Comm error rate

Note

To ensure an accurate error rate, you should typically simulate
enough data to produce at least 100 errors.

m = 3; n = 2^m-1; k = n-m; % Prepare to use Hamming code.
msg = randi([0 1],k*200,1); % 200 messages of k bits each
code = encode(msg,n,k,'hamming');
codenoisy = rem(code+(rand(n*200,1)>.95),2); % Add noise.
% Decode and correct some errors.
newmsg = decode(codenoisy,n,k,'hamming');
% Compute and display symbol error rates.
noisyVec = step(comm.ErrorRate,code,codenoisy);
decodedVec = step(comm.ErrorRate,msg,newmsg);
disp(['Error rate in the received code: ',num2str(noisyVec(1))])
disp(['Error rate after decoding: ',num2str(decodedVec(1))])

Error rate in the received code: 0.054286
Error rate after decoding: 0.03

a = [1 2 3]'; b = [1 4 4]';
format rat % Display fractions instead of decimals.
% Create ErrorRate Calculator System object
serVec = step(comm.ErrorRate,a,b);
srate = serVec(1)
snum = serVec(2)
% Convert integers to bits
hIntToBit = comm.IntegerToBit(3);
a_bit = step(hIntToBit, a);
b_bit = step(hIntToBit, b);
% Calculate BER
berVec = step(comm.ErrorRate,a_bit,b_bit);
brate = berVec(1)
bnum = berVec(2)

snum =

      2      


srate =

     2/3     


bnum =

      5      


brate =

     5/9  

• Any effects of multipath fading, quantization, and
  amplifier nonlinearities must precede the effects
  of noise in the actual channel being modeled.

• The receiver is perfectly synchronized with the carrier,
  and timing jitter is negligible. Because phase noise and timing jitter
  are slow processes, they reduce the applicability of the semianalytic
  technique to a communication system.

• The noiseless simulation has no errors in the received
  signal constellation. Distortions from sources other than noise should
  be mild enough to keep each signal point in its correct decision region.
  If this is not the case, the calculated BER is too low. For instance,
  if the modeled system has a phase rotation that places the received
  signal points outside their proper decision regions, the semianalytic
  technique is not suitable to predict system performance.

1. Generate a message signal containing at least M^L symbols,
   where M is the alphabet size of the modulation and L is the length
   of the impulse response of the channel in symbols. A common approach
   is to start with an augmented binary pseudonoise (PN) sequence of
   total length (log2M)ML.
   An augmented PN sequence is a PN sequence with
   an extra zero appended, which makes the distribution of ones and zeros
   equal.

2. Modulate a carrier with the message signal using baseband modulation.
   Supported modulation types are listed on the reference page for semianalytic.
   Shape the resultant signal with rectangular pulse shaping, using
   the oversampling factor that you will later use to filter the modulated
   signal. Store the result of this step as txsig for
   later use.

3. Filter the modulated signal with a transmit filter. This filter
   is often a square-root raised cosine filter, but you can also use
   a Butterworth, Bessel, Chebyshev type 1 or 2, elliptic, or more general
   FIR or IIR filter. If you use a square-root raised cosine filter,
   use it on the nonoversampled modulated signal and specify the oversampling
   factor in the filtering function. If you use another filter type,
   you can apply it to the rectangularly pulse shaped signal.

4. Run the filtered signal through a noiseless channel.
   This channel can include multipath fading effects, phase shifts,
   amplifier nonlinearities, quantization, and additional filtering,
   but it must not include noise. Store the result of this step as rxsig for
   later use.

5. Invoke the semianalytic function
   using the txsig and rxsig data
   from earlier steps. Specify a receive filter as a pair of input arguments,
   unless you want to use the function’s default filter. The function
   filters rxsig and then determines the error probability
   of each received signal point by analytically applying the Gaussian
   noise distribution to each point. The function averages the error
   probabilities over the entire received signal to determine the overall
   error probability. If the error probability calculated in this way
   is a symbol error probability, the function converts it to a bit error
   rate, typically by assuming Gray coding. The function returns the
   bit error rate (or, in the case of DQPSK modulation, an upper bound
   on the bit error rate).

% Step 1. Generate message signal of length >= M^L.
M = 16; % Alphabet size of modulation
L = 1; % Length of impulse response of channel
msg = [0:M-1 0]; % M-ary message sequence of length > M^L

% Step 2. Modulate the message signal using baseband modulation.
%hMod = comm.RectangularQAMModulator(M);  % Use 16-QAM.
%modsig = step(hMod,msg'); % Modulate data
modsig = qammod(msg',M); % Modulate data
Nsamp = 16;
modsig = rectpulse(modsig,Nsamp); % Use rectangular pulse shaping.

% Step 3. Apply a transmit filter.
txsig = modsig; % No filter in this example

% Step 4. Run txsig through a noiseless channel.
rxsig = txsig*exp(1i*pi/180); % Static phase offset of 1 degree
% Step 5. Use the semianalytic function.
% Specify the receive filter as a pair of input arguments.
% In this case, num and den describe an ideal integrator.
num = ones(Nsamp,1)/Nsamp;
den = 1;
EbNo = 0:20; % Range of Eb/No values under study
ber = semianalytic(txsig,rxsig,'qam',M,Nsamp,num,den,EbNo);

% For comparison, calculate theoretical BER.
bertheory = berawgn(EbNo,'qam',M);

% Plot computed BER and theoretical BER.
figure; semilogy(EbNo,ber,'k*');
hold on; semilogy(EbNo,bertheory,'ro');
title('Semianalytic BER Compared with Theoretical BER');
legend('Semianalytic BER with Phase Offset',...
   'Theoretical BER Without Phase Offset','Location','SouthWest');
hold off;

coderate = 1/4; % Code rate
% Create a structure dspec with information about distance spectrum.
dspec.dfree = 10; % Minimum free distance of code
dspec.weight = [1 0 4 0 12 0 32 0 80 0 192 0 448 0 1024 ...
   0 2304 0 5120 0]; % Distance spectrum of code
EbNo = 3:0.5:8;
berbound = bercoding(EbNo,'conv','soft',coderate,dspec);
semilogy(EbNo,berbound) % Plot the results.
xlabel('E_b/N_0 (dB)'); ylabel('Upper Bound on BER');
title('Theoretical Bound on BER for Convolutional Coding');
grid on;

% 1. Compute theoretical error rate using BERAWGN.
rng('default')      % Set random number seed for repeatability
%
M = 8; EbNo = 0:13;
[ber, ser] = berawgn(EbNo,'pam',M);
% Plot theoretical results.
figure; semilogy(EbNo,ser,'r');
xlabel('E_b/N_0 (dB)'); ylabel('Symbol Error Rate');
grid on; drawnow;

% 2. Compute empirical error rate by simulating.
% Set up.
n = 10000; % Number of symbols to process
k = log2(M); % Number of bits per symbol
% Convert from EbNo to SNR.
% Note: Because No = 2*noiseVariance^2, we must add 3 dB
% to get SNR. For details, see Proakis' book listed in
% "Selected Bibliography for Performance Evaluation."
snr = EbNo+3+10*log10(k);
% Preallocate variables to save time.
ynoisy = zeros(n,length(snr));
z      = zeros(n,length(snr));
berVec = zeros(3,length(EbNo));

% PAM modulation and demodulation system objects
%h  = comm.PAMModulator(M);
%h2 = comm.PAMDemodulator(M);

% AWGNChannel System object
hChan = comm.AWGNChannel('NoiseMethod', 'Signal to noise ratio (SNR)');


% ErrorRate calculator System object to compare decoded symbols to the
% original transmitted symbols.
hErrorCalc = comm.ErrorRate;

% Main steps in the simulation
x = randi([0 M-1],n,1); % Create message signal.
%y = step(h,x); % Modulate.
y = pammod(x,M); % Modulate.
hChan.SignalPower = (real(y)' * real(y))/ length(real(y));

% Loop over different SNR values.
for jj = 1:length(snr)
    reset(hErrorCalc)
    hChan.SNR = snr(jj); % Assign Channel SNR
    ynoisy(:,jj) = step(hChan,real(y)); % Add AWGN
%    z(:,jj) = step(h2,complex(ynoisy(:,jj))); % Demodulate.
    z(:,jj) = pamdemod(complex(ynoisy(:,jj)),M); % Demodulate.

    % Compute symbol error rate from simulation.
    berVec(:,jj) = step(hErrorCalc, x, z(:,jj));
end

% 3. Plot empirical results, in same figure.
hold on; semilogy(EbNo,berVec(1,:),'b.');
legend('Theoretical SER','Empirical SER');
title('Comparing Theoretical and Empirical Error Rates');
hold off;

• Example: Using the Semianalytic Technique, which also illustrates

  • Plotting two sets of data on one pair of axes

  • Adding a title

  • Adding a legend

• Plotting Theoretical Error Rates, which also illustrates

  • Adding axis labels

  • Adding grid lines

• Customize various relevant aspects of the curve-fitting
  process, such as the type of closed-form function (from a list of
  preset choices) used to generate the fit.

• Plot empirical data along with a curve that berfit fits
  to the data.

• Interpolate points on the fitted curve between E_b/N₀ values
  in your empirical data set to make the plot smoother looking.

• Collect relevant information about the fit, such as
  the numerical values of points along the fitted curve and the coefficients
  of the fit expression.

Note

The berfit function is intended for curve
fitting or interpolation, not extrapolation.
Extrapolating BER data beyond an order of magnitude below the smallest
empirical BER value is inherently unreliable.

Note

For most applications, you should base an error rate computation
on a larger number of errors than is used here (for instance, you
might change numerrmin to 100 in
the code below). However, this example uses a small number of errors
merely to illustrate how curve fitting can smooth out a rough data
set.

% Set up initial parameters.
siglen = 100000; % Number of bits in each trial
M = 2; % DBPSK is binary.
% DBPSK modulation and demodulation System objects
hMod  = comm.DBPSKModulator;
hDemod = comm.DBPSKDemodulator;
% AWGNChannel System object
hChan = comm.AWGNChannel('NoiseMethod', 'Signal to noise ratio (SNR)');
% ErrorRate calculator System object to compare decoded symbols to the
% original transmitted symbols.
hErrorCalc = comm.ErrorRate;
EbNomin = 0; EbNomax = 9; % EbNo range, in dB
numerrmin = 5; % Compute BER only after 5 errors occur.
EbNovec = EbNomin:1:EbNomax; % Vector of EbNo values
numEbNos = length(EbNovec); % Number of EbNo values
% Preallocate space for certain data.
ber = zeros(1,numEbNos); % final BER values
berVec = zeros(3,numEbNos); % Updated BER values
intv = cell(1,numEbNos); % Cell array of confidence intervals

• randi to generate a random message
  sequence

• dpskmod to perform DBPSK modulation

• awgn to model a channel with
  additive white Gaussian noise

• dpskdemod to perform DBPSK demodulation

• biterr to compute the number
  of errors for a given pass through the while loop

• berconfint to compute the final
  error rate and confidence interval for a given value of EbNo

• ber, a vector containing the bit
  error rates for the series of EbNo values.

• intv, a cell array containing the
  confidence intervals for the series of EbNo values.
  Each entry in intv is a two-element vector that
  gives the endpoints of the interval.

% Loop over the vector of EbNo values.
berVec = zeros(3,numEbNos); % Reset
for jj = 1:numEbNos
    EbNo = EbNovec(jj);
    snr = EbNo; % Because of binary modulation
    reset(hErrorCalc)
    hChan.SNR = snr; % Assign Channel SNR
    % Simulate until numerrmin errors occur.
    while (berVec(2,jj) < numerrmin)
        msg = randi([0,M-1], siglen, 1); % Generate message sequence.
        txsig = step(hMod, msg); % Modulate.
        hChan.SignalPower = (txsig'*txsig)/length(txsig);  % Calculate and
        % assign signal power
        rxsig = step(hChan,txsig); % Add noise.
        decodmsg = step(hDemod, rxsig); % Demodulate.
        if (berVec(2,jj)==0)
            % The first symbol of a differentially encoded transmission
            % is discarded.
            berVec(:,jj) = step(hErrorCalc, msg(2:end),decodmsg(2:end));
        else
            berVec(:,jj) = step(hErrorCalc, msg, decodmsg);
        end
    end
    % Error rate and 98% confidence interval for this EbNo value
    [ber(jj), intv1] = berconfint(berVec(2,jj),berVec(3,jj)-1,.98);
    intv{jj} = intv1; % Store in cell array for later use.
    disp(['EbNo = ' num2str(EbNo) ' dB, ' num2str(berVec(2,jj)) ...
        ' errors, BER = ' num2str(ber(jj))])
end

EbNo = 0 dB, 189 errors, BER = 0.18919
EbNo = 1 dB, 139 errors, BER = 0.13914
EbNo = 2 dB, 105 errors, BER = 0.10511
EbNo = 3 dB, 66 errors, BER = 0.066066
EbNo = 4 dB, 40 errors, BER = 0.04004
EbNo = 5 dB, 18 errors, BER = 0.018018
EbNo = 6 dB, 6 errors, BER = 0.006006
EbNo = 7 dB, 11 errors, BER = 0.0055028
EbNo = 8 dB, 5 errors, BER = 0.00071439
EbNo = 9 dB, 5 errors, BER = 0.00022728
EbNo = 10 dB, 5 errors, BER = 1.006e-005

The final part of this example fits a curve to the BER data
collected from the simulation loop. It also plots error bars using
the output from the berconfint function.

% Use BERFIT to plot the best fitted curve,
% interpolating to get a smooth plot.
fitEbNo = EbNomin:0.25:EbNomax; % Interpolation values
berfit(EbNovec,ber,fitEbNo,[],'exp');

% Also plot confidence intervals.
hold on;
for jj=1:numEbNos
   semilogy([EbNovec(jj) EbNovec(jj)],intv{jj},'g-+');
end
hold off;

• A data viewer at the top. It is initially empty.

  

  After you instruct BERTool to generate one or more BER data
  sets, they appear in the data viewer. An example that shows how data
  sets look in the data viewer is in Example: Using a MATLAB Simulation with BERTool.

• A set of tabs on the bottom. Labeled Theoretical, Semianalytic,
  and Monte Carlo, the tabs correspond to the different
  methods by which BERTool can generate BER data.

  

  Note

  When using BERTool to compare theoretical results and Monte
  Carlo results, the Simulink model provided must model exactly
  the system defined by the parameters on the
  Theoretical tab.

  To learn more about each of the methods, see

  • Computing Theoretical BERs

  • Using the Semianalytic Technique to Compute BERs

  • Run MATLAB Simulations or Run Simulink Simulations

• A separate BER Figure window, which displays some or all
  of the BER data sets that are listed in the data viewer. BERTool opens
  the BER Figure window after it has at least one data set to display, so
  you do not see the BER Figure window when you first open BERTool. For
  an example of how the BER Figure window looks, see Example: Using the Theoretical Tab in BERTool.

• If you select a data set in the data viewer, BERTool reconfigures
  the tabs to reflect the parameters associated with that data set and
  also highlights the corresponding data in the BER Figure window. This is
  useful if the data viewer displays multiple data sets and you want
  to recall the meaning and origin of each data set.

• If you click data plotted in the BER Figure window, BERTool reconfigures
  the tabs to reflect the parameters associated with that data and also
  highlights the corresponding data set in the data viewer.

  Note

  You cannot click on a data point while BERTool is generating
  Monte Carlo simulation results. You must wait until the tool generates
  all data points before clicking for more information.

• If you configure the Semianalytic or Theoretical tab
  in a way that is already reflected in an existing data set, BERTool highlights
  that data set in the data viewer. This prevents BERTool from duplicating
  its computations and its entries in the data viewer, while still showing
  you the results that you requested.

• If you close the BER Figure window, then you can reopen
  it by choosing from the menu
  in BERTool.

• If you select options in the data viewer that affect
  the BER plot, the BER Figure window reflects your selections immediately.
  Such options relate to data set names, confidence intervals, curve
  fitting, and the presence or absence of specific data sets in the
  BER plot.

Note

If you save the BER Figure window using the window’s menu,
the resulting file contains the contents of the window but not the BERTool data
that led to the plot. To save an entire BERTool session, see Saving a BERTool Session.

1. Open BERTool, and go to the Theoretical tab.

   

2. Set the parameters to reflect the system whose performance
   you want to analyze. Some parameters are visible and active only when
   other parameters have specific values. See Available Sets of Theoretical BER Data for details.

3. Click Plot.

1. Open BERTool, and go to the Theoretical
   tab.

2. Set the parameters as shown in the following figure.

   

3. Click Plot.

   BERTool creates an entry in the data viewer and plots the data in
   the BER Figure window. Even though the parameters request that
   E_b/N₀ go up to 18,
   BERTool plots only those BER values that are at least
   10^-8. The following figures
   illustrate this step.

   

   

4. Change the Modulation order parameter to
   16, and click
   Plot.

   BERTool creates another entry in the data viewer and plots the new
   data in the same BER Figure window (not pictured).

5. Change the Modulation order parameter to
   64, and click
   Plot.

   BERTool creates another entry in the data viewer and plots the new
   data in the same BER Figure window, as shown in the following
   figures.

   

   

6. To recall which value of Modulation order
   corresponds to a given curve, click the curve. BERTool responds by
   adjusting the parameters in the Theoretical tab
   to reflect the values that correspond to that curve.

7. To remove the last curve from the plot (but not from the data
   viewer), clear the check box in the last entry of the data viewer in
   the Plot column. To restore the curve to the
   plot, select the check box again.

• block and convolutional coding with hard-decision decoding for all
  modulations except CPFSK

• block coding with soft-decision decoding for all binary
  modulations (including 4-PSK and 4-QAM) except CPFSK, noncoherent
  non-orthogonal FSK, and noncoherent MSK

• convolutional coding with soft-decision decoding for all binary
  modulations (including 4-PSK and 4-QAM) except CPFSK

• uncoded nondifferentially-encoded 2-PSK with synchronization
  errors

• berawgn — For
  systems with no coding and perfect synchronization

• bercoding —
  For systems with channel coding

• bersync — For
  systems with BPSK modulation, no coding, and imperfect
  synchronization

1. To set up the transmitted and received signals, run steps 1
   through 4 from the code example in Example: Using the Semianalytic Technique. The code is
   repeated below.

   % Step 1. Generate message signal of length >= M^L.
   M = 16; % Alphabet size of modulation
   L = 1; % Length of impulse response of channel
   msg = [0:M-1 0]; % M-ary message sequence of length > M^L
   
   % Step 2. Modulate the message signal using baseband modulation.
   %hMod = comm.RectangularQAMModulator(M);  % Use 16-QAM.
   %modsig = step(hMod,msg'); % Modulate data
   modsig = qammod(msg',M); % Modulate data
   Nsamp = 16;
   modsig = rectpulse(modsig,Nsamp); % Use rectangular pulse shaping.
   
   % Step 3. Apply a transmit filter.
   txsig = modsig; % No filter in this example
   
   % Step 4. Run txsig through a noiseless channel.
   rxsig = txsig*exp(1i*pi/180); % Static phase offset of 1 degree

2. Open BERTool and go to the Semianalytic
   tab.

3. Set parameters as shown in the following figure.

   

4. Click Plot.

1. Generate a message signal containing at least M^L symbols,
   where M is the alphabet size of the modulation and L is the length
   of the impulse response of the channel in symbols. A common approach
   is to start with an augmented binary pseudonoise (PN) sequence of
   total length (log2M)ML.
   An augmented PN sequence is a PN sequence with
   an extra zero appended, which makes the distribution of ones and zeros
   equal.

2. Modulate a carrier with the message signal using baseband modulation.
   Supported modulation types are listed on the reference page for semianalytic.
   Shape the resultant signal with rectangular pulse shaping, using
   the oversampling factor that you will later use to filter the modulated
   signal. Store the result of this step as txsig for
   later use.

3. Filter the modulated signal with a transmit filter. This filter
   is often a square-root raised cosine filter, but you can also use
   a Butterworth, Bessel, Chebyshev type 1 or 2, elliptic, or more general
   FIR or IIR filter. If you use a square-root raised cosine filter,
   use it on the nonoversampled modulated signal and specify the oversampling
   factor in the filtering function. If you use another filter type,
   you can apply it to the rectangularly pulse shaped signal.

4. Run the filtered signal through a noiseless channel.
   This channel can include multipath fading effects, phase shifts,
   amplifier nonlinearities, quantization, and additional filtering,
   but it must not include noise. Store the result of this step as rxsig for
   later use.

5. On the Semianalytic tab of BERTool,
   enter parameters as in the table below.

   Parameter Name	Meaning
   Eb/No range	A vector that lists the values of Eb/N0 for which you want to collect BER data. The value in this field can be a MATLAB expression or the name of a variable in the MATLAB workspace.
   Modulation type	These parameters describe the modulation scheme you used earlier in this procedure.
   Modulation order
   Differential encoding	This check box, which is visible and active for MSK and PSK modulation, enables you to choose between differential and nondifferential encoding.
   Samples per symbol	The number of samples per symbol in the transmitted signal. This value is also the sampling rate of the transmitted and received signals, in Hz.
   Transmitted signal	The txsig signal that you generated earlier in this procedure
   Received signal	The rxsig signal that you generated earlier in this procedure
   Numerator	Coefficients of the receiver filter that BERTool applies to the received signal
   Denominator

   Note

   Consistency among the values in the GUI is important. For example,
   if the signal referenced in the Transmitted signal field
   was generated using DPSK and you set Modulation type to MSK,
   the results might not be meaningful.

6. Click Plot.

• Filters rxsig and then determines the error
  probability of each received signal point by analytically applying
  the Gaussian noise distribution to each point. BERTool averages the
  error probabilities over the entire received signal to determine the
  overall error probability. If the error probability calculated in
  this way is a symbol error probability, BERTool converts it to a bit
  error rate, typically by assuming Gray coding. (If the modulation
  type is DQPSK or cross QAM, the result is an upper bound on the bit
  error rate rather than the bit error rate itself.)

• Enters the resulting BER data in the data viewer of the BERTool
  window.

• Plots the resulting BER data in the BER Figure window.

1. Open BERTool and go to the Monte Carlo tab.
   (The default parameters depend on whether you have Communications
   Toolbox software
   installed. Also note that the BER variable name field
   applies only to Simulink models.)

2. Set parameters as shown in the following figure.

   

3. Click Run.

   BERTool runs the simulation function once for each specified
   value of E_b/N₀ and gathers BER data. (While BERTool is busy with
   this task, it cannot process certain other tasks, including plotting
   data from the other tabs of the GUI.)

   Then BERTool creates a listing in the data viewer.

   

   BERTool plots the data in the BER Figure window.

   

4. To change the range of E_b/N₀ while reducing the number
   of bits processed in each case, type [5 5.2 5.3] in
   the Eb/No range field, type 1e5 in
   the Number of bits field, and click Run.

   BERTool runs the simulation function again for each new value
   of E_b/N₀ and gathers new BER data. Then BERTool creates another
   listing in the data viewer.

   

   BERTool plots the data in the BER Figure window, adjusting the horizontal
   axis to accommodate the new data.

   

   The two points corresponding to 5 dB from the two data sets
   are different because the smaller value of Number of bits in
   the second simulation caused the simulation to end before observing
   many errors. To learn more about the criteria that BERTool uses
   for ending simulations, see Varying the Stopping Criteria.

Note

You can also use the Stop button in BERTool to
stop a series of simulations prematurely, as long as your function
is set up to detect and react to the button press.

• One value from the Eb/No range vector each
  time BERTool invokes the simulation function

• The Number of errors value

• The Number of bits value

• Bit error rate of the simulation

• Number of bits processed when computing the BER

• Simulate the communication system for the
  E_b/N₀ value
  specified in the first input argument.

• Stop simulating when the number of errors or the number of
  processed bits equals or exceeds the corresponding threshold
  specified in the second or third input argument,
  respectively.

• Detect whether you click Stop in BERTool
  and abort the simulation in that case.

function [ber, numBits] = bertooltemplate(EbNo, maxNumErrs, maxNumBits)
% Import Java class for BERTool.
import com.mathworks.toolbox.comm.BERTool;

% Initialize variables related to exit criteria.
berVec = zeros(3,1); % Updated BER values

% --- Set up parameters. ---
% --- INSERT YOUR CODE HERE.
% Simulate until number of errors exceeds maxNumErrs
% or number of bits processed exceeds maxNumBits.
while((berVec(2) < maxNumErrs) && (berVec(3) < maxNumBits))

   % Check if the user clicked the Stop button of BERTool.
   if (BERTool.getSimulationStop)
      break;
   end

   % --- Proceed with simulation.
   % --- Be sure to update totErr and numBits.
   % --- INSERT YOUR CODE HERE.
end % End of loop

% Assign values to the output variables.
ber = berVec(1);
numBits = berVec(3);

1. Copy the template from Template for a Simulation Function into a new MATLAB file in the MATLAB Editor. Save it in a folder on your MATLAB path using the file name
   bertool_simfcn.

2. From the original example, the following lines are setup tasks.
   They are modified from the original example to rely on the input
   arguments that BERTool provides to the function, instead of defining
   variables such as EbNovec and
   numerrmin directly.

   % Set up initial parameters.
   siglen = 1000; % Number of bits in each trial
   M = 2; % DBPSK is binary.
   % DBPSK modulation and demodulation System objects
   hMod  = comm.DBPSKModulator;
   hDemod = comm.DBPSKDemodulator;
   % AWGNChannel System object
   hChan = comm.AWGNChannel('NoiseMethod', 'Signal to noise ratio (SNR)');
   % ErrorRate calculator System object to compare decoded symbols to the
   % original transmitted symbols.
   hErrorCalc = comm.ErrorRate;
   snr = EbNo; % Because of binary modulation
   hChan.SNR = snr; %Assign Channel SNR

   Place these lines of code in the template section marked
   Set up parameters.

3. From the original example, the following lines are the core
   simulation tasks, after all setup work has been performed.

   msg = randi([0,M-1], siglen, 1); % Generate message sequence.
   txsig = step(hMod, msg); % Modulate.
   hChan.SignalPower = (txsig'*txsig)/length(txsig);  % Calculate and
                                                   % assign signal power
   rxsig = step(hChan,txsig); % Add noise.
   decodmsg = step(hDemod, rxsig); % Demodulate.
   berVec = step(hErrorCalc, msg, decodmsg); % Calculate BER

   Place the code for these core simulation tasks in the template
   section marked Proceed with simulation.

1. Open BERTool and go to the Monte Carlo
   tab.

2. Set parameters on the Monte Carlo tab as
   shown in the following figure.

   

3. Click Run.

   BERTool spends some time computing results and then plots them.
   They do not appear to fall along a smooth curve because the
   simulation required only five errors for each value in
   EbNo.

   

4. To fit a curve to the series of points in the BER Figure window,
   select the box next to Fit in the data
   viewer.

   BERTool plots the curve, as shown in the following figure.

   

Note

To use Simulink models within BERTool, you must have
a Simulink license. Communications
Toolbox software is highly
recommended. The rest of this section assumes you have a license for
both Simulink and Communications
Toolbox applications.

1. Open BERTool and go to the Monte Carlo tab.
   The model’s file name, commgraycode.mdl, appears
   as the Simulation MATLAB file or Simulink model parameter.
   (If viterbisim.m appears there, select to indicate
   that Communications
   Toolbox software is installed.)

2. Click Run.

   BERTool loads the model into memory (which in turn initializes
   several variables in the MATLAB workspace), runs the simulation
   once for each value of E_b/N₀, and gathers BER data. BERTool creates
   a listing in the data viewer.

   

   BERTool plots the data in the BER Figure window.

   

3. To fit a curve to the series of points in the BER Figure window,
   select the box next to Fit in the data viewer.

   BERTool plots the curve, as below.

   

4. To indicate the 99% confidence interval around each
   point in the simulation data, set Confidence Level to 99% in
   the data viewer.

   BERTool displays error bars to represent the confidence intervals,
   as below.

   

• The channel block must use the variable EbNo rather
  than a hard-coded value for E_b/N₀.

• The simulation must stop when the error count reaches
  the value of the variable maxNumErrs or when the
  number of processed bits reaches the value of the variable maxNumBits,
  whichever occurs first.

  You can configure the Error Rate Calculation block in Communications
  Toolbox software
  to stop the simulation based on such criteria.

• The simulation must send the final error rate data
  to the MATLAB workspace as a variable whose name you enter in
  the BER variable name field in BERTool. The
  variable must be a three-element vector that lists the BER, the number
  of bit errors, and the number of processed bits.

  This three-element vector format is supported by the Error Rate
  Calculation block.

• To avoid using an undefined variable name in the dialog
  box for a Simulink block in the steps that follow, set up variables
  in the MATLAB workspace using a command such as the one below.

  EbNo = 0; maxNumErrs = 100; maxNumBits = 1e8;
  

  You might also want to put the same command in the model’s preload
  function callback, to initialize the variables if you reopen the model
  in a future MATLAB session.

  When you use BERTool, it provides the actual values based
  on what you enter in the GUI, so the initial values above are somewhat
  arbitrary.

• To model the channel, use the AWGN Channel block in Communications
  Toolbox software
  with these parameters:

  • Mode = Signal to
noise ratio (Eb/No)

  • Eb/No = EbNo

  

• To compute the error rate, use the Error Rate Calculation
  block in Communications
  Toolbox software with these parameters:

  • Check Stop simulation.

  • Target number of errors = maxNumErrs

  • Maximum number of symbols = maxNumBits

  

• To send data from the Error Rate Calculation block to the MATLAB workspace, set Output data to
  Port, attach a To Workspace block, and
  set the latter block’s Limit data points to
  last parameter to 1. The
  Variable name parameter in the To Workspace block must
  match the value you enter in the BER variable
  name field of BERTool.

  Tip

  More
  than one To Workspace block is available. Be sure to
  select To Workspace from the DSP System
  Toolbox™ / Sinks sublibrary.

• If your model computes a symbol error rate instead
  of a bit error rate, use the Integer to Bit Converter block in Communications
  Toolbox software
  to convert symbols to bits.

• Frame-based simulations often run faster than sample-based
  simulations for the same number of bits processed. The number of errors
  or number of processed bits might exceed the values you enter in BERTool,
  because the simulation always processes a fixed amount of data in
  each frame.

• If you have an existing model that uses the AWGN Channel
  block using a Mode parameter other than Signal
to noise ratio (Eb/No), you can adapt the block to use
  the Eb/No mode instead. To learn about how the block’s different modes
  are related to each other, press the AWGN Channel block’s Help button
  to view the online reference page.

• If your model uses a preload function or other callback
  to initialize variables in the MATLAB workspace upon loading,
  make sure before you use the Run button in BERTool that
  one of these conditions is met:

  • The model is not currently in memory. In this case, BERTool loads
    the model into memory and runs the callback functions.

  • The model is in memory (whether in a window or not),
    and the variables are intact.

  If you clear or overwrite the model’s variables and want to
  restore their values before using the Run button
  in BERTool, you can use the bdclose function
  in the MATLAB Command Window to clear the model from memory.
  This causes BERTool to reload the model after you click Run.
  Similarly, if you refresh your workspace by issuing a clear
all or clear variables command, you should
  also clear the model from memory by using bdclose all.

1. Open the model by entering the following command in
   the MATLAB Command Window.

   

2. To initialize parameters in the MATLAB workspace
   and avoid using undefined variables as block parameters, enter the
   following command in the MATLAB Command Window.

   EbNo = 0; maxNumErrs = 100; maxNumBits = 1e8;
   

3. To ensure that BERTool uses the correct amount of
   noise each time it runs the simulation, open the dialog box for the AWGN
   Channel block by double-clicking the block. Verify that Es/No is
   set to EbNo and click OK.
   In this particular model, E_s/N₀ is
   equivalent to E_b/N₀ because the modulation type is BPSK.

4. To ensure that BERTool uses the correct stopping criteria for each
   iteration,

   • Open the dialog box for the Error Rate
     Calculation block. Verify that
     Target number of errors is set
     to maxNumErrs, and that
     Maximum number of symbols is
     set to maxNumBits. Click
     OK.

   • The simulation stop time must be set to
     Inf.

5. To enable BERTool to access the BER results that the Error Rate Calculation block computes,
   the To Workspace block,
   BER, is connected to the output of the Error
   Rate Calculation block.

   Tip

   More
   than one To Workspace block is available. Be sure to
   select To Workspace from the DSP System
   Toolbox / Sinks sublibrary.

1. Open BERTool and go to the Monte Carlo tab.

2. Set parameters on the Monte Carlo tab
   as shown in the following figure.

   

3. Click Run.

   BERTool spends some time computing results and then plots
   them.

   

4. To compare these simulation results with theoretical
   results, go to the Theoretical tab in BERTool and
   set parameters as shown below.

   

5. Click Plot.

   BERTool plots the theoretical curve in the BER Figure window along
   with the earlier simulation results.

   

1. In the data viewer, select the data set you want to export.

2. Choose .

   

3. Set Export to to indicate the format and
   destination of the data.

   1. If you want to reimport the data into BERTool later, you
      must choose either
      Workspace structure or
      MAT-file structure to create
      a structure in the MATLAB workspace or a MAT-file, respectively.

      A new field called Structure name
      appears. Set it to the name that you want BERTool to use for
      the structure it creates.

      If you selected Workspace
structure and you want BERTool to use your
      chosen variable name, even if a variable by that name
      already exists in the workspace, select Overwrite
      variables.

   2. If you do not need to reimport the
      data into BERTool later, a convenient way to access the data
      outside BERTool is to have BERTool create a pair of arrays
      in the MATLAB workspace. One array contains
      E_b/N₀
      values, while the other array contains BER values. To choose
      this option, set Export to to
      Workspace arrays.

      Then type two variable names in the fields under
      Variable names.

      If you want BERTool to use your chosen variable names even
      if variables by those names already exist in the workspace,
      select Overwrite variables.

4. Click OK. If you selected
   MAT-file structure, BERTool prompts
   you for the path to the MAT-file that you want to create.

• ber0.data{1} lists the
  E_b/N₀
  values.

• ber0.data{2} lists the BER values corresponding
  to each of the E_b/N₀
  values.

• ber0.data{3} indicates, for simulation or
  semianalytic results, how many bits BERTool processed when computing
  each of the corresponding BER values.

• To rename a data set in the data viewer, double-click
  its name in the BER Data Set column and type
  a new name.

  

• To delete a data set from the data viewer, select
  it and choose .

  Note

  If the data set originated from the Semianalytic or Theoretical tab, BERTool deletes
  the data without asking for confirmation. You cannot undo this operation.

• To move a column in the data viewer, drag the column’s
  heading to the left or right with the mouse. For example, the image
  below shows the mouse dragging the BER column
  to the left of its default position. When you release the mouse button,
  the columns snap into place.

  

• Writing a system class, extending the testconsole.SystemBasicAPI
  class.

• Writing a registration method

  • Registration is test related

  • Defines items such as test parameters, test probes,
    and test inputs

• Writing a setup method

• Writing a reset method

• Writing a run method

  Methods allows the system to communicate with the test console.

• Write a register method for every
  communication system you create.

• If you do not implement a register method
  for a system, you can still attach the system to the Error Rate Test
  Console. While the test console runs the specified number of iterations
  on the system, you cannot control simulation parameters or retrieve
  results from the simulation.

• sys represents the handle to a user-defined
  system object.

• inputName represents the name of the input that
  the system registers. This name must coincide with the name of an
  available test input in the Error Rate Test Console or an error
  occurs.

  • ‘NumTransmissions’ — calling the
    getInput method returns the frame
    length. The system itself is responsible for generating a
    data frame using a data source.

  • ‘RandomIntegerSource’ — calling the
    getInput method returns a vector of
    symbols with a length the Error Rate Test Console
    FrameLength property specifies. If
    the system registers this source type, then it must also
    register a test parameter named ‘M’ that corresponds to the
    modulation order.

• sys represents the handle to the user-defined
  system object

• name represents the parameter name that the
  system registers to the Error Rate Test Console

• default specifies the default value of the test
  parameter – it can be a numeric value or a character vector

• validRange specifies a range of input values
  for the test parameter — it can be a 1×2 vector of numeric
  values with upper and lower ranges or a cell array of chars (an
  Enum).

• sys represents the handle to the user-defined
  system object

• name represents the name of the test
  probe

• description contains information about the test
  probes; useful for indicating what the probe is used for. The
  description input is optional.

• at the beginning of simulations for a new sweep point.
  (This condition occurs when you set the ResetMode of
  the Error Rate Test Console to “Reset at new simulation point’.)

• at each simulation iteration. (This condition occurs
  when you set the ResetMode of the Error Rate Test
  Console to ‘Reset at every iteration’.)

• requests test inputs from the test console using the getInput method

• logs test data to its test probes using the setTestProbeData method

• logs user-data to the test console using the setUserData method

• Although it is recommended you do this at setup time,
  the system can also request the current simulation sweep values using
  the getTestParameter method.

• obj represents the handle of the Error Rate Test Console

• inputName represents the input that the system under
  test gets from the Error Rate Test Console

• ‘NumTransmissions’ — calling the getInput method
  returns the frame length. The system itself is responsible for generating
  a data frame using a data source.

• ‘RandomIntegerSource’ — calling the getInput method
  returns a vector of symbols with a length the Error Rate Test Console FrameLength property
  specifies. If the system registers this source type, then it must
  also register a test parameter named ‘M’ that corresponds to the modulation
  order.

• sys represents the handle to the
  system

• name represents the name of a registered
  test probe

• data represents the data the probe
  logs to the Error Rate Test Console.

• sys represents the handle to the
  system

• data represents the data the probe
  logs to the Error Rate Test Console.

• Creating a test console

• Attaching a system

• Defining simulation conditions

  • Specifying stop criterion

  • Specifying iteration mode

  • Specifying reset mode

  • Specifying sweep values

• Registering test points

• Running simulations

• Getting results and plotting

• h = commtest.ErrorRate returns
  an error rate test console, h. The error rate test console runs simulations
  of a system under test to obtain error rates.

• h = commtest.ErrorRate(sys) returns
  an error rate test console, h, with an attached system under test,
  sys.

• h = commtest.ErrorRate(sys,'PropertyName',PropertyValue,...) returns
  an error rate test console, h, with an attached system under test,
  sys. Each specified property, ‘PropertyName’, is set to the specified
  value, PropertyValue.

• h = commtest.ErrorRate('PropertyName',PropertyValue,...) returns
  an error rate test console, h, with each specified property ‘PropertyName’,
  set to the specified value, PropertyValue.

• To attach a system to the Error Rate Test Console,
  type the following at the MATLAB command line:

  attachSystem(testConsole, mySystem)

• To attach a system at construction time of an Error
  Rate Test Console, see Creating a Test Console.

• mySystem is the name of the system
  under test

• Setting SimulationLimitOption property to
  ‘Number of transmissions’ stops the simulation for each sweep
  parameter point when the Error Rate Test Console counts the number
  of transmissions specified in
  MaxNumTransmissions

• Setting SimulationLimitOption property to
  ‘Number of errors’ stops the simulation for a sweep parameter point
  when the Error Rate Test Console counts the number of errors
  specified in MinNumErrors. The
  ErrorCountTestPoint property should be set to
  the name of the registered test point containing the error count
  being compared to the MinNumErrors property to
  control the simulation length.

• Setting SimulationLimitOption property to
  ‘Number of errors or transmissions’ stops the simulation for each
  sweep parameter point when the Error Rate Test Console completes the
  number of transmissions specified in
  MaxNumTransmissions or when obtaining the
  number of errors specified in MinNumErrors,
  whichever happens first.

• Setting IterationMode to ‘Combinatorial’
  performs simulations for all possible combinations of registered
  test parameter sweep values.

• Setting IterationMode to ‘Indexed’ performs
  simulations for all indexed sweep value sets. The
  i^th sweep
  value set consists of the
  i^th element from
  every sweep value vector for each registered test parameter. All
  sweep value vectors must be of equal length, with the exception of
  those that are unit length.

• obj represents handle to the Error Rate Test
  Console.

• name represents the name of the registered test
  parameter (this name must correspond to a test parameter registered
  by the system under test or an error occurs)

• value represents the sweep values you specify
  for the test parameter named ‘name’. Depending on the application,
  sweep values may be a vector with numeric values or a cell array of
  characters. The test console issues an error if you attempt to set
  sweep values that are out of the specified valid range for a test
  parameter (valid ranges are defined by the system when attaching to
  a test console).

• Setting SystemResetMode to ‘Reset at new
  simulation point’ resets the system under test resets at the
  beginning of iterations for a new simulation sweep point.

• Setting SystemResetMode to ‘Reset at every
  iteration’ resets the system under test at every
  simulation.

• Test console name

• System under test name

• Available test inputs

• Registered test inputs

• Registered test parameters

• Registered test probes

• Registered test points

• Metric calculator functions

• Test metrics

• The bit energy to noise power spectral density ratio, EbNo (in
  decibels)

• The modulation order, M

• The maximum Doppler shift, MaxDopplerShift (in
  hertz)

• EbNo = [-2:4] dB

• M = [2 4 8 16]

• MaxDopplerShift = [0 0.001 0.09]
  Hz

1. Using the getSweepParameterValues method,
   display the sweep parameter values used in the simulation for each
   test parameter. For example, you display the sweep values for MaxDopplerShift by
   entering:

   getTestParameterSweepValues(testConsole,'MaxDopplerShift') 

   MATLAB returns the following result:

2. Get the results object that parses and plots simulation
   results by entering the following at the command line:

   DPSKResults = getResults(testConsole)

   MATLAB returns the following result:

   DPSKResults =
   
           TestConsoleName: 'commtest.ErrorRate'
       SystemUnderTestName: 'commexample.DPSKModulation'
             IterationMode: 'Combinatorial'
                 TestPoint: 'BitErrors'
                    Metric: 'ErrorRate'
            TestParameter1: 'EbNo'
            TestParameter2: 'None'

3. Use the setParsingValues method to enable
   the plotting of error rate results versus Eb/No for a modulation order
   of 4 and maximum Doppler shift of 0.001 Hz. To do so, enter the following:.

   setParsingValues(DPSKResults,'M',4,'MaxDopplerShift',0.001)

4. Use the getParsingValues method to verify
   the current parsing values settings:

   getParsingValues(DPSKResults)

   MATLAB returns the following:

   ans =
   
                  EbNo: -2
                     M: 4
       MaxDopplerShift: 1.0000e-003

   If not specified, the parsing value for a test parameter defaults
   to its first sweep value. In this example, the first sweep value for
   EbNo equals -2 dB. However, in this example, TestParameter1 is
   set to EbNo; therefore, the Error Rate Test Console plots results
   for all EbNo sweep values, not just for the value listed by the getParsingValues method.

5. Obtain a log-scale plot of bit error rate versus Eb/No
   for a modulation order of 4 and a maximum Doppler shift of 0.001 Hz:

   MATLAB generates the following figure.

   

6. Set the TestParameter2 property of the
   results object to ‘MaxDopplerShift’. This setting enables the plotting
   of multiple error rate curves versus Eb/No for each sweep value of
   the maximum Doppler shift.

   DPSKResults.TestParameter2 = 'MaxDopplerShift';

7. Obtain log-scale plots of bit error rate versus Eb/No
   for a modulation order of 2 at each of the maximum Doppler shift sweep
   values.

   setParsingValues(DPSKResults,'M',2)
   semilogy(DPSKResults)
   

   MATLAB generates the following figure.

   

8. Obtain the same type of curves as in the previous step,
   but now for a modulation order of 16.

   setParsingValues(DPSKResults,'M',16)
   semilogy(DPSKResults)
   

   MATLAB generates the following figure.

   

9. Obtain error rate plots versus the modulation order for
   each Eb/No sweep value by setting TestParameter1 equal
   to M and TestParameter2 equal to EbNo. You can plot
   the results for the case when the maximum Doppler shift is 0 Hz by
   using the setParsingValues method:

   DPSKResults.TestParameter1 = 'M';
   DPSKResults.TestParameter2 = 'EbNo';
   setParsingValues(DPSKResults, 'MaxDopplerShift',0)
   semilogy(DPSKResults)
   

   MATLAB generates the following figure.

   

10. Obtain a data matrix with the bit error rate values previously
    plotted by entering the following:

    BERMatrix = getData(DPSKResults)

    MATLAB returns the following result:

    BERMatrix =
    
      Columns 1 through 7
    
        0.2660    0.2467    0.2258    0.2049    0.1837    0.1628    0.1418
        0.3076    0.2889    0.2702    0.2504    0.2296    0.2082    0.1871
        0.3510    0.3384    0.3258    0.3120    0.2983    0.2837    0.2685
        0.3715    0.3631    0.3535    0.3442    0.3350    0.3246    0.3147
    
      Columns 8 through 13
    
        0.1217    0.1022    0.0844    0.0677    0.0534    0.0406
        0.1658    0.1451    0.1254    0.1065    0.0890    0.0728
        0.2531    0.2369    0.2204    0.2042    0.1874    0.1704
        0.3044    0.2945    0.2839    0.2735    0.2626    0.2512

    The rows of the matrix correspond to the values of the test
    parameter defined by the TestParameter1 property,
    M. The columns correspond to the values of the test parameter defined
    by the TestParameter2 property, EbNo.

11. Plot the results as a 3-D data plot by entering the following:

    MATLAB generates the following plot:

    

    In this case, the parameter defined by the TestParameter1 property,
    M, controls the x-axis and the parameter defined by the TestParameter2 property,
    EbNo, controls the y-axis.

1. Load the file containing the Error Rate Test Console
   and attached Gray coded modulation system. At the MATLAB command
   line, enter:

   load GrayCodedModTester_EbNo_M

2. Examine the test console by displaying its properties.
   At the MATLAB command line, enter:

   MATLAB returns the following output:

   testConsole =
   
                      Description: 'Error Rate Test Console'
              SystemUnderTestName: 'commexample.GrayCodedMod_EbNo_M'
                    IterationMode: 'Combinatorial'
                  SystemResetMode: 'Reset at new simulation point'
            SimulationLimitOption: 'Number of errors or transmissions'
       TransmissionCountTestPoint: 'DemodBitErrors'
              MaxNumTransmissions: 100000000
              ErrorCountTestPoint: 'DemodBitErrors'
                     MinNumErrors: 100
   

   Notice that SystemUnderTest is a Gray coded modulation system.
   Because the SimulationLimitOption is ‘Number of error or transmission’,
   the simulation runs until reaching 100 errors or 1e8 bits.

1. Run the simulation, using the tic and toc commands
   to measure simulation time. At the MATLAB command line, enter:

   tic; run(testConsole); toc

   MATLAB returns output similar to the following:

   Running simulations...
   Elapsed time is 174.671632 seconds.
   

2. Obtain the results of the simulation using the getResults method
   by typing the following at the MATLAB command line:

   grayResults = getResults(testConsole)

   MATLAB returns the following output:

   grayResults =
   
           TestConsoleName: 'commtest.ErrorRate'
       SystemUnderTestName: 'commexample.GrayCodedMod_EbNo_M'
             IterationMode: 'Combinatorial'
                 TestPoint: 'DemodBitErrors'
                    Metric: 'ErrorRate'
            TestParameter1: 'EbNo'
            TestParameter2: 'None'
   

1. Generate the figure by entering the following at the MATLAB command
   line:

   This script generates the following figure.

   

2. Set the TestParameter2 property
   to M. At the MATLAB command line, enter:

   grayResults.TestParameter2 = 'M'

   Previously, the simulation ran for multiple modulation order
   (M) values. The x-axis displays the TestParameter1 property
   of grayResults, which contains EbNo values. Although
   the simulation ran for multiple M values, this run contains data for
   M=2.

3. Plot multiple error rate curves by entering the following
   at the MATLAB command line.

   This script generates the following figure.

   

Note

If you do not have a Parallel
Computing Toolbox user license
you are unable to perform this section of the tutorial.

1. If you have a Parallel
   Computing Toolbox license,
   run the following command to start your default parpool:

   If you have a multicore computer, then the default parpool
   uses the cores as workers.

2. Using the workers, run the simulation. At the MATLAB command
   line, enter:

tic; run(testConsole); toc

4 workers available for parallel computing. Simulations ...,
will be distributed among these workers.
Running simulations...
Elapsed time is 87.449652 seconds.

1. Copy the system basic API template, SystemBasicTemplate.m,
   as MyGrayCodedModulation.m.

2. Rename the references to the system name in the file.
   First, rename the system definition by changing the class name to
   MyGrayCodedModulation. Replace the following lines, lines 1 and 2,
   of the file:

   classdef SystemBasicTemplate < testconsole.SystemBasicAPI
   %SystemBasicTemplate Template for creating a system
   

   with these lines:

   classdef MyGrayCodedModulation < testconsole.SystemBasicAPI
   %MyGrayCodedModulation Gray coded modulation system
   

3. Rename the constructor by replacing:

   function obj = SystemBasicTemplate
   %SystemBasicTemplate Construct a system

   with

   function obj = MyGrayCodedModulation
   %MyGrayCodedModulation Construct a Gray coded modulation system
   

4. Enter a description for your system. Update the obj.Description parameter
   with the following information:

   obj.Description = 'Gray coded modulation';
   

   Because you are not using the reset and setup methods
   for this system, leave these methods empty.

5. Copy lines 12–44 from commdoc_gray.m to the
   body of the run method.

6. Copy Lines 54–57 from commdoc_gray.m to the
   body of the run method.

7. Change EbNo to a test parameter. This change allows
   the system to obtain EbNo values from the Error Rate Test Console.
   As a test parameter, EbNo becomes a variable, which allows simulations
   to run for different values. Locate the following line of syntax in
   the file:

   Replace it with:

   EbNo = getTestParameter(obj,'EbNo');

8. Add modulation order, M, as a new test parameter for
   the simulation. Locate the following syntax:

    M = 16;                     % Size of signal constellation

   Replace
   it with:

   M = getTestParameter(obj,'M');
   

9. Register the test parameters to the test console.

   • Declare EbNo as a test parameter by placing the following
     line of code in the body of the register method:

     registerTestParameter(obj,'EbNo',0,[-50 50]);

     The
     parameter defaults to 0 dB and can take values between -50 dB and
     50 dB.

   • Declare M as a test parameter by placing the following
     line of code in the body of the register method:

     registerTestParameter(obj,'M',16,[2 1024]);
     

     The parameter defaults to 16 QAM Modulation and can take values
     from 2 through 1024.

10. Add EbNo and M to the test parameters list in the
    MyGrayCodedModulationFile file.

     % Test Parameters
        properties
            EbNo = 0;
      		 M = 16;
        end

    This adds EbNo and M to the possible test
    parameters list. EbNo defaults to a value of 0 dB. M defaults to a
    value of 16.

11. Define test probe locations in the run method.
    In this example, you are calculating end-to-end error rate. This calculation
    requires transmitted bits and received bits. Add one probe for obtaining
    transmitted bits and one probe for received bits.

    • Locate the random binary data stream creation code
      by searching for the following lines:

      % Create a binary data stream as a column vector.
        x = randi([0 1],n,1); % Random binary data stream
      

    • Add a probe, TxBits, after the random binary data
      stream creation:

       % Create a binary data stream as a column vector.
       x = randi([0 1],n,1); % Random binary data stream
       setTestProbeData(obj,'TxBits',x);
      

      This code sends the random binary data stream, x,
      to the probe TxBits.

    • Locate the demodulation code by searching for the
      following lines:

      % Demodulate signal using 16-QAM.
      z = demodulate(hDemod,yRx);
      

    • Add a probe, RxBits, after the demodulation code.

      % Demodulate signal using 16-QAM.
      z = demodulate(hDemod,yRx);
      setTestProbeData(obj,'RxBits',z);
      

    This code sends the binary received data stream, z,
    to the probe RxBits.

12. Register the test probes to the Error Rate Test Console,
    making it possible to obtain data from the system. Add these probes
    to the function register(obj) by adding two lines
    to the register method:

    function register(obj)
    % REGISTER Register the system with a test console
    % REGISTER(H) registers test parameters and test probes of the
    % system, H, with a test console.
    
                registerTestParameter(obj,'EbNo',0,[-50 50]);
    					registerTestParameter(obj,'M',16,[2 1024]);
                registerTestProbe(obj,'TxBits')
                registerTestProbe(obj,'RxBits')
            end
    

13. Save the file. The file is ready for use with the
    system.

14. Create a Gray coded modulation system. At the MATLAB command
    line, enter:

    mySystem = MyGrayCodedModulation

    MATLAB returns the following output:

    mySystem =
    
        Description: 'Gray coded modulation'
               EbNo: 0
    	            M: 16
    

15. Create an Error Rate Test Console by entering the
    following at the MATLAB command line:

    testConsole = commtest.ErrorRate

    The MATLAB software returns the following output:

    testConsole =
    
                       Description: 'Error Rate Test Console'
               SystemUnderTestName: 'commtest.MPSKSystem'
                       FrameLength: 500
                     IterationMode: 'Combinatorial'
                   SystemResetMode: 'Reset at new simulation point'
             SimulationLimitOption: 'Number of transmissions'
        TransmissionCountTestPoint: 'Not set'
               MaxNumTransmissions: 1000
    

16. Attach the system file MyGrayCodedModulation to the
    error rate test console by entering the following at the MATLAB command
    line:

    attachSystem(testConsole, mySystem)

1. At the MATLAB command line, enter:

   registerTestPoint(testConsole, 'DemodBitErrors', 'TxBits', 'RxBits');

   This line defines the test point, DemodBitErrors, and compares
   bits from the TxBits probe to the bits from the RxBits probe. The
   Error Rate Test Console calculated metrics for this test point.

2. Configure the Error Rate Test Console to run simulations
   for EbNo values. Start at 2 dB and end at 10 dB, with a step size
   of 2 dB and M values of 2, 4, 8, and 16. At the MATLAB command
   line, enter:

   setTestParameterSweepValues(testConsole, 'EbNo', 2:2:10)
   setTestParameterSweepValues(testConsole, 'M', [2 4 8 16])
   

3. Set the simulation limit to the number of transmissions.

   testConsole.SimulationLimitOption = 'Number of transmissions'

4. Set the maximum number of transmissions to 1000.

   testConsole.MaxNumTransmissions = 1000
   

5. Configure the Error Rate Test Console so it uses the
   demodulator bit error test point for determining the number of transmitted
   bits.

   testConsole.TransmissionCountTestPoint = 'DemodBitErrors'
   

6. Run the simulation. At the MATLAB command line,
   enter:

7. Obtain the results of the simulation. At the MATLAB command
   line, enter:

   grayResults = getResults(testConsole)

8. To obtain more accurate results, run the simulations
   for a given minimum number of errors. In this example, you also limit
   the number of simulation bits so that the simulations do not run indefinitely.
   At the MATLAB command line, enter:

   testConsole.SimulationLimitOption = 'Number of errors or transmissions';
   testConsole.MinNumErrors = 100;
   testConsole.ErrorCountTestPoint = 'DemodBitErrors';
   testConsole.MaxNumTransmissions = 1e8;
   testConsole

9. Run the simulation by entering the following at the MATLAB command
   line.

10. Generate the new results in a Figure window by entering
    the following at the MATLAB command line.

    grayResults = getResults(testConsole);
    grayResults.TestParameter2 = 'M'
    semilogy(grayResults)

    This script generates the following figure.

    

1. Save the file MyGrayCodedModulation as MyGrayCodedModulationOptimized.

2. In the MyGrayCodedModulationOptimized file, replace
   the constructor name and the class definition name.

   • Locate the following lines of code:

     classdef MyGrayCodedModulation < testconsole.SystemBasicAPI
     %MyGrayCodedModulation Gray coded modulation system

   • Replace them with:

     classdef MyGrayCodedModulationOptimized < testconsole.SystemBasicAPI
     %MyGrayCodedModulationOptimized Gray coded modulation system

3. In the MyGrayCodedModulationOptimized file,
   replace the constructor name.

   • Locate the following lines of code:

     function obj = MyGrayCodedModulation
     %MyGrayCodedModulation Construct a Gray coded modulation system

   • Replace them with:

     function obj = MyGrayCodedModulationOptimized
     %MyGrayCodedModulationOptimized Construct a Gray
     %coded modulation system
     

4. Move the oversampling rate definition from the run method
   to the setup method.

   nSamp = 1;                  % Oversampling rate

5. Move code related to setting M to the setup method.
   Cut the following lines from the run method and
   paste to the setup method.

               M = getTestParameter(obj,'M');
               k = log2(M);                % Number of bits per symbol
   

6. In the setup method, replace M
   with the object property M.

   obj.M = getTestParameter(obj,'M');
   k = log2(obj.M);                % Number of bits per symbol
   

   This change provides access to the M value from the run method.

7. Move code related to setting EbNo to the setup method.
   Cut the following lines from the run method and
   paste to the setup method.

   EbNo = getTestParameter(obj,'EbNo');
   
   SNR = EbNo + 10*log10(k) - 10*log10(nSamp);
   

8. In the setup method, replace EbNo
   with the object property EbNo. This change provides access to the
   EbNo value from the run method.

   obj.EbNo = getTestParameter(obj,'EbNo');
   SNR = obj.EbNo + 10*log10(k) - 10*log10(nSamp);
   

9. Create a new internal variable called SNR to store
   the calculated SNR value. Define the SNR property as a private property;
   it is not a test parameter. With this change, the system calculates
   SNR in the setup method and accesses it from the run method.
   Add the following lines of code the system file, after the Test Parameters
   block.

   %=================================================================
       % Internal variables
       properties (Access = private)
           SNR
       end
   

10. In the setup method, replace SNR
    with object property SNR.

     obj.SNR = obj.EbNo + 10*log10(k) - 10*log10(nSamp);

11. In the run method, replace M with obj.M and SNR with obj.SNR.

    hMod = comm.RectangularQAMModulator(obj.M); % Create a 16-QAM modulator
    yNoisy = awgn(yTx,obj.SNR,'measured'); 

    Notice that the run method creates the QAM
    modulator and demodulator.

12. Move the QAM modulator and demodulator creation out of the run method. Move
    following lines from the run method to the
    constructor (i.e the method named
    MyGrayCodedModulationOptimized)

    %% Create Modulator and Demodulator
    hMod = comm.RectangularQAMModulator(obj.M);     % Create a 16-QAM modulator
    hMod.BitInput = true;                           % Accept bits as inputs
    hMod.SymbolMapping = 'Gray';                    % Gray coded symbol mapping
    hDemod = comm.RectangularQAMDemodulator(obj.M); % Create a 16-QAM demodulator
    hDemod.BitOutput = true;                        % Output bits
    hDemod.SymbolMapping = 'Gray';                  % Gray coded symbol mapping
    

    Create private properties called Modulator and Demodulator to
    store the modulator and demodulator objects.

    % Internal variables
    properties (Access = private)
    SNR
    Modulator
    Demodulator
    end
    

13. In the constructor method, replace hMod and hDemod with
    the object property obj.Modulator and obj.Demodulator respectively.

    % Create a 16-QAM modulator
    obj.Modulator = comm.RectangularQAMModulator(obj.M, ...
    'BitInput',true,'SymbolMapping','Gray');
    % Create a 16-QAM demodulator
    obj.Demodulator = comm.RectangularQAMDemodulator(obj.M, ...
    'BitOutput',true,'SymbolMapping','Gray');

    In the run method, replace hMod and hDemod with
    object properties obj.Modulator and obj.Demodulator.

    y = modulate(obj.Modulator,x);
    z = demodulate(obj.Demodulator,yRx);
    

14. Locate the setup region of the file.

    function setup(obj)
    % SETUP Initialize the system
    % SETUP(H) gets current test parameter value(s) from the test
    % console and initializes system, H, accordingly.
    

15. Set the M value of the modulator and demodulator by
    adding the following lines of code to the setup.

    obj.Modulator.M = obj.M;
    obj.Demodulator.M = obj.M;
    

16. Save the file.

17. Create an optimized system. At the MATLAB command
    line, enter:

    myOptimSystem = MyGrayCodedModulationOptimized

18. Create an Error Rate Test Console and attach the system
    to the test console. At the MATLAB command line, type:

    testConsole = commtest.ErrorRate(myOptimSystem)

19. At the MATLAB command line, type:

    registerTestPoint(testConsole, 'DemodBitErrors', 'TxBits', 'RxBits');

    This line defines the test point, DemodBitErrors, and compares
    bits from the TxBits probe to the bits from the RxBits probe. The
    Error Rate Test Console calculated metrics for this test point.

20. Configure the Error Rate Test Console to run simulations
    for EbNo values. Start at 2 dB and end at 10 dB, with a step size
    of 2 dB and M values of 2, 4, 8, and 16. At the MATLAB command
    line, type:

    setTestParameterSweepValues(testConsole, 'EbNo', 2:2:10)
    setTestParameterSweepValues(testConsole, 'M', [2 4 8 16])
    

21. Configure the Error Rate Test Console so it uses the
    demodulator bit error test point for determining the number of transmitted
    bits.

    testConsole.TransmissionCountTestPoint = 'DemodBitErrors'
    

22. To obtain more accurate results, run the simulations
    for a given minimum number of errors. In this example, you also limit
    the number of simulation bits so that the simulations do not run indefinitely.
    At the MATLAB command line, type:

    testConsole.SimulationLimitOption = 'Number of errors or transmissions';
    testConsole.MinNumErrors = 100;
    testConsole.ErrorCountTestPoint = 'DemodBitErrors';
    testConsole.MaxNumTransmissions = 1e8;
    testConsole

23. Run the simulation. At the MATLAB command line,
    type:

    tic; run(testConsole); toc

    MATLAB returns the following information:

    Running simulations...
    Elapsed time is 191.748359 seconds.
    

    Notice that these optimization changes reduce the simulation
    run time about 10%.

24. Generate the new results in a Figure window. At the MATLAB command
    line, type:

    grayResults = getResults(testConsole);
    grayResults.TestParameter2 = 'M'
    semilogy(grayResults) 

    This script generates the
    following figure.