Introduction to MATLAB

[1]. Generate the binary data stream, modulate it using a 16-QAM baseband
modulator, transmit it through AWGN channel and then demodulate. Compute
the system’s bit error rate (BER). Also, display the transmitted and received
signals in a scatter plot.

1. Generate a Random Binary Data Stream. The conventional format for

representing a signal in MATLAB is a vector or matrix. This example uses the
randint function to create a column vector that lists the successive values of a
binary data stream. The length of the binary data stream (that is, the number of
rows in the column vector) is arbitrarily set to 30,000.
% Define parameters.
M = 16; % Size of signal constellation
k = log2(M); % Number of bits per symbol
n = 3e4; % Number of bits to process

% Create a binary data stream as a column vector.

x = randint(n,1); % Random binary data stream

% Plot first 50 bits in a stem plot.

stem(x(1:50),'filled');
title('Random Bits');
xlabel('Bit Index'); ylabel('Binary Value');

2. Prepare to Modulate. The modem.qammod object implements an M-ary QAM

modulator, M being 16 in this example. It is configured to receive integers
between 0 and 15 rather than 4-tuples of bits. Therefore, you must preprocess the
binary data stream x before using the modulate method of the object. In
particular, you arrange each 4-tuple of values from x across a row of a matrix,
using the reshape function in MATLAB, and then apply the bi2de function to
convert each 4-tuple to a corresponding integer. (The .' characters after the
reshape command form the unconjugated array transpose operator in MATLAB.
% Convert the bits in x into k-bit symbols.
mapping = [0 1 3 2 4 5 7 6 12 13 15 14 8 9 11 10].';% for gray coded
xsym = bi2de(reshape(x,k,length(x)/k).','left-msb');
xsym = mapping(xsym+1); % for gray coded

% Plot first 20 symbols in a stem plot.

figure; % Create new figure window.
stem(xsym(1:20));
title('Random Symbols');
xlabel('Symbol Index'); ylabel('Integer Value');

3. Modulate Using 16-QAM. Having defined xsym as a column vector

containing integers between 0 and 15, you can use the ‘qammod’ method of the
object to modulate xsym using the baseband representation. Recall that M is 16,
the alphabet size.
% Modulate using 16-QAM.
y = modulate(modem.qammod(M),xsym);
%% Transmitted Signal
ytx = y;

The result is a complex column vector whose values are in the 16-point QAM
signal constellation.

4. Add White Gaussian Noise. Applying the awgn function to the modulated
signal adds white Gaussian noise to it. The ratio of bit energy to noise power
spectral density, Eb/N0, is arbitrarily set at 10 dB.
% Send signal over an AWGN channel.
ynoisy = awgn(ytx,10,'measured');

%% Received Signal
yrx = ynoisy;

5. Create a Scatter Plot. Applying the scatterplot function to the transmitted and
received signals shows what the signal constellation looks like and how the noise
distorts the signal. In the plot, the horizontal axis is the in-phase component of
the signal and the vertical axis is the quadrature
component.
%% Scatter Plot
% Create scatter plot of noisy signal and transmitted
% signal on the same axes.
h = scatterplot(yrx(1:3e3),1,0,'g.');
hold on;
scatterplot(ytx(1:3e3),1,0,'r+',h);
title('Received Signal');
legend('Received Signal','Signal Constellation');
axis([-5 5 -5 5]); % Set axis ranges.
hold off;
6. Demodulate Using 16-QAM. Applying the ‘qamdemod’ to the received signal
demodulates it. The result is a column vector containing integers between 0 and
15.

%% Demodulation
% Demodulate signal using 16-QAM.
zsym = demodulate(modem.qamdemod(M),yrx);

7. Convert the Integer-Valued Signal to a Binary Signal. The previous step

produced zsym, a vector of integers. To obtain an equivalent binary signal, use
the de2bi function to convert each integer to a corresponding binary 4-tuple
along a row of a matrix. Then use the reshape function to arrange all the bits in a
single column vector rather than a four-column matrix.
%% Symbol-to-Bit Mapping
% Undo the bit-to-symbol mapping performed earlier.
z = de2bi(zsym,'left-msb'); % Convert integers to bits.
% Convert z from a matrix to a vector.
z = reshape(z.',prod(size(z)),1);

8. Compute the System’s BER. Applying the biterr function to the original
binary vector and to the binary vector from the demodulation step above yields
the number of bit errors and the bit error rate.

%% BER Computation
% Compare x and z to obtain the number of errors and
% the bit error rate.
[number_of_errors,bit_error_rate] = biterr(x,z)

[2]. Repeat the above programme for various modulation schemes.

For BPSK:
M=2
y = modulate(modem.pskmmod(M),xsym);
zsym = demodulate(modem.pskdemod(M),yrx);

For QPSK : M=4

For MSK:
M=2
y = modulate(modem.mskmod,xsym);
zsym = demodulate(modem.mskdemod,yrx);

Also change the value of SNR in AWGN to compare the result.

[3]. Repeat problem [1] for gray coded 16-QAM scheme.

Change the following sections as shown below:

(1)
%% Bit-to-Symbol Mapping
% Convert the bits in x into k-bit symbols, using
% Gray coding.
mapping = [0 1 3 2 4 5 7 6 12 13 15 14 8 9 11 10].';
Do ordinary binary-to-decimal mapping.
xsym = bi2de(reshape(x,k,length(x)/k).','left-msb');
Map from binary coding to Gray coding.
xsym = mapping(xsym+1);
(2)
%% Symbol-to-Bit Mapping
[dummy demapping] = sort(mapping);
% Initially, demapping has values between 1 and M.
% Subtract 1 to obtain values between 0 and M-1.
demapping = demapping - 1;
Map between Gray and binary coding.
zsym = demapping(zsym+1);
Do ordinary decimal-to-binary mapping.
z = de2bi(zsym,'left-msb');
Convert z from a matrix to a vector.
z = reshape(z.',prod(size(z)),1);

Compare the BER of Problem (1) & (3) and comment on the results.
[4]. Modify the modulation in Problem (3) so that it computes the BER for integer
values of EbNo between 0 and 7. Plot the BER as a function of EbNo using a
logarithmic scale for the vertical axis. (Using ‘bertool’ )

BERTool solves the problem by managing a series of simulations with different

values of Eb/N0, collecting the results, and creating a plot.

edit bertooltemplate

1. Save Template in Your Own Directory. Navigate to a directory where you

want to save your own files. Save the BERTool template (bertooltemplate) under
the filename sac_bertool to avoid overwriting the original template.
Also, change the first line of sac_bertool, which is the function declaration, to use
the new filename.

function [ber, numBits] = sac_bertool(EbNo, maxNumErrs, maxNumBits)

2. Copy Setup Code Into Template. In the sac_bertool file, replace

% --- Set up parameters. ---
% --- INSERT YOUR CODE HERE.
with the following setup code adapted from the problem(3)
% Setup
% Define parameters.
M = 16; % Size of signal constellation
k = log2(M); % Number of bits per symbol
n = 1000; % Number of bits to process
nsamp = 1; % Oversampling rate

3. Copy Simulation Code Into Template. In the sac_bertool file, replace

% --- Proceed with simulation.
% --- Be sure to update totErr and numBits.
% --- INSERT YOUR CODE HERE.
with the rest of the code (that is, the code following the Setup section) from
the problem (3)

4. Update numBits and totErr. After the pasted code from the last step and
before the end statement from the template, insert the following code.
%% Update totErr and numBits.
totErr = totErr + number_of_errors;
numBits = numBits + n;

5. Suppress Earlier Plots. Running multiple iterations would result in a large

number of plots, which this example suppresses for simplicity. In the sac_bertool
file, remove the lines of code that use these functions:
stem, title, xlabel, ylabel, figure, scatterplot, hold, legend, and axis.

6. Omit Direct Assignment of EbNo. When BERTool invokes a simulation

function, it specifies a value of EbNo. The sac_bertool function must not directly
assign EbNo. Therefore, remove or comment out the line that you pasted into
sac_bertool (within the Channel section) that assigns EbNo directly.
% EbNo = 10; % In dB % COMMENT OUT FOR BERTOOL
7. Save Simulation Function. The simulation function, sac_bertool, is complete.
Save the file so that BERTool can use it.

8. Open BERTool and Enter Parameters. To open BERTool, enter bertool

in the MATLAB Command Window. Then click the Monte Carlo tab. Set the
parameters.

9. Use BERTool to Simulate and Plot. Click the Run button on BERTool.
[5] Scalar Quantization ( Use of codebook, partition)
qunatiz function uses partition and codebook to provide quantization as shown
below.
% sample programme
partition = [0,1,3];
codebook = [-1, 0.5, 2, 3];
samp = [-2.4, -1, -.2, 0, .2, 1, 1.2, 1.9, 2, 2.9, 3, 3.5, 5];
[index,quantized] = quantiz(samp,partition,codebook);
quantized

The output is below.

quantized =
Columns 1 through 6
-1.0000 -1.0000 -1.0000 -1.0000 0.5000 0.5000
Columns 7 through 13
2.0000 2.0000 2.0000 2.0000 2.0000 3.0000 3.0000

Run the programme final_scalar.m

(1) Change the signal from sine to sawtooth and observe the effects.
(2) Change the partition and codebook and observe the effect on the quantized signal.

[6] Optimizing Quantization Parameters using Lloyds function

The lloyds function optimizes the partition and codebook according to the Lloyd
algorithm. The code below optimizes the partition and codebook for one period
of a sinusoidal signal, starting from a rough initial guess. Then it uses these
parameters to quantize the original signal using the initial guess parameters as
well as the optimized parameters. The output shows that the mean square
distortion after quantizing is much less for the optimized parameters. The
quantiz function automatically computes the mean square distortion and returns
it as the third output parameter.
Run the programme final_opt_scalar.m.

Change the waveform from sin to sawtooth and compare the distortion before
optimization and after optimization.
Lab Session 2
[7] Hamming code
%Encoding and decoding of [7,4] Hamming code.
close all;
clear all;
clc;
m = 3; n = 2^m-1; k = n-m;
parmat = hammgen(m); % Produce parity-check matrix.
trt = syndtable(parmat); % Produce decoding table.
recd = [1 0 0 1 1 1 1] % Suppose this is the received vector.
syndrome = rem(recd * parmat',2);
syndrome_de = bi2de(syndrome,'left-msb'); % Convert to decimal.
disp(['Syndrome = ',num2str(syndrome_de),...
' (decimal), ',num2str(syndrome),' (binary)'])
corrvect = trt(1+syndrome_de,:) % Correction vector
% Now compute the corrected codeword.
correctedcode = rem(corrvect+recd,2)

 Modify the received code word ‘recd’ and run the programme again.
 Modify above programme for m=4 i.e. [15,11] Hamming code. Make
necessary corrections in the programme.
m=4
recd = [ any 15 bit code word]

[8] Convolution coding

The encoder's constraint length is a vector of length 2 because the encoder has two inputs.
The elements of this vector indicate the number of bits stored in each shift register,
including the current input bits. Counting memory spaces in each shift register in the
diagram and adding one for the current inputs leads to a constraint length of [5 4].

To determine the code generator parameter as a 2-by-3 matrix of octal numbers, use the
element in the ith row and jth column to indicate how the ith input contributes to the jth
output. For example, to compute the element in the second row and third column, the
leftmost and two rightmost elements in the second shift register of the diagram feed into
the sum that forms the third output. Capture this information as the binary number 1011,
which is equivalent to the octal number 13. The full value of the code generator matrix is
[23 35 0; 0 5 13].
To use the constraint length and code generator parameters in the convenc and vitdec
functions, use the poly2trellis function to convert those parameters into a trellis
structure. The command to do this is below.

trel = poly2trellis([5 4],[23 35 0;0 5 13]); % Define trellis.

% 2/3 rate convolution coder- encoding & decoding

close all;
clear all;
clc;
len = 1000;
msg = randint(2*len,1); % Random binary message of 2-bit symbols
trel = poly2trellis([5 4],[23 35 0;0 5 13]); % Trellis
code = convenc(msg,trel); % Encode the message.
ncode = rem(code + randerr(3*len,1,[0 1;.96 .04]),2); % Add noise.
decoded = vitdec(ncode,trel,34,'cont','hard'); % Decode.
[number,ratio] = biterr(decoded(68+1:end),msg(1:end-68))

 Construct the trellis description for the following convolution coder.

Use it in the above programme.

[ans: trellis = poly2trellis(5,[37,33]);]

Make necessary changes in the above programme to simulate ½ rate coder.

[9] Simulation of Delta Modulation with and without slope overload

step=0.1; % step size

fs=1000; % dT=0.001, slope=step/dt=100
fm = 10; A=1; % maximum slope=2*pi*fm*A=62.8, no slope overloading

t=0:1/fs:((2/fm)-(1/fs)); % Two cycles

x=A*sin(2*pi*fm*t);
subplot(221);plot(x); title('original signal');

% Modulation
xq(1)=0; d(1)=0;
for n=2:length(x),
d(n)=sign(x(n)-xq(n-1));
xq(n)=xq(n-1)+d(n)*step;
end
subplot(222);
plot(d(1:100)), axis([0 100 -10.2 10.2]);
title('First 100 output of delta modultaion')

% Demodulation
y=0;
for n=2:length(d)
y(n)=y(n-1)+d(n);
end;
subplot(223);plot(y); title('demodulation by summing');

%slope overload
A=2.5; x=A*x; %max. slope=2.5*62.8=157, slope overloading
% Modulation
xq(1)=0; d(1)=0;
for n=2:length(x),
d(n)=sign(x(n)-xq(n-1)); xq(n)=xq(n-1)+d(n)*step;
end
% Demodulation
y=0;
for n=2:length(d)
y(n)=y(n-1)+d(n);
end;
subplot(224), plot(y); title('demodulation by summing, slope overload')

Change the value of A >1 for slope overload effect and <1 for observing the
effects of granual noise.
[10] Simulation of Hamming code with and without interleaver. Observe the
ability of interleaver to correct burst errors

seed1 = 1428; % Random number seed for random message generation

seed2 = 5975; % Random number seed for interleaving and deinterleaving
n = 7; k = 4; % Parameters for Hamming code
inp_msg = randint(k*500,1,2,seed1); % Input message to encode
op_code = encode(inp_msg,n,k,'hamming/binary'); % Encoded output

errors = zeros(size(op_code));
errors(n-2:n+3) = [1 1 1 1 1 1]; % Burst error affecting adjacent blocks

% First we find probability of error when interleaver is not used

code_error = bitxor(op_code,errors); % Introduction of burst error
decoded_inp = decode(code_error,n,k,'hamming/binary'); % Decoded input
disp('Number of errors and error rate, without interleaving:');
[num_no_interleav,rate_no_interleav] = biterr(inp_msg,decoded_inp)

% Next we find probability of error using interleaver

inter_op_code = randintrlv(op_code,seed2); % Interleaving of output code
inter_op_err = bitxor(inter_op_code,errors); % Introduction of burst
error
deinter_op = randdeintrlv(inter_op_err,seed2); % Deinterleaving
decoded_inp_inter = decode(deinter_op,n,k,'hamming/binary');
disp('Number of errors and error rate, with interleaving:');
[num_interleav,rate_interleav] = biterr(inp_msg,decoded_inp_inter)

Result:
Number of errors and error rate, without interleaving:
num_no_interleav =
4
rate_no_interleav =
0.0020
Number of errors and error rate, with interleaving:
num_interleav =
0
rate_interleav =
0

* Change the error pattern, seed1, seed2 and type of code in the above
programme and observe.
[11] Generation of PN sequence and spreading of data using it. Plot the
frequency spectrum of the spreaded signal.

% This shows generation of DS spread spectrum

close all;
clear all;
clc;

pn=round(rand(1,20)); % Generating the PN sequence for spreading

subplot(231),plot(pn);title('Pseudorandom Bit Sequence');
msg=round(rand(1,5)); % Generating the bit seq with each message 6
samples long
bitseq=[];
for i=1:5
if msg(i)==0
sig=zeros(1,20);
else
sig=ones(1,20);
end
bitseq=[bitseq sig];
end
subplot(232),plot(bitseq);title('Message Bit Sequence');

pnsig = [pn pn pn pn pn];

subplot(233); plot(pnsig);
spread_sig=bitxor(bitseq,pnsig);% Spreading : XORing the message with
the PN seq
subplot(234);plot(spread_sig);

%BPSK Modulation of spread data for transmission

ds_ss=[]; % initializing DS SS signal
fc=10000; fs=10000; % fc=carrier freq, fs=sampling freq used
t=0:1/fs:1/fc-1/fs;
m1=cos(2*pi*fc*t); m2=cos(2*pi*fc*t+pi); % BPSK signals
for i=1:100
if spread_sig(i)==0
ds_ss=[ds_ss m1];
else
ds_ss=[ds_ss m2];
end
end
subplot(235),plot(ds_ss);title('DS Spread Spectrum Signal');
subplot(236),plot(abs(fft(ds_ss))), title('FFT of DS Spread Spectrum
Signal');
* Change the spreading factor in the above code
* Change the code to make it generic for random data sequence.
Introduction to SIMULINK

by

Prof Manisha Upadhyay

[1]. Pulse Amplitude Modulation (PAM)
[2] Pulse Width Modulation
[3] Quantization
[4]. Simulation of BPSK scheme in the presence of noise and evaluate BER.

Bernuolli Binary Generator

BPSK Modulator

AWGN Channel
Error Rate Calculation

Output on Scope

 Change the value of Es/No and observe the effects.

 Change the modulation technique to QPSK and also observe the scatter
plot. Make the necessary changes as shown below.
In place of binary generator,
connect random integer generator
[5] QPSK Modulator & Demodulator:
  Change Modulation technique to QAM.

[6] Auto correlation & Cross Correlation of spread spectrum code generator

Set the parameters as shown below in first three code generators.

In the last Walsh code generator, set code index = 30

[7] Comapnding using -Law and comparison of distortion with and without
companding

In the command window, type

sig = -4:.1:4;
sig = exp(sig'); % Exponential signal to quantize

Set the block parameters as shown below:

• Signal From Workspace, in the Signal Processing Sources library
- Set Signal to sig.
• Mu-Law Compressor
- Set Peak signal magnitude to max(sig).
• Quantizing Encoder
- Set Quantization partition to 0:floor(max(sig)).
- Set Quantization codebook to 0:ceil(max(sig)).
• Terminator
• Demux
• Mu-Law Expander
- Set Peak signal magnitude to ceil(max(sig)).
• To Workspace,
- Set Variable name to nocompander and withcompander, respectively,
in the two copies of this block.
- Set Save format to Array in each of the two copies of this block.

Run the simulation.

In the command window, type

distor = sum((nocompander-sig).^2)/length(sig);
distor2 = sum((withcompander-sig).^2)/length(sig);
 [distor distor2]

ans =

89.177 0.0397

[8] Amplitude Shift Keying (without using block)