comm.RectangularQAMDemodulator

(To be removed) Demodulate using rectangular QAM signal constellation

comm.RectangularQAMDemodulator will be removed in a future release. Use qamdemod instead. For more information, see Compatibility Considerations.

Description

The RectangularQAMDemodulator object demodulates a signal that was modulated using quadrature amplitude modulation with a constellation on a rectangular lattice.

To demodulate a signal that was modulated using quadrature amplitude modulation:

Define and set up your rectangular QAM demodulator object. See Construction.
Call step to demodulate the signal according to the properties of comm.RectangularQAMDemodulator. The behavior of step is specific to each object in the toolbox.

Note

Starting in R2016b, instead of using the step method to perform the operation defined by the System object™, you can call the object with arguments, as if it were a function. For example, y = step(obj,x) and y = obj(x) perform equivalent operations.

Construction

H = comm.RectangularQAMDemodulator creates a demodulator System object, H. This object demodulates the input signal using the rectangular quadrature amplitude modulation (QAM) method.

H = comm.RectangularQAMDemodulator(Name,Value) creates a rectangular QAM demodulator object, H, with each specified property set to the specified value. You can specify additional name-value pair arguments in any order as (Name1,Value1,...,NameN,ValueN).

H = comm.RectangularQAMDemodulator(M,Name,Value) creates a rectangular QAM demodulator object, H. This object has the ModulationOrder property set to M, and the other specified properties set to the specified values.

Properties

`ModulationOrder`	Number of points in signal constellation Specify the number of points in the signal constellation as scalar value with a positive, integer power of two. The default is `16`.
`PhaseOffset`	Phase offset of constellation Specify the phase offset of the signal constellation, in radians, as a real scalar value. The default is `0`.
`BitOutput`	Output data as bits Specify whether the output consists of groups of bits or integer symbol values. When you set this property to true the step method outputs a column vector of bit values whose length equals log2(`ModulationOrder`) times the number of demodulated symbols. When you set this property to `false`, the `step` method outputs a column vector with a length equal to the input data vector. This vector contains integer symbol values between `0` and `ModulationOrder`-`1`. The default is `false`.
`SymbolMapping`	Constellation encoding Specify how the object maps an integer or group of log2(`ModulationOrder`) bits to the corresponding symbol as one of `Binary` \| `Gray` \| `Custom`. The default is `Gray`. When you set this property to `Gray`, the object uses a Gray-coded signal constellation. When you set this property to `Binary`, the object uses a natural binary-coded constellation. When you set this property to `Custom`, the object uses the signal constellation defined in the `CustomSymbolMapping` property.
`CustomSymbolMapping`	Custom constellation encoding Specify a custom constellation symbol mapping vector. The default is `0:15`. This property is a row or column vector with a size of `ModulationOrder` and with unique integer values in the range [`0`, `ModulationOrder`-`1`]. The values must be of data type `double`. The first element of this vector corresponds to the top-leftmost point of the constellation, with subsequent elements running down column-wise, from left to right. The last element corresponds to the bottom-rightmost point. This property applies when you set the `SymbolMapping` property to `Custom`.
`NormalizationMethod`	Constellation normalization method Specify the method used to normalize the signal constellation as `Minimum distance between symbols` \| `Average power` \| `Peak power`. The default is `Minimum distance between symbols`.
`MinimumDistance`	Minimum distance between symbols Specify the distance between two nearest constellation points as a positive, real, numeric scalar value. The default is `2`. This property applies when you set the `NormalizationMethod` property to `Minimum distance between symbols`.
`AveragePower`	Average power of constellation Specify the average power of the symbols in the constellation as a positive, real, numeric scalar value. The default is `1`. This property applies when you set the `NormalizationMethod` property to `Average power`.
`PeakPower`	Peak power of constellation Specify the maximum power of the symbols in the constellation as a positive, real, numeric scalar value. The default is `1`. This property applies when you set the `NormalizationMethod` property to `Peak power`.
`DecisionMethod`	Demodulation decision method Specify the decision method the object uses as `Hard decision` \| `Log-likelihood ratio` \| `Approximate log-likelihood ratio`. The default is `Hard decision`. When you set the `BitOutput` property to `false` the object always performs hard-decision demodulation. This property applies when you set the `BitOutput` property to `true`.
`VarianceSource`	Source of noise variance Specify the source of the noise variance as `Property` \| `Input port`. The default is `Property`. This property applies when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Log-likelihood ratio` or `Approximate log-likelihood ratio`.
`Variance`	Noise variance Specify the variance of the noise as a positive, real scalar value. The default is `1`. If this value is very small (i.e., SNR is very high), log-likelihood ratio (LLR) computations may yield Inf or -Inf. This result occurs because the LLR algorithm computes the exponential of very large or very small numbers using finite-precision arithmetic. In such cases, using approximate LLR is recommended because its algorithm does not compute exponentials. This property applies when you set the `BitOutput` property to `true`, the `DecisionMethod` property to `Log-likelihood ratio` or `Approximate log-likelihood ratio`, and the `VarianceSource` property to `Property`. This property is tunable.
`OutputDataType`	Data type of output Specify the output data type as `Full precision` \| `Smallest unsigned integer` \| `double` \| `single` \| `int8` \| `uint8` \| `int16` \| `uint16` \| `int32` \| `uint32`. The default is `Full precision`. This property applies only when you set the `BitOutput` property to `false` or when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard decision`. In this case, when the `OutputDataType` property is set to `Full precision`, and the input data type is single- or double-precision, the output data has the same data type as the input. When the input data is of a fixed-point type, the output data type behaves as if you had set the `OutputDataType` property to `Smallest unsigned integer`. When you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard Decision`, then `logical` data type becomes a valid option. When you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Log-likelihood ratio` or `Approximate log-likelihood ratio`, the output data type is the same as that of the input. In this case, that data type can only be single- or double-precision.

Fixed-Point Properties

`FullPrecisionOverride`	Full precision override for fixed-point arithmetic Specify whether to use full precision rules. If you set `FullPrecisionOverride` to `true`, which is the default, the object computes all internal arithmetic and output data types using full precision rules. These rules provide the most accurate fixed-point numerics. It also turns off the display of other fixed-point properties because they do not apply individually. These rules guarantee that no quantization occurs within the object. Bits are added, as needed, to ensure that no roundoff or overflow occurs. If you set `FullPrecisionOverride` to `false`, fixed-point data types are controlled through individual fixed-point property settings. For more information, see Full Precision for Fixed-Point System Objects.
`DerotateFactorDataType`	Data type of derotate factor Specify the derotate factor data type as `Same word length as input` \| `Custom`. The default is `Same word length as input`. This property applies when you set the `BitOutput` property to false, or when you set the `BitOutput` property to true and the `DecisionMethod` property to `Hard decision`. The object uses the derotate factor in the computations only when the step method input is of a fixed-point type and the `PhaseOffset` property has a value that is not a multiple of $\frac{π}{2}$ .
`CustomDerotateFactorDataType`	Fixed-point data type of derotate factor Specify the derotate factor fixed-point type as an unscaled `numerictype` (Fixed-Point Designer) object with a signedness of Auto. The default is `numerictype([],16)`. This property applies when you set the `DerotateFactorDataType` property to `Custom`.
`DenormalizationFactorDataType`	Data type of denormalization factor Specify the denormalization factor data type as `Same word length as input` \| `Custom`. The default is `Same word length as input`. This property applies when you set the `BitOutput` property to `false` or when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard decision`.
`CustomDenormalizationFactorDataType`	Fixed-point data type of denormalization factor Specify the denormalization factor fixed-point type as an unscaled `numerictype` (Fixed-Point Designer) object with a signedness of Auto. The default is `numerictype([],16)`. This property applies when you set the `DenormalizationFactorDataType` property to `Custom`.
`ProductDataType`	Data type of product Specify the product data type as `Full precision` \| `Custom`. The default is `Full precision`. This property applies when you set the `BitOutput` property to `false` or when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard decision`.
`CustomProductDataType`	Fixed-point data type of product Specify the product fixed-point type as an unscaled `numerictype` (Fixed-Point Designer) object with a signedness of Auto. The default is `numerictype([],32)`. This property applies when you set the `ProductDataType` property to `Custom`.
`ProductRoundingMethod`	Rounding of fixed-point numeric value of product Specify the product rounding method as `Ceiling` \| `Convergent` \| `Floor` \| `Nearest` \| `Round` \| `Simplest` \| `Zero`. The default is `Floor`. This property applies when the object is not in a full precision configuration, when you set the `BitOutput` property to `false` or when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard decision`.
`ProductOverflowAction`	Action when fixed-point numeric value of product overflows Specify the product overflow action as `Wrap` \| `Saturate`. The default is `Wrap`. This property applies when the object is not in a full precision configuration, when you set the `BitOutput` property to `false` or when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard decision`.
`SumDataType`	Data type of sum Specify the sum data type as `Full precision` \| `Same as product` \| `Custom`. The default is `Full precision`. This property applies when you set the `FullPrecisionOverride` property to false, when you set the `BitOutput` property to `false` or when you set the `BitOutput` property to `true` and the `DecisionMethod` property to `Hard decision`.
`CustomSumDataType`	Fixed-point data type of sum Specify the sum fixed-point type as an unscaled `numerictype` (Fixed-Point Designer) object with a signedness of Auto. The default is `numerictype([],32)`. This property applies when you set the `FullPrecisionOverride` property to false or when you set the `SumDataType` property `Custom`.

Methods

constellation	(To be removed) Calculate or plot ideal signal constellation
step	(To be removed) Demodulate using rectangular QAM method

Common to All System Objects
`release`	Allow System object property value changes

More About

expand all

Full Precision for Fixed-Point System Objects

FullPrecisionOverride is a convenience property that, when you set to true, automatically sets the appropriate properties for an object to use full-precision to process fixed-point input.

For System objects, full precision, fixed-point operation refers to growing just enough additional bits to compute the ideal full precision result. This operation has no minimum or maximum range overflow nor any precision loss due to rounding or underflow. It is also independent of any hardware-specific settings. The data types chosen are based only on known data type ranges and not on actual numeric values. Full precision for System objects does not optimize coefficient values. When you set the FullPrecisionOverride property to true, the other fixed-point properties it controls no longer apply and any of their non-default values are ignored. These properties are also hidden. To specify individual fixed-point properties, first set FullPrecisionOverride to false.

Algorithms

This object implements the algorithm, inputs, and outputs described on the Rectangular QAM Demodulator Baseband block reference page. The object properties correspond to the block parameters.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

See System Objects in MATLAB Code Generation (MATLAB Coder).

Version History

Introduced in R2012a

expand all

R2018b: `comm.RectangularQAMDemodulator` will be removed in a future release. Use `qamdemod` instead.

Constellation normalization by PeakPower and AveragePower (other than unit average power) as supported by comm.RectangularQAMModulator and comm.RectangularQAMDemodulator is not inherently provided by functions. To perform peak power and average power normalization using qammod and qamdemod functions, you can use these utility functions to scale symbols from peak or average power normalization to minimum distance normalization.

function minD = pkPow2MinD(pkPow,M)
% Peak power to minimum distance
    nBits = log2(M);
    if (mod(nBits,2)==0)
        % Square QAM
        sf = 0.5*M - sqrt(M) + 0.5;
    else
        % Cross QAM
        mBy32 = M/32;
        if (nBits > 4)
            sf = (13 * mBy32) - (5 * sqrt(mBy32)) + 0.5;
        else
            sf = (20 * mBy32) - (6 * sqrt(mBy32)) + 0.5;
        end
    end
    minD = sqrt(pkPow/sf);
end

function minD = avgPow2MinD(avgPow,M)
% Average power to minimum distance
    nBits = log2(M);
    if (mod(nBits,2)==0)
        % Square QAM
        sf = (M - 1)/6;
    else
        % Cross QAM
        if (nBits > 4)
            sf = ((31 * M / 32) - 1) / 6;
        else
            sf = ((5 * M / 4) - 1) / 6;
        end
    end
    minD = sqrt(avgPow/sf);
end

Peak Power Normalization for Hard Decision

Average Power Normalization for Hard Decision

Peak Power Normalization for Approximate LLR

Output shown here compares computation of peak power normalization for approximate LLR by using the qammod and qamdemod functions and the pkPow2MinD utility function.

% QAM alternative for "Peak power" normalization method for
% Approximate LLR output when using functions.
%
% Modulation order must be supported by QAM modulator-demodulator.
M = 256;     % Modulation order
pkPow = 221; % Peak constellation power
snrdB=16;    % SNR in dB

minD = pkPow2MinD(pkPow,M);

modObj = comm.RectangularQAMModulator('ModulationOrder',M, ...
    'NormalizationMethod','Peak power', ...
    'PeakPower',pkPow);

% Check 1 - Verify that the two constellations are same by 
% comparing symbols.
constellationSO = modObj((0:M-1)');
constellationFcn = qammod((0:M-1)',M);
scaledConstellationFcn = (minD/2) .* constellationFcn;
err = constellationSO - scaledConstellationFcn;
maxConstellationErr = max(abs(err))

maxConstellationErr =
     0

x = randi([0,M-1],100,1);
y1 = modObj(x);;
    

% Reset global rng stream for repeatable noise samples, then add noise
reset(RandStream.getGlobalStream);
y1Rec = awgn(y1,snrdB,'measured','db');

% Compute noise variance to use when demodulating.
nv = mean(abs(y1).^2) / 10^(snrdB/10);

demodObj = comm.RectangularQAMDemodulator('ModulationOrder',M, ...
    'NormalizationMethod','Peak power', ...
    'PeakPower',pkPow, ...
    'BitOutput',true, ...
    'DecisionMethod','Approximate log-likelihood ratio', ...
    'Variance',nv);
    
    z1 = demodObj(y1Rec);

% With proper scaling, the demodulated output from the function 
% is the same as that from the System object.
y2 = qammod(x,M);
% Scale function output so that it matches System object output.
y2Scaled = (minD/2) .* y2;

% Reset global rng stream for repeatable noise samples, then add noise.
reset(RandStream.getGlobalStream);
y2Rec = awgn(y2Scaled,snrdB,'measured','db');

% Compute noise variance to use when demodulating.
nv1 = mean(abs(y2Scaled).^2) / 10^(snrdB/10);

% Scale the received signal for the constellation used by function
y2RecScaled = (2/minD) .* y2Rec;
% Scale the noise variance appropriately.
z2 = qamdemod(y2RecScaled,M,'OutputType','approxllr', ...
    'NoiseVariance',nv1 * (2/minD)^2);

% Check 2 - Compare deomodulated output from System object and function is minimal.
maxOutputErr = max(abs(z1-z2))

maxOutputErr =
   2.8422e-14

Average Power Normalization for Approximate LLR

This example compares computation of average power normalization for approximate LLR by using the qammod and qamdemod functions and the avgPow2MinD utility function.

% QAM alternative for "Average power" normalization method for
% Approximate LLR output when using functions.
%
% Modulation order must be supported by QAM modulator-demodulator.
M = 1024;    % Modulation order
avgPow = 87; % Average constellation power
snrdB = 33;  % Signal-to-Noise Ratio in dB

minD = avgPow2MinD(avgPow,M);

modObj = comm.RectangularQAMModulator('ModulationOrder',M, ...
    'NormalizationMethod','Average power', ...
    'AveragePower',avgPow);

% Check 1 - Verify that the two constellations are same by 
% comparing symbols.
constellationSO = modObj((0:M-1)');
constellationFcn = qammod((0:M-1)',M);
scaledConstellationFcn = (minD/2) .* constellationFcn;
err = constellationSO - scaledConstellationFcn;
maxConstellationErr = max(abs(err))

maxConstellationErr =
     0

x = randi([0,M-1],100,1);
y1 = modObj(x);

% Reset global rng stream for repeatable noise samples, then add noise
reset(RandStream.getGlobalStream);
y1Rec = awgn(y1,snrdB,'measured','db');

% Compute noise variance to use when demodulating.
nv = mean(abs(y1).^2) / 10^(snrdB/10);

demodObj = comm.RectangularQAMDemodulator('ModulationOrder',M, ...
    'NormalizationMethod','Average power', ...
    'AveragePower',avgPow, ...
    'BitOutput',true, ...
    'DecisionMethod','Approximate log-likelihood ratio', ...
    'Variance',nv);

z1 = demodObj(y1Rec);

% With proper scaling, the demodulated output from the function 
% is the same as that from the System object.
y2 = qammod(x,M);
% Scale function output so that it matches System object output.
y2Scaled = (minD/2) .* y2;

% Reset global rng stream for repeatable noise samples, then add noise.
reset(RandStream.getGlobalStream);
y2Rec = awgn(y2Scaled,snrdB,'measured','db');
% Compute noise variance to use when demodulating.
nv1 = mean(abs(y2Scaled).^2) / 10^(snrdB/10);

% Scale the received signal for the constellation used by function
y2RecScaled = (2/minD) .* y2Rec;
% Scale the noise variance appropriately.
z2 = qamdemod(y2RecScaled,M,'OutputType','approxllr', ...
    'NoiseVariance',nv1 * (2/minD)^2);

% Check 2 - Compare deomodulated output from System object and function is minimal.
maxOutputErr = max(abs(z1-z2))

maxOutputErr =
   1.3642e-12

Peak Power Normalization for LLR

Output shown here compares computation of peak power normalization for LLR by using the qammod and qamdemod functions and the pkPow2MinD utility function.

% QAM alternative for "Peak power" normalization method for
% LLR output when using functions.
%
% Modulation order must be supported by QAM modulator-demodulator.
M = 1024;  % Modulation order
pkPow = 1; % Peak constellation power
snrdB=6;   % SNR in dB

minD = pkPow2MinD(pkPow,M);

modObj = comm.RectangularQAMModulator('ModulationOrder',M, ...
    'NormalizationMethod','Peak power', ...
    'PeakPower',pkPow);

% Check 1 - Verify that the two constellations are same by 
% comparing symbols.
constellationSO = modObj((0:M-1)');
constellationFcn = qammod((0:M-1)',M);
scaledConstellationFcn = (minD/2) .* constellationFcn;
err = constellationSO - scaledConstellationFcn;
maxConstellationErr = max(abs(err))

maxConstellationErr =
     0

x = randi([0,M-1],100,1);
% Modulate and demodulate using the System objects
y1 = modObj(x);;

% Reset global rng stream for repeatable noise samples, then add noise
reset(RandStream.getGlobalStream);
y1Rec = awgn(y1,snrdB,'measured','db');

% Compute noise variance to use when demodulating.
nv = mean(abs(y1).^2) / 10^(snrdB/10);

demodObj = comm.RectangularQAMDemodulator('ModulationOrder',M, ...
    'NormalizationMethod','Peak power', ...
    'PeakPower',pkPow, ...
    'BitOutput',true, ...
    'DecisionMethod','Log-likelihood ratio', ...
    'Variance',nv);
    
    z1 = demodObj(y1Rec);

% Modulate and demodulate using the functions
y2 = qammod(x,M);
% Scale function output so that it matches System object output.
y2Scaled = (minD/2) .* y2;

% Reset global rng stream for repeatable noise samples, then add noise.
reset(RandStream.getGlobalStream);
y2Rec = awgn(y2Scaled,snrdB,'measured','db');

% Compute noise variance to use when demodulating.
nv1 = mean(abs(y2Scaled).^2) / 10^(snrdB/10);

% Create inputs required by utility function to compute LLR
nBits = log2(M);
bitwiseMapping = (int2bit((0:M-1),nBits))';
% c0 contains indices of mapping which has 0 at various bit positions
[c0, ~] = find(bitwiseMapping==0);
c0 = reshape(int32(c0),M/2,nBits);
% c1 contains indices of mapping which has 1 at various bit positions
[c1, ~] = find(bitwiseMapping==1);
c1 = reshape(int32(c1),M/2,nBits);

z2 = comm.internal.utilities.computeLLRsim(y2Rec,M,nBits, ...
    scaledConstellationFcn,c0,c1,nv1);

% Check 2 - Compare deomodulated output from System object and function is minimal.
maxOutputErr = max(abs(z1-z2))

maxOutputErr =
   3.5527e-15

Average Power Normalization for LLR

This example compares computation of average power normalization for LLR by using the qammod and qamdemod functions and the avgPow2MinD utility function.

% QAM alternative for "Average power" normalization method for
% LLR output when using functions.
%
% Modulation order must be supported by QAM modulator-demodulator.
M = 1024;    % Modulation order
avgPow = 117; % Average constellation power
snrdB = 8;  % Signal-to-Noise Ratio in dB

minD = avgPow2MinD(avgPow,M);

modObj = comm.RectangularQAMModulator('ModulationOrder',M, ...
    'NormalizationMethod','Average power', ...
    'AveragePower',avgPow);

% Check 1 - Verify that the two constellations are same by 
% comparing symbols.
constellationSO = modObj((0:M-1)');
constellationFcn = qammod((0:M-1)',M);
scaledConstellationFcn = (minD/2) .* constellationFcn;
err = constellationSO - scaledConstellationFcn;
maxConstellationErr = max(abs(err))

maxConstellationErr =
     0

x = randi([0,M-1],100,1);
y1 = modObj(x);

% Reset global rng stream for repeatable noise samples, then add noise
reset(RandStream.getGlobalStream);
y1Rec = awgn(y1,snrdB,'measured','db');

% Compute noise variance to use when demodulating.
nv = mean(abs(y1).^2) / 10^(snrdB/10);

demodObj = comm.RectangularQAMDemodulator('ModulationOrder',M, ...
    'NormalizationMethod','Average power', ...
    'AveragePower',avgPow, ...
    'BitOutput',true, ...
    'DecisionMethod','Log-likelihood ratio', ...
    'Variance',nv);

z1 = demodObj(y1Rec);

% With proper scaling, the demodulated output from the function 
% is the same as that from the System object.
y2 = qammod(x,M);
% Scale function output so that it matches System object output.
y2Scaled = (minD/2) .* y2;

% Reset global rng stream for repeatable noise samples, then add noise.
reset(RandStream.getGlobalStream);
y2Rec = awgn(y2Scaled,snrdB,'measured','db');
% Compute noise variance to use when demodulating.
nv1 = mean(abs(y2Scaled).^2) / 10^(snrdB/10);

% Create inputs required by utility function to compute LLR
nBits = log2(M);
bitwiseMapping = (int2bit((0:M-1),nBits))';
% c0 contains indices of mapping which has 0 at various bit positions
[c0, ~] = find(bitwiseMapping==0);
c0 = reshape(int32(c0),M/2,nBits);
% c1 contains indices of mapping which has 1 at various bit positions
[c1, ~] = find(bitwiseMapping==1);
c1 = reshape(int32(c1),M/2,nBits);

z2 = comm.internal.utilities.computeLLRsim(y2Rec,M,nBits, ...
    scaledConstellationFcn,c0,c1,nv1);

% Check 2 - Compare deomodulated output from System object and function is minimal.
maxOutputErr = max(abs(z1-z2))

maxOutputErr =
   1.3642e-12

comm.RectangularQAMDemodulator

Description

Construction

Properties

Methods

More About

Full Precision for Fixed-Point System Objects

Algorithms

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Version History

R2018b: `comm.RectangularQAMDemodulator` will be removed in a future release. Use `qamdemod` instead.

See Also

Functions

Objects

comm.RectangularQAMDemodulator

Description

Construction

Properties

Methods

More About

Full Precision for Fixed-Point System Objects

Algorithms

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

Version History

R2018b: comm.RectangularQAMDemodulator will be removed in a future release. Use qamdemod instead.

See Also

Functions

Objects

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

R2018b: `comm.RectangularQAMDemodulator` will be removed in a future release. Use `qamdemod` instead.