turbo 5.7RSCC编码matlab程序

clear all;
close all;
clc;
% Program written by Ayoade Oguntade
% The University of Toledo
% oguntadeayo@
% Recursive Systematic Convolutional Code for Turbo code encoders
% This project uses a (5,7) RSCC for the encoding and
% uses the log-MAP algorithm for decoding
% ******************************************************************

d = [0 1 0 0 0 0 1 0 0 1]; %10-bit input to the encoder
No = 1.5; % Noise Variance

% *****************************Encoder*************************************
m1=0;
m2=0;
p = zeros(1,10);

for i=1:10 % For 10 input bits
b = xor(d(i),m2);
c = xor(b,m1);
p(i)=xor(c,m2);
m2=m1; % Content of memory register m1 shifting to m2
m1=d(i);
end

% ****************Mapping of d and p in BPSK bits of +1 and-1**************
for i=1:10
if d(i)==0;
bpsk=-1;
d(i)=bpsk;
else
bpsk=1;
d(i)=bpsk;
end
end

for k=1:10
if p(k)==0;
bpsk=-1;
p(k)=bpsk;
else
bpsk=1;
p(k)=bpsk;
end
end

%***********Generating Gaussian Noise************************************

Noise = sqrt(No).*randn(1,100); %Generating 100 samples of noise data

% **************Adding AWGN*****************************************

w = randint(1,10,[1 100]);%Generating 10 random integers from 1 to 100
h = randint(1,10,[1 100]);%Generating 10 random integers from 1 to 100

k = zeros(1,10);
l = zeros(1,10);
x = zeros(1,10);
y = zeros(1,10);

for i=1:10;
k(i) = 2*d(i);
l(i) = 2*p(i);
x(i) = k(i)+ Noise(w(i)); % Adding 10 random noise data from 100 samples
y(i) = l(i)+ Noise(h(i)); % Adding 10 random noise data from 100 samples
end

%**************************Puncturing of y*********************************
% Note that only five bits of y are transmitted (Even bits). The punctured
% positions (odd bits) are replaced with zeros at the receiver when decoding
% is done
empty_y = zeros (1,10);
y_p= empty_y;
even = [2 4 6 8 10];
for i=1:5
y_p(even(i)) = y(even(i));
end

%*********************Gamma Calculations***********************************
gamma = zeros (4,11);
g = zeros(4,11);

r1 = [1 1 -1 -1]; %bpsk bits of d
s1 = [-1 1 1 -1]; %bpsk bits of p


%*********************The first three time units (1-3)*********************
%Gamma is zero for the first time unit hence it is all zeros for all the states.
for i=1:2 % The first two bits of d and p
for t =1:4 % The four rows of the gamma matix - four transition states
g(t)=(exp(-((x(i)-r1(t))^2)/No).*exp(-((y_p(i)-s1(t))^2)/No));
gamma(t,(i+1))=g(t);
end
end
%*********************The next eight time units (4 -11)***********************
r2 = [1 1 -1 -1 1 1 -1 -1]; %bpsk bits of d
s2 = [-1 1 1 -1 -1 1 1 -1]; %bpsk bits of p
a1 = [1 2 3 4];
a2 = [5 6 7 8];

g4alpha = zeros(8,8);%To store 8 valued gammas for later use in calculating alpha and beta
u=zeros (4,1);

for i=3:1

0 % The next eight bits of d and p
for t=1:8 % To calculate 8 gamma values from the fourth time unit
g(t)=(exp(-((x(i)-r2(t))^2)/No).*exp(-((y_p(i)-s2(t))^2)/No));
g4alpha(t,(i-2))=g(t); %8 gamma values being stored be used later for alpha and beta calculations
end
for k=1:4 % Summing the gammas that lead into the same state
u(k)= g(a1(k))+ g(a2(k));
gamma(k,(i+1))=u(k);
end
end

gamma(1,2)=0;
gamma(3,2)=0;


%*********************Alpha Calculations***********************************

alpha = zeros (4,11);

alpha(4,1)=1;

alpha(2,2)=alpha(4,1).*gamma(2,2);
alpha(4,2)=alpha(4,1).*gamma(4,2);

alpha(1,3)=alpha(2,2).*gamma(1,3);
alpha(2,3)=alpha(4,2).*gamma(2,3);
alpha(3,3)=alpha(2,2).*gamma(3,3);
alpha(4,3)=alpha(4,2).*gamma(4,3);

alpha(1,4)=alpha(1,3).*g4alpha(1,1)+ alpha(2,3).*g4alpha(5,1);
alpha(2,4)=alpha(3,3).*g4alpha(2,1)+ alpha(4,3).*g4alpha(6,1);
alpha(3,4)=alpha(1,3).*g4alpha(7,1)+ alpha(2,3).*g4alpha(3,1);
alpha(4,4)=alpha(3,3).*g4alpha(8,1)+ alpha(4,3).*g4alpha(4,1);

alpha(1,5)=alpha(1,4).*g4alpha(1,2)+ alpha(2,4).*g4alpha(5,2);
alpha(2,5)=alpha(3,4).*g4alpha(2,2)+ alpha(4,4).*g4alpha(6,2);
alpha(3,5)=alpha(1,4).*g4alpha(7,2)+ alpha(2,4).*g4alpha(3,2);
alpha(4,5)=alpha(3,4).*g4alpha(8,2)+ alpha(4,4).*g4alpha(4,2);

alpha(1,6)=alpha(1,5).*g4alpha(1,3)+ alpha(2,5).*g4alpha(5,3);
alpha(2,6)=alpha(3,5).*g4alpha(2,3)+ alpha(4,5).*g4alpha(6,3);
alpha(3,6)=alpha(1,5).*g4alpha(7,3)+ alpha(2,5).*g4alpha(3,3);
alpha(4,6)=alpha(3,5).*g4alpha(8,3)+ alpha(4,5).*g4alpha(4,3);

alpha(1,7)=alpha(1,6).*g4alpha(1,4)+ alpha(2,6).*g4alpha(5,4);
alpha(2,7)=alpha(3,6).*g4alpha(2,4)+ alpha(4,6).*g4alpha(6,4);
alpha(3,7)=alpha(1,6).*g4alpha(7,4)+ alpha(2,6).*g4alpha(3,4);
alpha(4,7)=alpha(3,6).*g4alpha(8,4)+ alpha(4,6).*g4alpha(4,4);

alpha(1,8)=alpha(1,7).*g4alpha(1,5)+ alpha(2,7).*g4alpha(5,5);
alpha(2,8)=alpha(3,7).*g4alpha(2,5)+ alpha(4,7).*g4alpha(6,5);
alpha(3,8)=alpha(1,7).*g4alpha(7,5)+ alpha(2,7).*g4alpha(3,5);
alpha(4,8)=alpha(3,7).*g4alpha(8,5)+ alpha(4,7).*g4alpha(4,5);

alpha(1,9)=alpha(1,8).*g4alpha(1,6)+ alpha(2,8).*g4alpha(5,6);
alpha(2,9)=alpha(3,8).*g4alpha(2,6)+ alpha(4,8).*g4alpha(6,6);
alpha(3,9)=alpha(1,8).*g4alpha(7,6)+ alpha(2,8).*g4alpha(3,6);
alpha(4,9)=alpha(3,8).*g4alpha(8,6)+ alpha(4,8).*g4alpha(4,6);

alpha(1,10)=alpha(1,9).*g4alpha(1,7)+ alpha(2,9).*g4alpha(5,7);
alpha(2,10)=alpha(3,9).*g4alpha(2,7)+ alpha(4,9).*g4alpha(6,7);
alpha(3,10)=alpha(1,9).*g4alpha(7,7)+ alpha(2,9).*g4alpha(3,7);
alpha(4,10)=alpha(3,9).*g4alpha(8,7)+ alpha(4,9).*g4alpha(4,7);

alpha(1,11)=alpha(1,10).*g4alpha(1,8)+ alpha(2,10).*g4alpha(5,8);
alpha(2,11)=alpha(3,10).*g4alpha(2,8)+ alpha(4,10).*g4alpha(6,8);
alpha(3,11)=alpha(1,10).*g4alpha(7,8)+ alpha(2,10).*g4alpha(3,8);
alpha(4,11)=alpha(3,10).*g4alpha(8,8)+ alpha(4,10).*g4alpha(4,8);



%*********************Beta Calculations***********************************

beta = zeros (4,11);

beta(1,11)= alpha(1,11); %The last time unit (11)- Obtained from value of the last alpha
beta(2,11)= alpha(2,11); %The last time unit (11)- Obtained from value of the last alpha
beta(3,11)= alpha(3,11); %The last time unit (11)- Obtained from value of the last alpha
beta(4,11)= alpha(4,11); %The last time unit (11)- Obtained from value of the last alpha

beta(1,10)=beta(1,11).*g4alpha(1,8)+beta(3,11).*g4alpha(7,8);
beta(2,10)=beta(1,11).*g4alpha(5,8)+beta(3,11).*g4alpha(3,8);
beta(3,10)=beta(2,11).*g4alpha(2,8)+beta(4,11).*g4alpha(8,8);
beta(4,10)=beta(2,11).*g4alpha(6,8)+beta(4,11).*g4alpha(4,8);

beta(1,9)=beta(1,10).*g4alpha(1,7)+beta(3,10).*g4alpha(7,7);
beta(2,9)=beta(1,10).*g4alpha(5,7)+beta(3,10).*g4alpha(3,7);
beta(3,9)=beta(2,10).*g4alpha(2,7)+beta(4,10).*g4alpha(8,7);
beta(4,9)=beta(2,10).*g4alpha(6,7)+beta(4,10).*g4alpha(4,7);

beta(1,8)=beta(1,9).*g4alpha(1,6)+beta(3,9).*g4alpha(7,6);
beta(2,8)=beta(1,9).*g4alpha(5,6)+beta(3,9).*g4alpha(3,6);
beta(3,8)=beta(2,9).*g4alpha(2,6)+beta(4,9).*g4alpha(8,6);
beta(4,8)=beta(2,9).*g4alpha(6,6)+beta(4,9).*g4alpha(4,6);

beta(1,7)=beta(1,8).*g4alpha(1,5)+beta(3,8).*g4alpha(7,5);
beta(2,7)=beta(1,8).*g4alpha(5,5)+beta(3,8).*g4alpha(3,5);
beta(3,7)=beta(2,8).*g4alpha(2,5)+beta(4,8).*g4alpha(8,5);
beta(4,7)=beta(2,8).*g4alpha(6,5)+beta(4,8).*g4alpha(4,5);

beta(1,6)=beta(1,7).*g4alpha(1,4)+beta(3,7).*g4alpha(7,4);
beta(2,6)=beta(1,7).*g4alpha(5,4)+beta(3,7).*g4alpha(3,4);
beta(3,6)=beta(2,7).*g4alpha(2,4)+beta(4,7).*g4alpha(8,4);
beta(4,6)=beta(2,7).*g4alpha(6,4)+beta(4,7).*g4alpha(4,4);

beta(1,5)=beta(1,6).*g4alpha(1,3)+beta(3,6).*g4alpha(7,3);
beta(2,5)=beta(1,6).*g4alpha(5,3)+beta(3,6).*g4alpha(3,3);
beta(3,5)=beta(2,6).*g4alpha(2,3)+beta(4,6).*g4alpha(8,3);
beta(4,5)=beta(2,6).*g4alpha(6,3)+beta(4,6).*g4alpha(4,3);

beta(1,4)=beta(1,5).*g4alpha(1,2)+beta(3,5).*g4alpha(7,2);
beta(2,4)=beta(1,5).*g4alpha(5,2)+beta(3,5).*g4alpha(3,2);
beta(3,4)=beta(2,5).*g4alpha(2,2)+beta(4,5).*g4alpha(8,2);
beta(4,4)=beta(2,5).*g4alpha(6,2)+beta(4,5).*g4alpha(4,2);

beta(1,3)=beta(1,4).*g4alpha(1,1)+beta(3,4).*g4alpha(7,1);
beta(2,3)=beta(1,4).*g4alpha(5,1)+beta(3,4).*g4alpha(3,1);
beta(3,3)=beta(2,4).*g4alpha(2,1)+beta(4,4).*g4alpha(8,1);
beta(4,3)=beta(2,4).*g4alpha(6,1)+beta(4,4).*g4alpha(4,1);


beta(2,2)=beta(1,3).*gamma(1,3)+beta(3,3).*gamma(3,3);
beta(4,2)=beta(2,3).*gamma(2,3)+beta(4,3).*gamma(4,3);

beta(4,1)=beta(2,2).*gamma(2,2)+beta(4,2).*gamma(4,4);


%*********************Sigma Calculations**********************************


sigma01 = alpha(4,1).*gamma(4,2).*beta(4,2);
sigma11 = alpha(4,1).*gamma(2,2).*beta(2,2);

Rel1 =log(sigma11/sigma01);


sigma02 = alpha(2,2).*gamma(3,3).*beta(3,3)+ alpha(4,2).*gamma(4,3).*beta(4,3);
sigma12 = alpha(2,2).*gamma(1,3).*beta(1,3)+ alpha(4,2).*gamma(2,3).*beta(2,3);

Rel2 =log(sigma12/sigma02);


sigma03 = alpha(1,3).*g4alpha(7,1).*beta(3,4)+ alpha(2,3).*g4alpha(3,1).*beta(3,4)+...
alpha(3

,3).*g4alpha(8,1).*beta(4,4)+ alpha(4,3).*g4alpha(4,1).*beta(4,4);

sigma13 = alpha(1,3).*g4alpha(1,1).*beta(1,4)+ alpha(2,3).*g4alpha(5,1).*beta(1,4)+...
alpha(3,3).*g4alpha(2,1).*beta(2,4)+ alpha(4,3).*g4alpha(6,1).*beta(2,4);

Rel3 =log(sigma13/sigma03);


sigma04 = alpha(1,4).*g4alpha(7,2).*beta(3,5)+ alpha(2,4).*g4alpha(3,2).*beta(3,5)+...
alpha(3,4).*g4alpha(8,2).*beta(4,5)+ alpha(4,4).*g4alpha(4,2).*beta(4,5);

sigma14 = alpha(1,4).*g4alpha(1,2).*beta(1,5)+ alpha(2,4).*g4alpha(5,2).*beta(1,5)+...
alpha(3,4).*g4alpha(2,2).*beta(2,5)+ alpha(4,4).*g4alpha(6,2).*beta(2,5);

Rel4 =log(sigma14/sigma04);


sigma05 = alpha(1,5).*g4alpha(7,3).*beta(3,6)+ alpha(2,5).*g4alpha(3,3).*beta(3,6)+...
alpha(3,5).*g4alpha(8,3).*beta(4,6)+ alpha(4,5).*g4alpha(4,3).*beta(4,6);

sigma15 = alpha(1,5).*g4alpha(1,3).*beta(1,6)+ alpha(2,5).*g4alpha(5,3).*beta(1,6)+...
alpha(3,5).*g4alpha(2,3).*beta(2,6)+ alpha(4,5).*g4alpha(6,3).*beta(2,6);

Rel5 =log(sigma15/sigma05);

sigma06 = alpha(1,6).*g4alpha(7,4).*beta(3,7)+ alpha(2,6).*g4alpha(3,4).*beta(3,7)+...
alpha(3,6).*g4alpha(8,4).*beta(4,7)+ alpha(4,6).*g4alpha(4,4).*beta(4,7);

sigma16 = alpha(1,6).*g4alpha(1,4).*beta(1,7)+ alpha(2,6).*g4alpha(5,4).*beta(1,7)+...
alpha(3,6).*g4alpha(2,4).*beta(2,7)+ alpha(4,6).*g4alpha(6,4).*beta(2,7);

Rel6 =log(sigma16/sigma06);

sigma07 = alpha(1,7).*g4alpha(7,5).*beta(3,8)+ alpha(2,7).*g4alpha(3,5).*beta(3,8)+...
alpha(3,7).*g4alpha(8,5).*beta(4,8)+ alpha(4,7).*g4alpha(4,5).*beta(4,8);

sigma17 = alpha(1,7).*g4alpha(1,5).*beta(1,8)+ alpha(2,7).*g4alpha(5,5).*beta(1,8)+...
alpha(3,7).*g4alpha(2,5).*beta(2,8)+ alpha(4,7).*g4alpha(6,5).*beta(2,8);

Rel7 =log(sigma17/sigma07);


sigma08 = alpha(1,8).*g4alpha(7,6).*beta(3,9)+ alpha(2,8).*g4alpha(3,6).*beta(3,9)+...
alpha(3,8).*g4alpha(8,6).*beta(4,9)+ alpha(4,8).*g4alpha(4,6).*beta(4,9);

sigma18 = alpha(1,8).*g4alpha(1,6).*beta(1,9)+ alpha(2,8).*g4alpha(5,6).*beta(1,9)+...
alpha(3,8).*g4alpha(2,6).*beta(2,9)+ alpha(4,8).*g4alpha(6,6).*beta(2,9);

Rel8 =log(sigma18/sigma08);

sigma09 = alpha(1,9).*g4alpha(7,7).*beta(3,10)+ alpha(2,9).*g4alpha(3,7).*beta(3,10)+...
alpha(3,9).*g4alpha(8,7).*beta(4,10)+ alpha(4,9).*g4alpha(4,7).*beta(4,10);

sigma19 = alpha(1,9).*g4alpha(1,7).*beta(1,10)+ alpha(2,9).*g4alpha(5,7).*beta(1,10)+...
alpha(3,9).*g4alpha(2,7).*beta(2,10)+ alpha(4,9).*g4alpha(6,7).*beta(2,10);


Rel9 =log(sigma19/sigma09);

sigma010 = alpha(1,10).*g4alpha(7,8).*beta(3,11)+ alpha(2,10).*g4alpha(3,8).*beta(3,11)+...
alpha(3,10).*g4alpha(8,8).*beta(4,11)+ alpha(4,10).*g4alpha(4,8).*beta(4,11);
sigma110 = alpha(1,10).*g4alpha(1,8).*beta(1,11)+ alpha(2,10).*g4alpha(5,8).*beta(1,11)+...
alpha(3,10).*g4alpha(2,8).*beta(2,11)+ alpha(4,10).*g4alpha(6,8).*beta(2,11);


Rel10 =log(sigma110/sigma010);


Reliability = [Rel1 Rel2 Rel3 Rel4 Rel5 Rel6 Rel7 Rel8 Rel9 Rel10];

Decoded = zeros(1,10);
for i=1:10

if Reliability(i)>0
Decoded(i) = 1;
else
Decoded(i) = 0;
end

end

Reliability %#ok
d %#ok
Decoded %#ok