Informe Codificacion 2parcial Torres Orbe

[COMUNICACIN Y CODIFICACIN DIGITAL]
1
IVAN ORBE DAVID TORRES
INFORME N2
INTEGRANTES:
-DAVID TORRES RACINES -IVAN ORBE OROZCO
NIVEL: 8vo
___________________________________________________________________________________________________
1. TEMAS:

MODULACION BPSK
MODULACION QPSK
MODULACION 8 PSK
CODIGOS CONVOLUCIONALES
CODIGOS TURBO

2. OBJETIVOS

- Complementar el anlisis terico de la materia, con la programacin en Matlab.
- Verificar la veracidad de la teora aplicada mediante la utilizacin de la
simulacin de las diferentes tipos de modulaciones y temas a tratar.
- Entender y comprender la transmisin de los bits, como estos llegan con
errores, como tratarlos y corregirlos.
- Aprender las tcnicas de correccin de errores en un mensaje, en este caso, con
la utilizacin de cdigo en Matlab.
- Poner en prctica la teora aprendida a lo largo de este tema.


2

3. MARCO TERICO
3.1. CODIGO CONVOLUCIONAL

En las transmisiones digitales actuales la codificacin es un proceso muy
elaborado, con un diagrama de bloques general que mostramos en la
siguiente figura 1.

Fig. 1

Este sistema contiene dos codificadores propiamente dichos: uno exterior de bloques,
y uno interior convolucional. Estos dos codificadores introducen redundancia en los
datos con objeto de poder detectar o corregir errores de transmisin. El sistema
contiene adems dos entrelazados cuyo objetivo es hacer que bloques correlativos de
bits no se transmitan juntos. Este es el esquema de codificacin empleado en la
televisin digital DVB (Digital Video Bradcasting). El esquema de codificacin
utilizado en la telefona mvil GSM es similar, pues usa un codificador de bloques, un
codificador convolucional y un entrelazado.


3
Los cdigos convolucionales son adecuados para usar sobre canales con mucho ruido
(alta probabilidad de error).
Los cdigos convolucionales son cdigos lineales, donde la suma de dos palabras de
cdigo cualesquiera tambin es una palabra de cdigo. Y al contrario que con los
cdigos lineales, se prefieren los cdigos no sistemticos.
El sistema tiene memoria: la codificacin actual depende de los datos que se envan
ahora y que se enviaron en el pasado.
Un cdigo convolucional queda especificado por tres parmetros (n,k,m):
n es el nmero de bits de la palabra codificada
k es el nmero de bits de la palabra de datos
m es la memoria del cdigo o longitud restringida
La codificacin convolucional es una codificacin continua en la que la secuencia de
bits codificada depende de los bits previos. El codificador consta de un registro de
desplazamiento de K segmentos de longitud k (en total kK) que se desplaza k
posiciones por ciclo y genera n funciones EXOR tambin por ciclo. La tasa de
codificacin es, entonces, R=k/n.
En el siguiente ejemplo mostramos un registro que se desplaza una posicin por ciclo
(k=1), que consta de Kk=3 celdas y que genera N=3 funciones EXOR por ciclo.


4

3.1.1. PROCESO DE CODIFICACIN

El proceso de codificacin de estos cdigos se realiza utilizando un dispositivo
lgico en el codificador.
Ejemplo 1: Codificador convolucional (4,3,5)

La palabra codificada se obtendra como el resultado de realizar una serie de
operaciones lgicas entre determinados bits que estn almacenados en los registros
intermedios.
Ejemplo 2: Codificador convolucional (2,1,3)

- El conmutador con las dos entradas hace el papel de un registro de
desplazamiento de dos estados.
- El cdigo convolucional es generado introduciendo un bit de datos y dando una
revolucin completa al conmutador.


5
- Inicialmente se supone que los registros intermedios contienen ceros.
En este ejemplo la palabra codificada se obtiene como resultado de sumas mdulo-2
entre los bits indicados que estn almacenados en los registros intermedios.
Supongamos que se quiere enviar la secuencia de bits 0101 (donde los bits ms a la
derecha son los ms antiguos). El proceso de codficacin es el siguiente:
- Se introduce el primer bit de la secuencia en el codificador:

- Se introduce el segundo bit de la secuencia en el codificador:

- Se introduce el tercer bit de la secuencia en el codificador:

- Se introduce el cuarto bit de la secuencia en el codificador:


6

Al final del proceso de codificacin obtenemos que la secuencia codificada es
01 01 01 11.
Sigamos con la exposicin del proceso de codificacin.
Debido a la memoria del cdigo es necesario de disponer de medios adecuados para
determinar la salida asociada a una determinada entrada.

Hay tres mtodos grficos:
- Diagrama rbol o rbol del cdigo: representacin mediante un rbol
binario de las distintas posibilidades.
- Diagrama de estados: es la forma menos utilizada.
- Diagrama de Trellis o enrejado: es la forma ms utilizada porque es la que
permite realizar la decodificacin de la forma ms sencilla.
3.1.2. DIAGRAMA DE TRELLIS

El diagrama de Trellis es un diagrama en forma de red. Cada lnea horizontal se
corresponde con uno de los estados del codificador. Cada lnea vertical se
correspondera con uno de los niveles del rbol del cdigo.
Partimos del estado inicial del codificador en el primer nivel del rbol. A partir de
aqu se trazan dos lneas desde este estado. Una para el caso de que la siguiente
entrada fuera un 0 y otra para el caso de que fuera un 1. Estas lneas irn hasta el
siguiente nivel del rbol al estado en el que queda el codificador despus de haber
codificado las correspondientes entradas. Encima de cada una de estas lneas
escribiremos la salida del codificador para esa codificacin.


7
3.1.3. CODIFICADOR CONVOLUCIONAL,
c=conv_encode(G,x,k). G es la matriz generadora del codificador convolucional, puesta
como una matriz de conexiones en binario, x es la secuencia de entrada, c es la
secuencia codificada, y k es el nmero de posiciones que se desplaza el registro en
cada ciclo. Esta funcin proporciona secuencia de salida hasta que el registro queda
completamente vaco y vuelto al estado 0.
3.1.4. ALGORITMO DE VITERBI
La codificacin convolucional se decodifica con ayuda del algoritmo de Viterbi. En la
siguiente figura mostramos el algoritmo para la codificacin del ejemplo.


8

El algoritmo de Viterbi tambin se puede simular en octave, aunque slo disponemos
de la funcin para codificadores que realizan un desplazamiento por ciclo (k=1). El
comando correspondiente es,
- Algoritmo de Viterbi, y=viterbi(G,2*c-1). En esta funcin, G es la matriz
generadora del codificador convolucional, c es la secuencia de entrada, e y es la
secuencia decodificada. La entrada tiene que tener los valores +/-1, por lo que
hemos puesto 2*c-1.
3.2. CDIGO TURBO
Los turbo cdigos son una nueva clase de cdigos de correccin de errores que se
introdujeron, junto con un algoritmo de decodificacin. La importancia de los turbo
cdigos es que permiten una comunicacin fiable y su eficiencia energtica est muy
cerca del lmite terico predicho por Shannon. Desde su introduccin, los turbo
cdigos se han utilizado en aplicaciones de baja potencia, como las comunicaciones
por satlite, as como para aplicaciones de interferencia limitada, como los servicios
de tercera generacin (3G) de comunicaciones mviles.


9
Las caractersticas fundamentales de los turbo cdigos son

- Codificacin paralela concatenada
- Codificadores Convolucionales Recursivos
- Entrelazada Pseudo-Random
- Decodificacin iterativa
Los Turbo cdigos se basan en la concatenacin de dos codificadores relativamente
sencillos separados por un Dispersor.
El conjunto es equivalente a un nico codificador convolucional de memoria tan
grande como la profundidad del dispersor pero con un proceso de decodificacin
simplificado que en ningn caso alcanza la complejidad del convolucional equivalente.

Diagrama de un Sistema de Transmisin

Un nico cdigo de proteccin de errores no siempre proporciona la proteccin
necesaria con una complejidad aceptable. La solucin es concatenar dos o ms
cdigos, esto crea un cdigo mucho ms potente que los tradicionales.
La propuesta original de los turbo cdigos consista en la concatenacin de dos
codificadores convolucionales sistemticos (RSC) con un dispersor.
3.2.1. RSC

Un codificador RSC puede construirse a partir de un codificador convolucional donde
una salida se realimenta a la entrada. La respuesta impulsiva de un RSC es infinita

Una entrada arbitraria ocasionar con alta probabilidad una salida buena (con alto
peso de
hamming). Algunas entradas ocasionan salidas malas (bajo peso).


10

La forma de trabajar de estos cdigos se basa en permitir que el codificador final
entregue unas decisiones leves o soft en lugar de graves o hard, con el objetivo de
poder realimentar estas decisiones, de nuevo, hacia el cdigo inicial en un proceso
iterativo similar al que gobierna el principio de los motores turbo. Cuantas ms
iteraciones se aplican a este proceso ms refinada y fiable es la decisin hard
definitiva, y se reduce en cada iteracin la probabilidad de error.
Por qu Entrelazado y Codificacin Recursiva
- En un sistema de codificacin
- Las prestaciones estn limitadas por las palabras de peso pequeo
- Un cdigo bueno
- Genera las palabras de poco peso con probabilidad muy baja
- Los cdigos RSC
- Generan palabras de bajo peso con una probabilidad bastante baja
- En cualquier caso, algunas secuencias de entrada causan salidas con peso
pequeo
- Gracias al entrelazado
- La probabilidad de que ambos codificadores generen una palabra de peso
pequeo es muy baja
- Por lo tanto, la concatenacin en paralelo de los dos codificadores proporciona
un cdigo bastante bueno


11

3.2.2. CODIFICADOR

Diagrama de un Turbo Codificador

Un turbo cdigo es la concatenacin en paralelo de dos cdigos RSC separados por un
dispersor.
En el codificador del esquema los dos codificadores tienen la misma tasa del
codificador RSC. El codificador de la rama de arriba recibe los datos directamente,
mientras que el codificador de la rama inferior recibe la informacin despus de
dispersarse por una funcin de permutacin .
El dispersor es en general un dispersor pseudo-aleatorio, que mueve los bits de la
posicin i a la posicin (i) de acuerdo con una prescripcin (regla), que se generada
aleatoriamente. El dispersor opera en bloques, intercalado grupos de bits a la vez, y
por tanto los turbo cdigos son en realidad bloques de cdigos. Dado que ambos
codificadores son sistemticos y reciben el mismo conjunto de datos (aunque con un
orden permutado), slo hay que enviar la salida de una de las ramas. Por convenio, se
transmite la salida de la rama superior y la salida del codificador inferior no se
transmite. Sin embargo, las salidas de paridad de los dos codificadores se transmiten.
La tasa general de un turbo cdigo formado por la concatenacin en paralelo de dos
tasas de 1 / 2 de un codificador sistemtico es r = 1 / 3. La tasa tpica de un turbo
cdigo incrementa a r = 1 / 2 para transmitir slo los ndices impares de los bits de
paridad del codificador superior y para transmitir los ndices pares de los bits de
paridad del codificador inferior.


12
3.2.3. DECODIFICADOR
Un turbo cdigo, como ya hemos dicho anteriormente, se basa en la utilizacin de dos
o ms cdigos constituyentes, la descodificacin se basa en aplicar el criterio MAP
para poder tener tanto entradas como salidas soft (decodificador soft in - soft out).
Como se puede ver, la filosofa turbo se basa en aprovechar la informacin extrnseca
proporcionada por el cdigo y convertirla en informacin a priori para una etapa
posterior de decodificacin (esta parte se toma como 0 en la primera etapa). En un
esquema con dos cdigos este bucle de realimentacin debe tener en cuenta los dos
decodificadores y tambin la etapa de dispersin.

Diagrama de un Turbo Decodificador
Al igual que con los cdigos convolucionales, se puede obtener una solucin utilizando
la ecuacin:
y el algoritmo de Viterbi. Sin embargo, debido a la
presencia del dispersor, la complejidad del algoritmo Viterbi, cuando se utiliza para
descodificar los turbo cdigos es O(2
L
), donde L es el tamao del frame de datos. Esto
hace que para descodificar los turbo cdigos , se tenga que buscar una solucin de
menor complejidad, aunque sea una solucin subptima. En particular, se puede
encontrar una buena estimacin de los datos solucionando el siguiente sistema de
ecuaciones:

(1)
(2)


13

Donde y
(0)
son los bits sistemticos, y
(1)
son los bits de paridad observados por el
codificador 1 y y
(2)
son los bits de paridad observados por el codificador 2. El acento
sobre una variables representa su valor dispersado ,es decir, es la versin
dispersada de y. "A" es log-likelihood ratio (LLR) o la medida logartmica de similitud
(LLR), y z es la informacin extrnseca que se relaciona con LLR a travs de:

(3)
(4)

El sistema de ecuaciones se puede resolver iterativamente mediante la estructura que
se muestra en la figura. EL decodificador 1 determina la solucin de eq (1) y el
decodificador 2 determina la solucin de eq (2). Cada decodificador pasa la
informacin al otro decodificador, que a su vez mejora la estimacin de
probabilidades a posteriori utilizando la informacin obtenida por el otro
decodificador. La estimacin final de los datos se obtiene limitando la salida de uno de
los descodificadores (por convencin, la salida del segundo decodificador) mediante:
(5)

Los turbo cdigos deben su nombre a la estructura de retroalimentacin de la figura y
es una analoga de un motor turbo. De hecho, no hay nada "turbo", sobre los turbo
cdigos, ms bien slo existe el efecto turbo procedente de la implementacin del
decodificador.
3.2.4. APLICACIONES CON CODIGOS TURBO
Los turbocdigos se usan en los sistemas de telecomunicaciones, algunos ejemplos
son:
- En Comunicaciones satlite y espaciales
- En la televisin Digital, por ejemplo en: DVB-RCS , DVB-SH , DVB-S2
- En las Comunicaciones de fibra ptica
- En Comunicaciones inalmbricas (wireless)
- En Sistemas de grabacin pticos
- En los mdems ADSL
- En Telemetra


14

4. ANALISIS MATEMTICO
4.1. ANALISIS MATEMTICO MODULACIN 8PSK

= u 0
0
, 45
0
, 90
0
, 135
0
, 180
0
, 225
0
, 270
0
, 315
0
, 360
0


15
|
.
|
\
|
|
|
.
|
\
|

=
|
.
|
\
|
|
|
.
|
\
|

=
|
.
|
\
|
|
|
.
|
\
|

=
|
.
|
\
|
|
|
.
|
\
|

=
|
.
|
\
|
|
|
.
|
\
|

=
8
2
2
2
2
8
2
3
2
8
2
8 log
2
2
log
2
2
2
t
t
t
t
t
No
Es
Q Ps
M No
Es
Q Ps
No
Eb
Q Pb
No
Eb
Q Pb
M No
Eb
Q
M
Pb
( ) ( ) ( )
( ) ( )
( ) | |
| |
( ) ( ) ( )
( )
( ) ( ) ( )
( ) ( )
( ) | |
| |
2 2 3
2 2
2
2
1 2 ) 3 (
) 135 cos( 1 2 ) 3 (
) 135 cos( 2 2 ) 3 (
) 135 cos( 2 ) 3 (
2 2
2 ) 2 (
) 90 cos( 2 ) 2 (
2 2 1
2 2
2
2
1 2 ) 1 (
) 45 cos( 1 2 ) 1 (
) 45 cos( 2 2 ) 1 (
) 45 cos( 2 ) 1 (
2 2 2
2 2
2 2 2
2 2 2
2 2
2 2 2
2 2 2
2 2
2 2 2
2 2 2
+ =
+ =
(
+ =
=
=
+ =
=
=
+ =
=
=
(
=
=
=
+ =
a d
a a d
a d
a a d
a a a a d
a d
a d
a a a a d
a d
a a d
a d
a a d
a a a a d

|
.
|
\
|
+
|
|
.
|
\
|

+
|
|
.
|
\
|
+
|
|
.
|
\
|

=
=
o o o o 2
2
2
2 2
2
2
2
2
2
2 2
2
4
a
Q
a
Q
a
Q
a
Q Pe
a d


16
|
|
.
|
\
|
|
|
.
|
\
|

|
|
.
|
\
|
=
|
|
.
|
\
|
=
|
|
.
|
\
|
+ |
.
|
\
|
=
=
=
+ =
=
=
No
Es
Q
No
Es
Q Ps
No
Eb
Q Pb
a
Q
a
Q Pe
a d
a d
a a d
d d
a d
2
2
1
1
2
2
2
2
2
2 2 3
8 3
4 4 2
1 3
2 1
2
2 2
o o
4.2. ANALISIS MATEMTICO MODULACION QPSK

= u 45
0
, 135
0
, 225
0
, 315
0


17
4.3. ANALISIS MATEMTICO MODULACION BPSK

|
.
|
\
|
=
|
.
|
\
|
=
o
o
a
Q Pe
a
Q Pe
2
2


18

5. DESARROLLO EN MATLAB

5.1. MODULACIN BPSK ERROR DE SMBOLO
clc
clear all
tam=10000; % tamao de cada paquete
sigma=[0:0.1:3]; % Valor de sigma
%% se crea un ruido muy bajo disminuyendo el sigma
pee=[ ];
peet=[ ];
for sig=sigma
s=randsrc(1,tam,[1 2;0.5 0.5]);
% Mapeo
%%Transmision
[x y1]= find(s==1);
[x y2]= find(s==2);

%% asigno los valores de la constelacion a 1,2

s2=s; %guardo en otro vector s2

%En lo teorico,tomo el punto de referencia, pero ahora tomo todos los
puntos en la simulacion

s2(y1)=-1;
s2(y2)=1;

ruido=normrnd(0,sig,1,tam)+i*normrnd(0,sig,1,tam); %% agrego un ruido
teniendo su parte real e imaginaria

s3=s2+ruido;

rep=repmat(s3,2,1); %% copio la matriz para facilitar el calculo
%-----------------------------------------Recepcion----------------------
--
verif=[-1*ones(1,tam);1*ones(1,tam)]; %me crea vectores de unos
s4=abs(rep-verif); %% evaluo mediante la diferencia de s3 y cada punto
(1,i,-1,-i)
[distancia s5]=min(s4);
pe=sum(sign(abs(s-s5)))/tam

%-----------------Probabilidad de error teorica--------------------------
--
pet=Q(2/(2*sig))
pee=[pee pe];
peet=[peet pet];
end


19
semilogy(sigma,pee,'ro'); %%grafica de Probabilidad de error practica de
simbolo vs sigma
hold on
semilogy(sigma,peet);%%grafica de Probabilidad de error simbolo de
simbolo vs sigma
grid on %grilla
xlabel('\sigma');ylabel('P_e')

5.1.1. GRAFICA EN MATLAB (MODULACIN BPSK)

0 0.5 1 1.5 2 2.5 3
10
-25
10
-20
10
-15
10
-10
10
-5
10
0
o
P
e


20
5.1.2. TABLA DE DATOS (SIMULACIN)

5.2. MODULACION QPSK ERROR DE SIMBOLO
clc
clear all
a=1/sqrt(2);
tam=100; % tamao de cada paquete
sigma=[0:0.1:3]; % Valor de sigma

pee=[ ];
peet=[ ];
for sig=sigma
s=randsrc(1,tam,[1 2 3 4;0.25 0.25 0.25 0.25]);
b=dec_bin(s,4);

% Mapeo
%%Transmision

[x y1]= find(s==1);
[x y2]= find(s==2);
[x y3]= find(s==3);
[x y4]= find(s==4);

%asigno los valores de cada coordenada
s2=s;
s2(y1)=a+a*i; %(P1)
s2(y2)=-a+a*i; %(P2)
s2(y3)=-a-a*i; %(P3)
s2(y4)=a-a*i; %(P4)
o Pes(simulada) Pes(terica)
0 0 0
0,1 0 7.6199e-24
0,2 0 2.8665e-7
0,3 6e-4 4.2906e-4
0,4 0.0053 0.0062
0,5 0.0253 0.0228
0,6 0.0512 0.0478
0,7 0.0795 0.0766
0,8 0.1044 0.1056
0,9 0.1350 0.1333
1 0.1538 0.1587
1,1 0.1769 0.1817
1,2 0.2104 0.2023
1,3 0.2212 0.2209
1,4 0.2396 0.2375
1,5 0.2481 0.2525


21

ruido=normrnd(0,sig,1,tam)+i*normrnd(0,sig,1,tam); %% Creo un ruido
teniendo su parte real e imaginaria

s3=s2+ruido;
rep=repmat(s3,4,1); %% Obtengo mi valor en r3 y la repito
%%Recepcion
verif=[(a+a*i)*ones(1,tam);(-a+a*i)*ones(1,tam);(-a-a*i)*ones(1,tam);(a-
a*i)*ones(1,tam)]; %%me crea vectores de unos de 100 columnas
%por el tamao de la cabecera
s4=abs(rep-verif); %% resto la veri con la seal rep
sig
pe=sum(sign(abs(s-s5)))/tam

%--------------- Probabilidad de error teorica--------------------------

pet=2*Q(a/sig)+Q(sqrt(2)*a/(sig))
pee=[pee pe];
peet=[peet pet];
end
semilogy(sigma,pee,'ro'); %%Probabilidad de error de simbolo practica
hold on
semilogy(sigma,peet); %%Probabilidad de error de simbolo teorico
grid on
xlabel('\sigma');ylabel('P_e')

5.2.1. GRAFICA EN MATLAB (MODULACIN QPSK)

0 0.5 1 1.5 2 2.5 3
10
-12
10
-10
10
-8
10
-6
10
-4
10
-2
10
0
10
2
o
P
e


22
5.2.2. TABLA DE DATOS (SIMULACIN)

5.3. MODULACIN 8PSK ERROR DE SIMBOLO
clear all
clc
k=1;
tamano=10000;
sigma=[0:0.1:1];
angulo=0:pi/4:2*pi;
pee=[];
peet=[];
j=1;
matriz=ones(8,2);%matriz polar a cartesiano
ncomp=ones(8,1); %matriz donde resultado en ncomp
for theta=0:pi/4:2*pi,
[m n]=pol2cart(theta,k)
matriz(j,:)=[m n]
ncomp(j)=complex(matriz(j),matriz(j,2))
i=i+1;
end

for sig=sigma

s=randsrc(1,tamano,[1 2 3 4 5 6 7 8; 0.125 0.125 0.125 0.125 0.125 0.125
0.125 0.125]);
b=dec_bin(s,8)
%mapeo
[x y1]=find(s==1);
[x y2]=find(s==2);
o Pes(teorico) Pes(simulado)
0 0 0
0.1 1.5375e-012 0
0.2 4.0724e-004 0
0.3 0.0189 0,01
0.4 0.0833 0.0300
0.5 0.1800 0.1400
0.6 0.2864 0.2100
0.7 0.3890 0.2100
0.8 0.4824 0.3400
0.9 0.5653 0.4000
1 0.6382 0.4200
1.1 0.7020 0.4900
1.2 0.7580 0.4700
1.3 0.8074 0.4100
1.4 0.8510 0.5100
1.5 0.8898 0.5900


23
[x y3]=find(s==3);
[x y4]=find(s==4);
[x y5]=find(s==5);
[x y6]=find(s==6);
[x y7]=find(s==7);
[x y8]=find(s==8);

s2=s; %vector S

s2(y1)=ncomp(1);
s2(y2)=ncomp(2);
s2(y3)=ncomp(3);
s2(y4)=ncomp(4);
s2(y5)=ncomp(5);
s2(y6)=ncomp(6);
s2(y7)=ncomp(7);
s2(y8)=ncomp(8);

ruido=normrnd(0,sig,1,tamano)+j*normrnd(0,sig,1,tamano);
s3=s2+ruido;

rep=repmat(s3,8,1);
verif=[(ncomp(1))*ones(1,tamano);(ncomp(2))*ones(1,tamano);(ncomp(3))*one
s(1,tamano);(ncomp(4))*ones(1,tamano);(ncomp(5))*ones(1,tamano);(ncomp(6)
)*ones(1,tamano);(ncomp(7))*ones(1,tamano);(ncomp(8))*ones(1,tamano);];
s4=abs(rep-verif);

pe=sum(sign(abs(s-s5)))/(tamano);
pet=2*Q((k*sqrt(2-2*cos(angulo(2))))/(2*sig))+2*Q((k*sqrt(2-
2*cos(angulo(3))))/(2*sig))+2*Q((k*sqrt(2-
2*cos(angulo(4))))/(2*sig))+Q((k*sqrt(2-2*cos(angulo(5))))/(2*sig));
%probabilidad de error teorica

pee=[pee pe];
peet=[peet pet];
end
semilogy(sigma,pee,'ro');
hold on
semilogy(sigma,peet);
grid on
xlabel('\sigma')
ylabel('P_e')


24

5.3.1. GRAFICA EN MATLAB (MODULACIN 8PSK)

5.3.2. TABLA DE DATOS SIMULACIN
o Pes(simulada) Pes(teorica)
0 0,7461 0
0,1 0,8699 1.2980e-4
0,2 0,8772 0.05610
0,3 0,8740 0.2230
0,4 0,8727 0.4429
0,5 0,8757 0.6887
0,6 0,8787 0.9336
0,7 0,8778 1.1605
0,8 0,8773 1.3630
0,9 0,9000 1.5406
1 0,8748 1.6957

0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
10
-4
10
-3
10
-2
10
-1
10
0
10
1
o
P
e


25
5.4. MODULACION BPSK ERROR DE BIT
clear all
clc
a=1;
tam=100;

eb_no_db=[0:1:35]; %la relacion seal ruido en db
eb_no=10.^(eb_no_db/10);%%la relacion seal ruido en db
es_no=2*eb_no;
sigma=1./sqrt(es_no);
paquetes=1000;

psst=[];
pbbt=[];

for sig=sigma
pss=[];
pbb=[];
for paq=1:paquetes

s=randsrc(1,tam,[0 1 ; 0.5 0.5 ]);
bits=dec_bin(s,1);
%mapeo
[x y1]=find(s==0);
[x y2]=find(s==1);

s2=s; %para mantener el vector S

s2(y1)=(-1);
s2(y2)=(1);

ruido=normrnd(0,sig,1,tam)+i*normrnd(0,sig,1,tam); %agrego ruido con
parte imaginaria y real
s3=s2+ruido;

verif=[-1*ones(1,tam);1*ones(1,tam)];
rep=repmat(s3,2,1); %repite la matriz para facilitar calculo
s4=abs(rep-verif); %me indica la distancia entre cada punto
[distancia s5]=min(s4); %s5 me entrega la posicion en la que se encuentra
el valor minimo
s5=s5-1;

bits_d=dec_bin(s5,1);
ps=sum(sign(abs(s-s5)))/tam; %Probabiblidad de error practica
pb=sum(sum(xor(bits,bits_d)))/(tam);

pss=[pss ps];
pbb=[pbb pb];
end

psm=mean(pss);
pbm=mean(pbb);
psm


26
pbm
psst=[psst psm];
pbbt=[pbbt pbm];
end

semilogy(eb_no_db,psst);
hold on
pst=Q(2/(2*sig))
hold on
semilogy(eb_no_db,pbbt,'ro');%proabilidad de bit teorica
grid on
xlabel('Eb_No')
ylabel('P_e')

5.4.1. GRAFICA EN MATLAB (MODULACIN BPSK)

0 1 2 3 4 5 6 7 8 9
10
-5
10
-4
10
-3
10
-2
10
-1
Eb
N
o
P
e


27
5.5. MODULACIN QPSK ERROR DE BIT
clear all
clc
a=1/sqrt(2);
tam=100; %tamao de cada paquete
sigma=0.5; %valor de sigma para ruido

eb_no_db=[0:1:35];
eb_no=10.^(eb_no_db/10);
es_no=2*eb_no;
sigma=1./sqrt(2*es_no);
paquetes=100;

psst=[];
pbbt=[];

for sig=sigma
pss=[];
pbb=[];
for paq=1:paquetes

s=randsrc(1,tam,[0 1 2 3 ; 0.25 0.25 0.25 0.25]);
bits=dec_bin(s,2);
%mapeo
[x y1]=find(s==0);
[x y2]=find(s==1);
[x y3]=find(s==2);
[x y4]=find(s==3);


s2(y1)=a+a*i;
s2(y2)=-a+a*i;
s2(y3)=-a-a*i;
s2(y4)=a-a*i;

ruido=normrnd(0,sig,1,tam)+i*normrnd(0,sig,1,tam); %creo ruido con parte
Re e I
s3=s2+ruido;

verif=[(a+a*i)*ones(1,tam);(-a+a*i)*ones(1,tam);(-a-a*i)*ones(1,tam);(a-
a*i)*ones(1,tam)] ;%%me crea vectores de unos
rep=repmat(s3,4,1); %repite la matriz para facilitar calculo
el valor minimo
s5=s5-1;
ps=sum(sign(abs(s-s5)))/tam; %Probabiblidad de error practica
pb=sum(sum(xor(bits,bits_d)))/(2*tam);

pss=[pss ps];


28
pbb=[pbb pb];
end
psm=mean(pss);
pbm=mean(pbb);
psst=[psst psm];
pbbt=[pbbt pbm];

end

semilogy(eb_no_db,psst);%bprbilodad del simbolo
hold on
semilogy(eb_no_db,pbbt,'ro');%proabilidad de bit teorica
grid on
xlabel('Eb_No')
ylabel('P_e')

5.5.1. GRAFICA EN MATLAB (MODULACIN QPSK)

0 1 2 3 4 5 6 7 8 9
10
-4
10
-3
10
-2
10
-1
10
0
Eb
N
o
P
e


29
5.6. MODULACIN 8PSK ERROR DE BIT
clear all
clc
a=1;
tam=100;
%sigma=0.5; %valor de sigma para ruido

eb_no_db=[0:1:35];
es_no=2*eb_no;
paquetes=1000;
angulo=0:pi/4:2*pi;

psst=[];
pbbt=[];

i=1;
aux=ones(8,2);%genero matriz auxiliar para convertir polar a cartesiano
complejos=ones(8,1); %genero matriz donde voy a guardar el resultado en
complejos
for theta=0:pi/4:2*pi,
[m n]=pol2cart(theta,a);
aux(i,:)=[m n];
complejos(i)=complex(aux(i),aux(i,2));
i=i+1;
end

for sig=sigma
pss=[];
pbb=[];
for paq=1:paquetes

s=randsrc(1,tam,[0 1 2 3 4 5 6 7 ; 0.125 0.125 0.125 0.125 0.125 0.125
0.125 0.125]);
bits=dec_bin(s,3);
%mapeo
[x y1]=find(s==0);
[x y2]=find(s==1);
[x y3]=find(s==2);
[x y4]=find(s==3);
[x y5]=find(s==4);
[x y6]=find(s==5);
[x y7]=find(s==6);
[x y8]=find(s==7);


s2(y1)=complejos(1);


30

ruido=normrnd(0,sig,1,tam)+i*normrnd(0,sig,1,tam); %creo ruido con parte
Re e I
s3=s2+ruido;

verif=[(complejos(1))*ones(1,tam);(complejos(2))*ones(1,tam);(complejos(3
))*ones(1,tam);(complejos(4))*ones(1,tam);(complejos(5))*ones(1,tam);(com
plejos(6))*ones(1,tam);(complejos(7))*ones(1,tam);(complejos(8))*ones(1,t
am);];
rep=repmat(s3,8,1); %copio la matriz para facilitar calculo
el valor minimo
s5=s5-1;

ps=sum(sign(abs(s-s5)))/tam; %Probabiblidad de error simbolo
practica
pb=sum(sum(xor(bits,bits_d)))/(tam);%Probabiblidad de error bit practica

pss=[pss ps];
pbb=[pbb pb];
end

psm=mean(pss);
pbm=mean(pbb);
psst=[psst psm];
pbbt=[pbbt pbm];
end

semilogy(eb_no_db,psst);%
hold on
semilogy(eb_no_db,pbbt,'ro');%Probabilidad de bit teorica
grid on
xlabel('Eb_No')
ylabel('P_e')


31

5.6.1. GRAFICA EN MATLAB (MODULACION 8PSK)

5.7. DECISIN SOFT Y HARD DE MODULACIN BPSK
clear all;
close all;
clc;
a=1;
tam=1000; %Tamao de cada paquete

eb_no_db=[0:1:10];
es_no=0.5*eb_no;
paquetes=100;

g=[1 1 1;1 0 1]; %Matriz Generadora
0 5 10 15 20 25 30 35
10
-5
10
-4
10
-3
10
-2
10
-1
10
0
10
1
Eb
N
o
P
e


32
k=1;

pbbt=[];
pbbt_hard=[];
pbbt_soft=[];

for sig=sigma

pbb=[];
pbb_hard=[];
pbb_soft=[];

for paq=1:paquetes

s=randsrc(1,tam,[0 1;0.5 0.5]); %Generero la senal de entrada
bits=dec_bin(s,1); %Transformo a bits
bits_cod=cnv_encd(g,k,bits'); %Codifico los bits
tamV=length(bits_cod); %Tamano de los bits codificados

%Mapeo
[x y1]=find(bits_cod==0);
[x y2]=find(bits_cod==1);

s2=bits_cod;

%Modulo
s2(y1)=-1;
s2(y2)=1;

ruido=normrnd(0,sig,1,tamV)+i*normrnd(0,sig,1,tamV); %Creo ruido con
parte Re e I
s3=s2+ruido; %Sumo ruido
verif=[(-1)*ones(1,tamV);(1)*ones(1,tamV);]; %Modulacion bpsk
rep=repmat(s3,2,1); %Repite la matriz para facilitar calculo
s4=abs(rep-verif); %Me indica la distancia entre cada punto
el valor minimo
s5=s5-1; %Bits recuperados

bits_decViterbi=viterbi(g,k,s5);
bits_decViterbiSoft=viterbi_s(g,k,s3);
pb=sum(sign(abs(bits_cod-s5)))/tamV; %Probabiblidad bit y simbolo
practica
pb_hard=sum(sum(xor(bits,bits_decViterbi')))/(tam); %Probabilidad hard
practica
pb_soft=sum(sum(xor(bits,bits_decViterbiSoft')))/(tam); %Probabilidad
soft practica
ptb=Q(sqrt(2*(es_no))); %Probabilidad bit y simbolo teorica
pbb=[pbb pb];
pbb_hard=[pbb_hard pb_hard];
pbb_soft=[pbb_soft pb_soft];

end


33
pbbm=mean(pbb);
pbbm_hard=mean(pbb_hard);
pbbm_soft=mean(pbb_soft);

pbbt=[pbbt pbbm];
pbbt_hard=[pbbt_hard pbbm_hard];
pbbt_soft=[pbbt_soft pbbm_soft];
end

semilogy(eb_no_db,pbbt,'r'); %Probabilidad bit y simbolo practica
hold on
semilogy(eb_no_db,pbbt_hard,'g'); %Probabilidad hard practica
hold on
semilogy(eb_no_db,pbbt_soft,'b'); %Probabilidad soft practica
hold on
semilogy(eb_no_db,ptb,'bo'); %Probabilidad bit y simbolo teorica
xlabel('Eb_No')
ylabel('P_e')
grid on
legend('pbbt','pbbt_hard','pbbt_soft','ptb')

5.7.1. GRAFICA EN MATLAB (DETECTOR SOFT Y HARD BPSK)


34

5.8. DESICIN HARD DE MODULACIN QPSK
clear all;
close all;
clc;
a=1;
tam=1000; %Tamao de cada paquete

eb_no_db=[0:1:10];
es_no=0.5*eb_no;
paquetes=100;

g=[1 1 1;1 0 1]; %Matriz Generadora
k=1;

pbbt=[];
pbbt_hard=[];

for sig=sigma

pbb=[];
pbb_hard=[];

for paq=1:paquetes

s=randsrc(1,tam,[1 2 3 4;0.25 0.25 0.25 0.25]);
bits=dec_bin(s,1); %Transformo a bits
bits_cod=cnv_encd(g,k,bits'); %Codifico los bits
tamV=length(bits_cod); %Tamano de los bits codificados

%Mapeo
[x y1]= find(s==1);
[x y2]= find(s==2);
[x y3]= find(s==3);
[x y4]= find(s==4);

s2=bits_cod;

%Modulo
s2(y1)=a+a*i;
s2(y2)=-a+a*i;
s2(y3)=-a-a*i;
s2(y4)=a-a*i;

ruido=normrnd(0,sig,1,tamV)+i*normrnd(0,sig,1,tamV); %Creo ruido con
parte Re e I
s3=s2+ruido; %Sumo ruido
verif=[(-1)*ones(1,tamV);(1)*ones(1,tamV);]; %Modulacion bpsk
rep=repmat(s3,2,1); %Repite la matriz para facilitar calculo


35
s4=abs(rep-verif); %Me indica la distancia entre cada punto
el valor minimo
s5=s5-1; %Bits recuperados

bits_decViterbi=viterbi(g,k,s5);
bits_decViterbiSoft=viterbi_s(g,k,s3);
pb=sum(sign(abs(bits_cod-s5)))/tamV; %Probabiblidad bit y simbolo
practica
pb_hard=sum(sum(xor(bits,bits_decViterbi')))/(tam); %Probabilidad hard
practica
pb_soft=sum(sum(xor(bits,bits_decViterbiSoft')))/(tam); %Probabilidad
soft practica
ptb=Q(sqrt(2*(es_no))); %Probabilidad bit y simbolo teorica
pbb=[pbb pb];
pbb_hard=[pbb_hard pb_hard];

end

pbbm=mean(pbb);
pbbm_hard=mean(pbb_hard);

pbbt=[pbbt pbbm];
pbbt_hard=[pbbt_hard pbbm_hard];
end

semilogy(eb_no_db,pbbt,'r'); %Probabilidad bit y simbolo practica
hold on
semilogy(eb_no_db,pbbt_hard,'g'); %Probabilidad hard practica
hold on
semilogy(eb_no_db,ptb,'bo'); %Probabilidad bit y simbolo teorica
xlabel('Eb_No')
ylabel('P_e')
grid on
legend('pbbt','pbbt_hard','pbbt_soft','ptb')


36
5.8.1. GRAFICA EN MATLAB (DETECTOR HARD QPSK)


37
5.9. PROCESAMIENTO DE IMAGEN CON CODIGO TURBO
clear all
clc
img=imread('carita.bmp')%Leer imagen como matriz
[o p]=size(img);
q=img' % se saca la transpuesta para la recepcion del codigo
w=reshape(q,1,o,p); %reconstruccion de la imagen
[d z]=size(w);

% Choose decoding algorithm

dec_alg = input(' Ingrese el codigo de decodificacion');
if isempty(dec_alg)
dec_alg = 0;
end

% Frame size
L_total = input('ingrese la dimension'); % Por default esta 400
if isempty(L_total)
L_total = z; % infomacion bit a bit
img=imread('carita.bmp');%Leer imagen como matriz
end

% Voy a trabajar con la siguiente generadora
g = [ 1 1 1;
1 0 1 ];

[n,K] = size(g);
m = K - 1;
nstates = 2^m;

puncture = input(' Escoja su puctured / unpunctured (0/1): default 0
');
if isempty(puncture)
puncture = 0;
end

% Code rate
rate = 1/(2+puncture);

% Fading amplitude; a=1 in AWGN channel
a = 1;

niter = 5; % Numero de interacciones

% Number of frame errors to count as a stop criterior
ferrlim = input(' Please enter number of frame errors to terminate:
default 15 ');
if isempty(ferrlim)
ferrlim = 2;
end


38
EbN0db = input(' Please enter Eb/N0 in dB : default [2.0] ');
if isempty(EbN0db)
EbN0db = [2.0];
end

fprintf('\n\n----------------------------------------------------\n');
if dec_alg == 0
fprintf(' === Log-MAP decoder === \n');
else
fprintf(' === SOVA decoder === \n');
end
fprintf(' Frame size = %6d\n',L_total);
fprintf(' code generator: \n');
for i = 1:n
for j = 1:K
fprintf( '%6d', g(i,j));
end
fprintf('\n');
end
if puncture==0
fprintf(' Punctured, code rate = 1/2 \n');
else
fprintf(' Unpunctured, code rate = 1/3 \n');
end
fprintf(' iteration number = %6d\n', niter);
fprintf(' terminate frame errors = %6d\n', ferrlim);
fprintf(' Eb / N0 (dB) = ');
for i = 1:length(EbN0db)
fprintf('%10.2f',EbN0db(i));
end
fprintf('\n----------------------------------------------------\n\n');

fprintf('+ + + + Please be patient. Wait a while to get the result. + + +
+\n');

for nEN = 1:length(EbN0db)
en = 10^(EbN0db(nEN)/10); % convert Eb/N0 from unit db to normal
numbers
L_c = 4*a*en*rate; % reliability value of the channel
sigma = 1/sqrt(2*rate*en); % standard deviation of AWGN noise

% Clear bit error counter and frame error counter
errs(nEN,1:niter) = zeros(1,niter);
nferr(nEN,1:niter) = zeros(1,niter);

nframe = 0; % clear counter of transmitted frames
while nferr(nEN, niter)<ferrlim
nframe = nframe + 1;
yy=w;
x = yy; % info. bits
[temp, alpha] = sort(rand(1,L_total)); % random interleaver
mapping
en_output = encoderm( x, g, alpha, puncture ) ; % encoder output
(+1/-1)

r = en_output+sigma*randn(1,L_total*(2+puncture)); % received bits


39
yk = demultiplex(r,alpha,puncture); % demultiplex to get input for
decoder 1 and 2

% Scale the received bits
rec_s = 0.5*L_c*yk;

% Initialize extrinsic information
L_e(1:L_total) = zeros(1,L_total);

for iter = 1:niter
% Decoder one
L_a(alpha) = L_e; % a priori info.
if dec_alg == 0
L_all = logmapo(rec_s(1,:), g, L_a, 1); % complete info.
else
L_all = sova0(rec_s(1,:), g, L_a, 1); % complete info.
end
L_e = L_all - 2*rec_s(1,1:2:2*L_total) - L_a; % extrinsic info.

% Decoder two
L_a = L_e(alpha); % a priori info.
if dec_alg == 0
L_all = logmapo(rec_s(2,:), g, L_a, 2); % complete info.
else
L_all = sova0(rec_s(2,:), g, L_a, 2); % complete info.
end
L_e = L_all - 2*rec_s(2,1:2:2*L_total) - L_a; % extrinsic info.

% Estimate the info. bits
xhat(alpha) = (sign(L_all)+1)/2;

% Number of bit errors in current iteration
err(iter) = length(find(xhat(1:L_total-m)~=x));
% Count frame errors for the current iteration
if err(iter)>0
nferr(nEN,iter) = nferr(nEN,iter)+1;
end
end %iter

% Total number of bit errors for all iterations
errs(nEN,1:niter) = errs(nEN,1:niter) + err(1:niter);

if rem(nframe,3)==0 | nferr(nEN, niter)==ferrlim
% Bit error rate
ber(nEN,1:niter) = errs(nEN,1:niter)/nframe/(L_total-m);
% Frame error rate
fer(nEN,1:niter) = nferr(nEN,1:niter)/nframe;

% Display intermediate results in process
fprintf('************** Eb/N0 = %5.2f db **************\n',
EbN0db(nEN));
fprintf('Frame size = %d, rate 1/%d. \n', L_total, 2+puncture);
fprintf('%d frames transmitted, %d frames in error.\n', nframe,
nferr(nEN, niter));


40
fprintf('Bit Error Rate (from iteration 1 to iteration %d):\n',
niter);
for i=1:niter
fprintf('%8.4e ', ber(nEN,i));
end
fprintf('\n');
fprintf('Frame Error Rate (from iteration 1 to iteration
%d):\n', niter);
for i=1:niter
fprintf('%8.4e ', fer(nEN,i));
end
fprintf('\n');
fprintf('***********************************************\n\n');

% Save intermediate results
save turbo_sys_demo EbN0db ber fer
end

end %while
end %nEN
cc=xhat;
dd=reshape(cc,100,100);

imshow(dd)

5.10. IMAGEN A SER PROCESADA


41

6. CONCLUCIONES

- Se crea un ruido muy bajo en la simulacin de Matlab disminuyendo el sigma

- La importancia de los turbo cdigos es que permiten una comunicacin fiable y
su eficiencia energtica est muy cerca del lmite terico predicho
por Shannon.

- Para relaciones seal-ruido altas, puede ser mejor utilizar un cdigo
convolucional

- Los cdigos convolucionales son adecuados para usar sobre canales con mucho
ruido

7. BIBLIOGRAFA

- http://trabajospracticos.4mg.com/cod/secc2.htm
- http://web.usc.es/~elusive/simula3.html
- Wang, D.; Kobayashi, H. On design of interleavers with practical size for turbo
codes. IEEE International Conference on Communications, 2000. ICC 2000.
Volume 2, 18-22 June 2000 Page(s):618 - 622 vol.2

Informe Codificacion 2parcial Torres Orbe

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Informe Codificacion 2parcial Torres Orbe

Transféré par

Droits d'auteur :

Formats disponibles

[COMUNICACIN Y CODIFICACIN DIGITAL]

Vous aimerez peut-être aussi