# qammod

## Syntax

``Y = qammod(X,M)``
``Y = qammod(X,M,symOrder)``
``Y = qammod(___,Name=Value)``

## Description

example

````Y = qammod(X,M)` modulates input signal `X` by using QAM with the specified modulation order `M`.```

example

````Y = qammod(X,M,symOrder)` specifies the symbol order.```

example

````Y = qammod(___,Name=Value)` specifies options using name-value arguments in addition to any of the input argument combinations from previous syntaxes. For example, `InputType=bit` sets the type of input signal to bits.```

## Examples

collapse all

Modulate data using QAM and display the result in a scatter plot.

Set the modulation order to 16 and create a data vector containing each of the possible symbols.

```M = 16; x = (0:M-1)';```

Modulate the data using the `qammod` function.

`y = qammod(x,M);`

Display the modulated signal constellation using the `scatterplot` function.

`scatterplot(y)` Set the modulation order to 256, and display the scatter plot of the modulated signal.

```M = 256; x = (0:M-1)'; y = qammod(x,M); scatterplot(y)``` Modulate random data symbols using QAM. Normalize the modulator output so that it has an average signal power of 1 W.

Set the modulation order and generate random data.

```M = 64; x = randi([0 M-1],1000,1);```

Modulate the data. Use the `'UnitAveragePower'` name-value argument to set the output signal to have an average power of 1 W.

`y = qammod(x,M,UnitAveragePower=true);`

Confirm that the signal has unit average power.

`avgPower = mean(abs(y).^2)`
```avgPower = 1.0070 ```

Plot the resulting constellation.

```scatterplot(y) title('64-QAM, Average Power = 1 W')``` Plot QAM constellations for Gray, binary, and custom symbol mappings.

Set the modulation order, and create a data sequence that includes a complete set of symbols for the modulation scheme.

```M = 16; d = 0:M-1;```

Modulate the data, and plot its constellation. The default symbol mapping uses Gray-coded ordering. The ordering of the points is not sequential.

`y = qammod(d,M,PlotConstellation=true);` Repeat the modulation process with binary symbol mapping. The symbol mapping follows a binary-coded order and is sequential.

`z = qammod(d,M,'bin',PlotConstellation=true);` Create a custom symbol mapping.

`smap = randperm(M)-1;`

Modulate and plot the constellation.

`w = qammod(d,M,smap,PlotConstellation=true);` Modulate a sequence of bits using 64-QAM. Pass the signal through a noisy channel. Display the resultant constellation diagram.

Set the modulation order, and determine the number of bits per symbol.

```M = 64; k = log2(M);```

Create a binary data sequence. When using binary inputs, the number of rows in the input must be an integer multiple of the number of bits per symbol.

`data = randi([0 1],1000*k,1);`

Modulate the signal using bit inputs, and set it to have unit average power.

```txSig = qammod(data,M, ... InputType='bit', ... UnitAveragePower=true);```

Pass the signal through a noisy channel.

`rxSig = awgn(txSig,25);`

Plot the constellation diagram.

```cd = comm.ConstellationDiagram(ShowReferenceConstellation=false); cd(rxSig)``` Demodulate a fixed-point QAM signal and verify that the data is recovered correctly.

Set the modulation order as `64`, and determine the number of bits per symbol.

```M = 64; bitsPerSym = log2(M);```

Generate random bits. When operating in bit mode, the length of the input data must be an integer multiple of the number of bits per symbol.

`x = randi([0 1],10*bitsPerSym,1);`

Modulate the input data using a binary symbol mapping. Set the modulator to output fixed-point data. The numeric data type is signed with a 16-bit word length and a 10-bit fraction length.

```y = qammod(x,M,'bin', ... InputType='bit', ... OutputDataType=numerictype(1,16,10));```

Demodulate the 64-QAM signal. Verify that the demodulated data matches the input data.

```z = qamdemod(y,M,'bin',OutputType='bit'); s = isequal(x,double(z))```
```s = logical 1 ```

## Input Arguments

collapse all

Input signal, specified as a scalar, vector, matrix, or 3-D array. The elements of x must be binary values or integers in the range [0, (`M` – 1)], where `M` is the modulation order.

Note

To process input signal as binary elements, specify `InputType='bit'`. For binary inputs, the number of rows must be an integer multiple of log2(`M`). Groups of log2(`M`) bits are mapped onto a symbol, with the first bit representing the MSB and the last bit representing the LSB.

Data Types: `double` | `single` | `fi` | `int8` | `int16` | `uint8` | `uint16`

Modulation order, specified as an positive integer power of two. The modulation order specifies the number of points in the signal constellation.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Symbol order, specified as `'gray'`, `'bin'`, or a vector.

• `'gray'` — Use Gray-coded ordering. For more information, see Gray Code.

• `'bin'` — Use binary-coded ordering.

• Vector — Use custom symbol ordering

Vectors must use unique elements in the range [0, (`M` – 1)]. The first element corresponds to the upper-left point of the constellation, with subsequent elements running down column-wise from left to right.

Example: [0 3 1 2]

Data Types: `string` | `char` | `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

### Name-Value Arguments

Specify optional pairs of arguments as `Name1=Value1,...,NameN=ValueN`, where `Name` is the argument name and `Value` is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose `Name` in quotes.

Example: ```y = qammod(x,M,symOrder,'InputType','bit')```

Input type, specified as `'integer'` or `'bit'`.

• If you specify `'integer'`, the input signal must consist of integers in the range [0, (`M` – 1)].

• If you specify `'bit'`, the input signal must contain binary values, and the number of rows must be an integer multiple of log2(`M`).

Unit average power flag, specified as a numeric or logical `0` (`false`) or `1` (`true`).

• When this flag is `1` (`true`), the function scales the constellation to the average power of one watt referenced to 1 ohm.

• When this flag is `0` (`false`), the function scales the constellation so that the QAM constellation points are separated by a minimum distance of two.

Output data type, specified as a `numerictype` object. For more information on constructing these objects, see `numerictype` (Fixed-Point Designer).

• If you do not specify this property and the input is data type `double` or a built-in integer, the output data type is `double`.

• If the input is data type `single`, the output data type is `single`.

Option to plot constellation, specified as a numeric or logical `0` (`false`) or `1` (`true`). To plot the QAM constellation, specify `PlotConstellation=true`.

## Output Arguments

collapse all

Modulated signal, returned as a complex scalar, vector, matrix, or 3-D array of numeric values.

• For integer inputs, output `Y` has the same dimensions as input signal `X`.

• For bit inputs, the number of rows in `Y` is the number of rows in `X` divided by log2(`M`).

For more information on the output data type, see `OutputDataType`.

Data Types: `double` | `single` | `fi` | `int8` | `int16` | `uint8` | `uint16`

collapse all

### Gray Code

A Gray code, also known as a reflected binary code, is a system where the bit patterns in adjacent constellation points differ by only one bit.

## Version History

Introduced before R2006a

expand all