Bit error rate analysis tool matlab

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.