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.

Compatibility Considerations

expand all

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

Not recommended starting in R2018b

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. This code shows you how to perform peak power and average power normalization using qammod and qamdemod functions.

Average Power Normalization for Hard Decision

Output shown here compares computation of average power normalization for hard decision using alternative approach. Functions used follow the output.

>> averagePowerReplacement(64)
maxConstellationErr =
     0
objModDemodOutputIsEqual =
  logical
   1
objModFcnDemodIsEqual =
  logical
   1
fcnModObjDemodIsEqual =
  logical
   1

>> averagePowerReplacement(32)
maxConstellationErr =
     0
objModDemodOutputIsEqual =
  logical
   1
objModFcnDemodIsEqual =
  logical
   1
fcnModObjDemodIsEqual =
  logical
   1

Functions shown here compares computation of average power normalization for hard decision using alternative approach.

function averagePowerReplacement(M)
% QAM alternative for "Average power" normalization method when using functions
    
    avgPow = 100;
    minD = avgPow2MinD(avgPow, M);
    
    modObj = comm.RectangularQAMModulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Average power', ...
        'AveragePower', avgPow);
    demodObj = comm.RectangularQAMDemodulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Average power', ...
        'AveragePower', avgPow);
    
    % 1) The two constellations are same
    constellationSO = modObj([0:M-1]');
    constellationFcn = qammod([0:M-1]', M);
    scaledConstellationFcn = (minD/2) .* constellationFcn;
    err = constellationSO - scaledConstellationFcn;
    maxConstellationErr = max(abs(err))
    
    x = randi([0, M-1], 100, 1);
    
    y1 = modObj(x);
    z1 = demodObj(y1);
    objModDemodOutputIsEqual = isequal(x, z1)
    
    % 2) qamdemod() demodulates modulator System object output
    y1ScaledForFcn = (2/minD) .* y1;
    z2 = qamdemod(y1ScaledForFcn, M);
    objModFcnDemodIsEqual = isequal(x, z2)
    
    % 3) Demodulator System object demodulates qammod() output
    y2 = qammod(x, M);
    y2ScaledForSO = (minD/2) .* y2;
    z3 = demodObj(y2ScaledForSO);
    fcnModObjDemodIsEqual = isequal(x, z3)
    
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

Output shown here compares computation of peak power normalization for hard decision using alternative approach. Functions used follow the output.

>> peakPowerReplacement(16)
maxConstellationErr =
     0
objModDemodOutputIsEqual =
  logical
   1
objModFcnDemodIsEqual =
  logical
   1
fcnModObjDemodIsEqual =
  logical
   1

>> peakPowerReplacement(128)
maxConstellationErr =
     0
objModDemodOutputIsEqual =
  logical
   1
objModFcnDemodIsEqual =
  logical
   1
fcnModObjDemodIsEqual =
  logical
   1

Functions shown here compares computation of peak power normalization for hard decision using alternative approach.

function peakPowerReplacement(M)
% QAM alternative for "Peak power" normalization method when using functions
    
    pkPow = 5;
    minD = pkPow2MinD(pkPow, M);
    
    modObj = comm.RectangularQAMModulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Peak power', ...
        'PeakPower', pkPow);
    demodObj = comm.RectangularQAMDemodulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Peak power', ...
        'PeakPower', pkPow);
    
    % 1) The two constellations are same
    constellationSO = modObj([0:M-1]');
    constellationFcn = qammod([0:M-1]', M);
    scaledConstellationFcn = (minD/2) .* constellationFcn;
    err = constellationSO - scaledConstellationFcn;
    maxConstellationErr = max(abs(err))
    
    x = randi([0, M-1], 100, 1);
    
    y1 = modObj(x);
    z1 = demodObj(y1);
    objModDemodOutputIsEqual = isequal(x, z1)
    
    % 2) qamdemod() demodulates modulator System object output
    y1ScaledForFcn = (2/minD) .* y1;
    z2 = qamdemod(y1ScaledForFcn, M);
    objModFcnDemodIsEqual = isequal(x, z2)
    
    % 3) Demodulator System object demodulates qammod() output
    y2 = qammod(x, M);
    y2ScaledForSO = (minD/2) .* y2;
    z3 = demodObj(y2ScaledForSO);
    fcnModObjDemodIsEqual = isequal(x, z3)
    
end

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

Average Power Normalization for Approximate LLR

Output shown here compares computation of average power normalization for approximate LLR using alternative approach. Functions used follow the output.

>> averagePowerReplacementApproxLLR(16, 10, 1) % M=16, avgPow=10, snrdB=1
maxConstellationErr =
     0
maxOutputErr =
     0
>> averagePowerReplacementApproxLLR(32, 7, 20) % M=32, avgPow=7, snrdB=20
maxConstellationErr =
     0
maxOutputErr =
   8.5265e-14
>> averagePowerReplacementApproxLLR(64, 111, -2) % M=64, avgPow=111, snrdB=-2
maxConstellationErr =
     0
maxOutputErr =
   2.2204e-15
>> averagePowerReplacementApproxLLR(1024, 87, 33) % M=1024, avgPow=87, snrdB=33
maxConstellationErr =
     0
maxOutputErr =
   1.3642e-12

Functions shown here compares computation of average power normalization for approximate LLR using alternative approach.

function averagePowerReplacementApproxLLR(M, avgPow, snrdB)
% QAM alternative for "Average power" normalization method for
% Approximate LLR output when using functions
%
% M - Modulation order. Must be supported by QAM modulator-demodulator
% avgPow - Average constellation power
% snrdB - SNR, in dB. AWGN channel adds noise to provide this SNR. 
    
    minD = avgPow2MinD(avgPow, M);
    
    modObj = comm.RectangularQAMModulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Average power', ...
        'AveragePower', avgPow);
    
    % 1) The two constellations are same
    constellationSO = modObj((0:M-1)');
    constellationFcn = qammod((0:M-1)', M);
    scaledConstellationFcn = (minD/2) .* constellationFcn;
    err = constellationSO - scaledConstellationFcn;
    maxConstellationErr = max(abs(err))
    
    x = randi([0, M-1], 100, 1);
    
    y1 = modObj(x);
    
    % Add noise
    % Reset global rng stream for repeatable noise samples
    reset(RandStream.getGlobalStream);
    y1Rec = awgn(y1, snrdB, 'measured', 'db');
    
    % noise variance
    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);
    
    % 2) Functions' output is same as System objects' output, with right
    % scaling
    y2 = qammod(x, M);
    % Scale function's output so that it matches System object output. 
    y2Scaled = (minD/2) .* y2;
    
    % Add noise
    % Reset global rng stream for repeatable noise samples
    reset(RandStream.getGlobalStream);
    y2Rec = awgn(y2Scaled, snrdB, 'measured', 'db');

    % noise variance
    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);
    
    maxOutputErr = max(abs(z1-z2))     
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 Approximate LLR

Output shown here compares computation of peak power normalization for approximate LLR using alternative approach. Functions used follow the output.

>> peakPowerReplacementApproxLLR(4, 2.5, 7) % M=4, pkPow=2.5, snrdB=7
maxConstellationErr =
     0
maxOutputErr =
   7.1054e-15
>> peakPowerReplacementApproxLLR(16, 19, 0) % M=16, pkPow=19, snrdB=0
maxConstellationErr =
     0
maxOutputErr =
   4.4409e-15
>> peakPowerReplacementApproxLLR(128, 12, 4.4) % M=128, pkPow=12, snrdB=4.4
maxConstellationErr =
     0
maxOutputErr =
   2.6645e-15
>> peakPowerReplacementApproxLLR(256, 221, 16) % M=256, pkPow=221, snrdB=16
maxConstellationErr =
     0
maxOutputErr =
   2.8422e-14

Functions shown here compares computation of peak power normalization for approximate LLR using alternative approach.

function peakPowerReplacementApproxLLR(M, pkPow, snrdB)
% QAM alternative for "Peak power" normalization method for 
% Approximate LLR output when using functions
%
% M - Modulation order. Must be supported by QAM modulator-demodulator
% avgPow - Average constellation power
% snrdB - SNR, in dB. AWGN channel adds noise to provide this SNR.
    
    minD = pkPow2MinD(pkPow, M);
    
    modObj = comm.RectangularQAMModulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Peak power', ...
        'PeakPower', pkPow);
    
    % 1) The two constellations are same
    constellationSO = modObj((0:M-1)');
    constellationFcn = qammod((0:M-1)', M);
    scaledConstellationFcn = (minD/2) .* constellationFcn;
    err = constellationSO - scaledConstellationFcn;
    maxConstellationErr = max(abs(err))
    
    x = randi([0, M-1], 100, 1);
    
    y1 = modObj(x);
    
    % Add noise
    % Reset global rng stream for repeatable noise samples
    reset(RandStream.getGlobalStream);
    y1Rec = awgn(y1, snrdB, 'measured', 'db');

    % noise variance
    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);

    % 2) Functions' output is same as System objects' output, with right
    % scaling
    y2 = qammod(x, M);
    % Scale function's output so that it matches System object output. 
    y2Scaled = (minD/2) .* y2;

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

    % noise variance
    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);
    
    maxOutputErr = max(abs(z1-z2))
    
end

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

Average Power Normalization for LLR

Output shown here compares computation of average power normalization for LLR using alternative approach. Functions used follow the output.

>> averagePowerReplacementLLR(16, 20, 1) % M=16, avgPow=20, snrdB=1
maxConstellationErr =
     0
maxOutputErr =
   8.8818e-16
>> averagePowerReplacementLLR(32, 5.5, 15) % M=32, avgPow=5.5, snrdB=15
maxConstellationErr =
     0
maxOutputErr =
   7.1054e-15
>> averagePowerReplacementLLR(64, 100, -2) % M=64, avgPow=100, snrdB=-2
maxConstellationErr =
     0
maxOutputErr =
   8.8818e-16
>> averagePowerReplacementLLR(256, 117, 8) % M=256, avgPow=117, snrdB=8
maxConstellationErr =
     0
maxOutputErr =
   3.5527e-15

Functions shown here compares computation of average power normalization for LLR using alternative approach.

function averagePowerReplacementLLR(M, avgPow, snrdB)
% QAM alternative for "Average power" normalization method for
% LLR output when using functions
%
% M - Modulation order. Must be supported by QAM modulator-demodulator
% avgPow - Average constellation power
% snrdB - SNR, in dB. AWGN channel adds noise to provide this SNR. 
    
    minD = avgPow2MinD(avgPow, M);
    
    modObj = comm.RectangularQAMModulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Average power', ...
        'AveragePower', avgPow);
    
    % 1) The two constellations are same
    constellationSO = modObj((0:M-1)');
    constellationFcn = qammod((0:M-1)', M);
    scaledConstellationFcn = (minD/2) .* constellationFcn;
    err = constellationSO - scaledConstellationFcn;
    maxConstellationErr = max(abs(err))
    
    x = randi([0, M-1], 100, 1);
    
    y1 = modObj(x);
    
    % Add noise
    % Reset global rng stream for repeatable noise samples
    reset(RandStream.getGlobalStream);
    y1Rec = awgn(y1, snrdB, 'measured', 'db');
    
    % noise variance
    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);
    
    % 2) Get the same output as System object using functions
    y2 = qammod(x, M);
    % Scale function's output so that it matches System object output. 
    y2Scaled = (minD/2) .* y2;
    
    % Add noise
    % Reset global rng stream for repeatable noise samples
    reset(RandStream.getGlobalStream);
    y2Rec = awgn(y2Scaled, snrdB, 'measured', 'db');

    % noise variance
    nv1 = mean(abs(y2Scaled).^2) / 10^(snrdB/10);
    
    % Create inputs required by utility function to compute LLR
    nBits = log2(M);
    bitwiseMapping = de2bi((0:M-1)', nBits, 'left-msb');    
    % 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);       
    
    maxOutputErr = max(abs(z1-z2))
       
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 LLR

Output shown here compares computation of peak power normalization for LLR using alternative approach. Functions used follow the output.

>> peakPowerReplacementLLR(8, 21, 0) % M=8, pkPow=21, snrdB=0
maxConstellationErr =
     0
maxOutputErr =
   8.8818e-16
>> peakPowerReplacementLLR(64, 7, 22) % M=64, pkPow=7, snrdB=22
maxConstellationErr =
     0
maxOutputErr =
   7.1054e-15
>> peakPowerReplacementLLR(512, 1000, -5) % M=512, pkPow=1000, snrdB=-5
maxConstellationErr =
     0
maxOutputErr =
   2.6645e-15
>> peakPowerReplacementLLR(1024, 1, 6) % M=1024, pkPow=1, snrdB=6
maxConstellationErr =
     0
maxOutputErr =
   3.5527e-15

Functions shown here compares computation of peak power normalization for LLR using alternative approach.

function peakPowerReplacementLLR(M, pkPow, snrdB)
% QAM alternative for "Peak power" normalization method for
% LLR output when using functions
%
% M - Modulation order. Must be supported by QAM modulator-demodulator
% avgPow - Average constellation power
% snrdB - SNR, in dB. AWGN channel adds noise to provide this SNR.
    
    minD = pkPow2MinD(pkPow, M);
    
    modObj = comm.RectangularQAMModulator('ModulationOrder', M, ...
        'NormalizationMethod', 'Peak power', ...
        'PeakPower', pkPow);
    
    % 1) The two constellations are same
    constellationSO = modObj((0:M-1)');
    constellationFcn = qammod((0:M-1)', M);
    scaledConstellationFcn = (minD/2) .* constellationFcn;
    err = constellationSO - scaledConstellationFcn;
    maxConstellationErr = max(abs(err))
    
    x = randi([0, M-1], 100, 1);
    
    y1 = modObj(x);
    
    % Add noise
    % Reset global rng stream for repeatable noise samples
    reset(RandStream.getGlobalStream);
    y1Rec = awgn(y1, snrdB, 'measured', 'db');

    % noise variance
    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);

    % 2) Get the same output as System object using functions
    y2 = qammod(x, M);
    % Scale function's output so that it matches System object output. 
    y2Scaled = (minD/2) .* y2;

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

    % noise variance
    nv1 = mean(abs(y2Scaled).^2) / 10^(snrdB/10);
    
    % Create inputs required by utility function to compute LLR
    nBits = log2(M);
    bitwiseMapping = de2bi((0:M-1)', nBits, 'left-msb');    
    % 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);       
    
    maxOutputErr = max(abs(z1-z2))
end

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

Documentation

comm.RectangularQAMDemodulator

Description

Construction

Properties

Methods

More About

Full Precision for Fixed-Point System Objects

Algorithms

Compatibility Considerations

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

Extended Capabilities

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

See Also

Functions

Objects

Communications Toolbox Documentation

Support

Documentation

comm.RectangularQAMDemodulator

Description

Construction

Properties

Methods

More About

Full Precision for Fixed-Point System Objects

Algorithms

Compatibility Considerations

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

Extended Capabilities

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

See Also

Functions

Objects

Communications Toolbox Documentation

Support

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

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