MATLAB Drive

+ workspace +

+ Current Folder +

+ Prototype +

New to MATLAB? See resources for Getting Started.

+ Command Window +

+ ### +

4 usages of "M" found

UTF-8

script

clear all;

% Create the FIR

D = 3; % Delay value

h = [zeros(1,D) 1]

x = (1:10)';

dfir = dsp.FIRFilter(h);

y = dfir(x)'

% Ideal Filter sequence

D = 0.4;

hIdeal = @(k) sinc(k-D);

% FIR approximation with causal shift

N = 6;

idxWindow = (-floor((N-1)/2):floor(N/2))';

i0 = -idxWindow(1); % Causal latency

hApprox = hIdeal(idxWindow);

plot_causal_fir("sinc",D,N,i0,hApprox,hIdeal);

% Filter parameters

FD = 0.4;

K = 7; % Polynomial degree

N = K+1; % FIR Length

idxWindow = (-floor((N-1)/2):floor(N/2))';

% Define and solve Lagrange interpolation equations

V = idxWindow.^(0:K); % Vandermonde structure

C = FD.^(0:K);

hLagrange = C/V; % Solve for the coefficients

i0 = -idxWindow(1); % Causal latency

plot_causal_fir("Lagrange",FD,N,i0,hLagrange);

DBPSK Empirical Versus Theoretical Performance in Fading Conditions

This example creates a frequency-flat Rayleigh fading channel object and calls it to process a DBPSK signal consisting of a single vector. Bit error rate is computed for different values of the signal-to-noise ratio. The fading channel filter is applied before AWGN. This is the recommended sequence to use when you combine fading with AWGN.

Create Rayleigh fading channel, modulator, and demodulator objects

chan = comm.RayleighChannel('SampleRate',1e4,'MaximumDopplerShift',100);

Create DBPSK modulator and demodulator objects with the modulation order set to 2. Generate DBPSK modulated data and pass it through the channel.

M = 2; % DBPSK modulation order
tx = randi([0 M-1],50000,1); % Generate a random bit stream
mod = comm.DBPSKModulator;
demod = comm.DBPSKDemodulator;
dpskSig = mod(tx);
fadedSig = chan(dpskSig); % Apply the channel effects

Create an AWGN channel object and an error rate calculator object.

awgnChan = comm.AWGNChannel('NoiseMethod', 'Signal to noise ratio (SNR)');
errorCalc = comm.ErrorRate;

Compute error rate for different values of SNR.

SNR = 0:2:20; % Range of SNR values, in dB.
numSNR = length(SNR);
berVec = zeros(3, numSNR); % Preallocate a vector for BER results 
for n = 1:numSNR
   awgnChan.SNR = SNR(n);
   rxSig = awgnChan(fadedSig); % Add Gaussian noise
   rx = demod(rxSig);  % Demodulate
   reset(errorCalc)
  
   berVec(:,n) = errorCalc(tx,rx); % Compute error rate.
end
BER = berVec(1,:);

Compute theoretical performance results, for comparison.

BERtheory = berfading(SNR,'dpsk',M,1);

Plot BER results.

semilogy(SNR,BERtheory,'b-',SNR,BER,'r*');

legend('Theoretical BER','Empirical BER');

xlabel('SNR (dB)'); ylabel('BER');

title('Binary DPSK over Rayleigh Fading Channel');

Work with Channel Filter Delays

The value of a channel object's ChannelFilterDelay property is the number of samples by which the output of the channel lags the input. If you compare the input and output data sets directly, you must take the delay into account by using appropriate truncating or padding operations.

The example illustrates a way to account for the delay before computing a bit error rate.

Create DBPSK modulator and demodulator objects with the modulation order set to 2. Generate DBPSK modulated data and pass it through the channel.

bitRate = 50000;
M = 2; % DQPSK modulation order
mod = comm.DBPSKModulator;
demod = comm.DBPSKDemodulator;

Create Rayleigh fading channel object.

rayChan = comm.RayleighChannel('SampleRate',bitRate,'MaximumDopplerShift',4,...
    'PathDelays',[0 0.5/bitRate],'AveragePathGains',[0 -10]);
chInfo = info(rayChan);
delay = chInfo.ChannelFilterDelay;

Generate random bit stream data. Modulate the data, pass it through the fading channel, and demodulate it.

tx = randi([0 M-1],50000,1);
dpskSig = mod(tx);
fadedSig = rayChan(dpskSig);
rx = demod(fadedSig);

Compute bit error rate, taking delay into account.

errorCalc = comm.ErrorRate('ReceiveDelay', delay);
berVec = step(errorCalc,tx,rx);
ber = berVec(1)
ber = 0.0157
num = berVec(2)
num = 784

Quasi-Static Channel Modeling

Typically, a path gain in a fading channel changes insignificantly over a period of 1/(100fd) seconds, where fd is the maximum Doppler shift. Because this period corresponds to a very large number of bits in many modern wireless data applications, assessing performance over a statistically significant range of channel fading requires simulating a prohibitively large amount of data. This example illustrates the quasi-static channel modeling approach to gathering a statistically significant number of errors. Quasi-static channel modeling provides a more tractable approach, which you can implement using these steps:

Generate a random channel realization using a maximum Doppler shift of 0.
Process some large number of bits.
Compute error statistics.
Repeat these steps many times to produce a distribution of the performance metric.

Create modulator and demodulator system objects with a modulation order of 4.

M = 4;
dpskMod = comm.DPSKModulator('ModulationOrder',M);
dpskDemod = comm.DPSKDemodulator('ModulationOrder',M);
numBits = 10000; % Each trial uses 10000 bits
numTrials = 20;  % Number of BER computations

Typically, numTrials would be a large number to get an accurate estimate of outage probabilities or packet error rate. Use 20 here just to make the example run more quickly.

Create a Rician channel object and set the maximum Doppler shift to zero.

ricianChan = comm.RicianChannel('KFactor',3,'MaximumDopplerShift',0);

Within a for loop, generate a random bit stream, DPSK modulate the signal, filter the modulated signal through a Rician fading and AWGN channels, and demodulate the faded signal. For the symbol error rate computation on each packet, ignore the first sample because of DPSK initial condition.

nErrors = zeros(1,numTrials);
for n = 1:numTrials
   tx = randi([0 M-1],numBits,1);            % Generate random bit stream
   dpskSig = dpskMod(tx);                    % DPSK modulate signal
   fadedSig = ricianChan(dpskSig);           % Apply channel effects
   rxSig = awgn(fadedSig,15,'measured');     % Add Gaussian noise
   rx = dpskDemod(rxSig);                    % Demodulate
   nErrors(n) = symerr(tx(2:end),rx(2:end)); % Symbol error computation, beginning with sample index 2 
end

After the for loop ends, display the list of symbol error counts in the vector nErrors and a computation of the packet error rate. Run to run results vary due to randomness in the example.

nErrors
nErrors = 1×20
 Rows 1: | Columns 1:20
     0     0     1     0     0     0     1     0     1     0     0     0     0     0     0     2     0     0     0     1
+
per = mean(nErrors > 0) % Proportion of packets that had errors
per = 0.2500

Create a channel object

% rayChan = comm.RayleighChannel('SampleRate',100000,'MaximumDopplerShift',130,...
%     'PathDelays',[0 1.5e-5 3.2e-5],'AveragePathGains',[0, -3, -3],...
%     'Visualization','Impulse response');

Generate a bit stream and create a modulator object. Modulate the bit stream and pass the

modulated DBPSK signal through the channel by calling the channel object.

% tx = randi([0 1],500,1);
% dbspkMod = comm.DBPSKModulator;
% dpskSig = dbspkMod(tx);
% y = rayChan(dpskSig);

Rayleigh Fading Channel

% rayChan = comm.RayleighChannel('SampleRate',10000,'MaximumDopplerShift',100);
% sig = j*ones(2000,1); % Signal
% out = rayChan(sig); % Pass signal through channel.
% rayChan % Display all properties of the channel object.
% plot(20*log10(abs(out)))

Channel Filtering Using For Loop

bitRate = 50000; % Data rate is 50 kb/s

numTrials = 125; % Number of iterations of loop

M = 4; % QPSK modulation order

qpskMod = comm.QPSKModulator;

rayChan = comm.RayleighChannel('SampleRate',bitRate,'MaximumDopplerShift',4,'PathDelays',[0 2e-5],'AveragePathGains',[0 -9]);

rayChan.Visualization = 'Impulse response' % Enables the impulse response channel visualization

rayChan =

comm.RayleighChannel with properties: + + SampleRate: 50000 + PathDelays: [0 2.0000e-05] + AveragePathGains: [0 -9] + NormalizePathGains: true + MaximumDopplerShift: 4 + DopplerSpectrum: [1×1 struct] + ChannelFiltering: true + PathGainsOutputPort: false + + Show all properties +

g = rayChan.AveragePathGains % Retrieve the AveragePathGains property of rayChan

g = 1×2

0 -9 +

scatterPlot = comm.ConstellationDiagram;

rng(0)

for n = 1:numTrials

tx = randi([0 M-1],500,1); % Generate random bit stream

pskSig = qpskMod(tx); % PSK modulate signal

fadedSig = rayChan(pskSig); % Apply channel effects

% Plot the new data from this iteration.

update(scatterPlot,fadedSig);

end

●

+ Test_Fading.mlx### +

+ Test_delay.m +

+ DBPSKEmpiricalVersusTheoreticalInFadingConditionsExample.mlx +

+ WorkWithChannelFilterDelaysExample.mlx +

+ QuasiStaticChannelModelingExample.mlx +

+ Test_Fading.mlx +

+ + ▼ +

+ + ◀ +

+ + ▶ +

Home

Plots

Apps

Live Editor

Insert

View

File

Variable

Code

Simulink

Environment

Resources

File

Optimization

Set up and solve optimization problems (optimtool)

Signal Analyzer

View, analyze, and compare signals (signalAnalyzer)

Curve Fitting

Fit curves and surfaces to data (cftool)

PID Tuner

Tune PID controllers (pidTuner)

Classification Learner

Train models to classify data using supervised machine learning (classificationLearner)

Deep Network Designer

Design, visualize, and train deep learning networks (deepNetworkDesigner)

Experiment Manager

Design and run experiments to train and compare deep learning networks (experimentManager)

+ +

Apps

File

Navigate

Text

Code

Section

Run

Sara