Práctica 2.
1 de Técnicas de Transmisión
Grado en Ingeniería en Sistemas de Telecomunicación
Profesores:
Jorge Larrey, Antonio Lozano
Realizado por: Irene Rivera Varo y Javier López Marchante
Prólogo
El objetivo de esta práctica es que el alumno se familiarice con algunas de las técnicas existentes de
codificación de canal. En esta práctica trabajaremos con los códigos bloque lineales.
Las prácticas de la asignatura Técnicas de Transmisión se llevan a cabo en el entorno MATLAB, y en
concreto se emplea de forma exhaustiva la librería Communications Toolbox. Para obtener ayuda sobre
cualquier comando en MATLAB, introduzca help nombre del comando.
Funciones útiles para la realización de la práctica
encode, decode, gen2par, syndtable, cyclpoly, cyclgen, hammgen,
bchgenpoly, bchenc, bchdec, rsenc, rsdec, gf, double, bi2de, randint,
randerr, biterr, zeros, length, find, isequal, rem, log2
1. Introducción
En la codificación de canal existen dos clases fundamentales de códigos: los códigos bloque y los códigos
convolucionales. El primer tipo va a ser el tema de desarrollo de esta práctica y el segundo lo será durante
la práctica 2.2.
El objetivo de la codificación de canal ya no es la compresión del mensaje, sino la detección y corrección
de errores, la cual nos permite cierta confianza en la transmisión por un canal poco fiable debido al ruido.
La redundancia añadida al mensaje, haciendo cada palabra más larga, nos permitirá detectar y corregir
errores que se hayan producido por el ruido de canal.
Los códigos bloque convierten un número fijo de símbolos del mensaje en un número fijo de símbolos
código. El codificador va a tratar cada bloque de código de manera independiente. Normalmente, se
indicará con la letra n el tamaño de la palabra-código y con la letra k el tamaño de cada bloque del mensaje.
Utilizaremos la notación C(n,k), indicando así los tamaños de bloque y palabra-código.
Con el Communication Toolboox de MATLAB podremos trabajar con los siguientes códigos:
En esta práctica los estudiaremos todos ellos excepto los LDPC.
2. Codificación Bloque Lineal
El codificador transforma un bloque de k símbolos del mensaje en una palabra-código de n símbolos.
Si hablamos de codificación lineal binaria, con k como tamaño de bloque, tendremos 2k secuencias
posibles, asignando a cada una de ellas una única palabra-código de las 2n posibles.
Este tipo de codificación es denominada lineal porque la suma de dos palabras-código da lugar a otra
palabra-código.
En cualquier codificación bloque lineal genérica C(n,k), para poder codificar un mensaje es necesaria una
matriz generadora (G) de tamaño k x n. En concreto, a un mensaje d de tamaño 1 x k, le corresponderá la
palabra-código c de tamaño 1 x n dada por:
c=d*G
La forma estándar de esta matriz es [Ik P] o [P Ik ], siendo Ik la matriz identidad de k x k elementos y P
la matriz de paridad, de tamaño k x (n-k).
Para decodificar será necesaria una matriz de comprobación de paridad de tamaño n x (n-k) llamada
HT, tal que G*HT=0
Como hemos visto en el esquema de la introducción, dentro de los códigos bloque lineales genéricos se
encuentran los cíclicos, de los que se derivan los BCH, en los que se encuentran incluidos los códigos
Reed-Solomon y los códigos Hamming.
En este primer apartado, vamos a estudiar en conjunto los códigos bloque lineales genéricos, los códigos
cíclicos y los códigos Hamming.
Ya hemos descrito brevemente los códigos bloque lineales, así que vamos a presentar a continuación una
pequeña introducción sobre los códigos cíclicos y Hamming.
Códigos cíclicos
Un código cíclico es un código bloque lineal con la propiedad de que un desplazamiento cíclico de una
palabra-código es, a su vez, otra palabra-código. Es decir, dada una palabra-código U=(u0,u1,…,un-1), la
palabra Ui=(un-i,un-i+1,…,u0,...,un-i-1) es otra palabra-código.
Para este tipo de códigos, en vez de usarse una matriz generadora, es necesario un polinomio generador
para realizar la codificación y posteriormente la decodificación.
Código Hamming
Los códigos de Hamming son códigos de detección y corrección de errores que sólo pueden corregir
correctamente un error por palabra-código. Para corregir correctamente 2 errores por palabra-código, se
necesita usar un código Hamming extendido (no lo estudiaremos). Por cada entero m ≥ 3, existe al menos
un código Hamming con m bits de paridad y 2m- m - 1 bits de datos.
Teorema de codificación de canal
Vamos a realizar una breve descripción del teorema de codificación de canal.
La capacidad de un canal binario simétrico (BSC) es 𝐶 = 1 − 𝐻(𝑝) , siendo 𝑝 la probabilidad de error de
bit en el canal. Por otro lado, definimos el ratio de codificación 𝑅 =k/n
El teorema de codificación de canal de Shannon establece lo siguiente:
siendo 𝑃𝑒 la probabilidad de error residual extremo a extremo tras la codificación de canal.
Para calcular H(p), aplicaremos la siguiente fórmula (y la fórmula análoga para calcular 𝐻(𝑃𝑒)):
Funciones
En este apartado vamos a presentar y describir las funciones necesarias para realizar la codificación y
posterior decodificación de canal, tanto para códigos bloque lineales genéricos como para códigos cíclicos
y códigos Hamming. La codificación la realizamos mediante el comando
code=encode(msg,n,k,method,opt);
Con esta función codificamos el mensaje msg según la técnica especificada en method con un código
C(n,k), mediante la matriz/polinomio generador indicada en opt.
msg es una matriz que contiene el mensaje a codificar. Hay que tener en cuenta que en esta matriz cada fila
es una palabra de k bits.
El resultado de la codificación es una matriz code, que contiene las palabras-código generadas y tiene el
mismo número de filas que msg, y n columnas.
El parámetro method indica qué técnica vamos a utilizar, por tanto puede tener los siguientes valores:
🡪’linear’ para codificación bloque lineal genérica.
🡪’hamming’ para codificación Hamming.
🡪’cyclic’ para codificación cíclica.
Para analizar el resto de parámetros vamos a hacerlo en función de la técnica utilizada en la codificación:
🡪Lineal.
El tamaño de palabra-código es n bits, siendo el tamaño de palabra del mensaje k bits. El parámetro
opt en este caso es la matriz generadora genmat de tamaño n x k
Al usar method=’linear’ se usa una codificación binaria, pero también se pueden codificar en este
caso mensajes en base 10 usando method=’linear/decimal’. En este caso, MATLAB convierte
cada entero del mensaje en m bits, tal que m sea el entero menor que cumple 𝑛 ≤ 2𝑚 − 1.
🡪Hamming.
El tamaño de palabra-código es de n bits, siendo el tamaño del mensaje k bits. En este caso no hay que usar
una matriz generadora, por tanto se omite el parámetro opt. Cabe destacar que n y k no pueden ser valores
cualesquiera, sino que se debe cumplir que 𝑛 = 2𝑚 − 1 y, a su vez, que 𝑘 = 𝑛 − 𝑚.
También podemos codificar mensajes con dígitos en base 10 usando method=’linear/decimal’.
MATLAB convierte cada dígito decimal del mensaje en m bits, siendo m el entero menor que cumple 𝑛 ≤
2𝑚 − 1.
🡪Cíclico.
De nuevo el tamaño de palabra-código es de n bits, siendo el tamaño de cada palabra del mensaje k bits.
Para esta codificación es necesario un polinomio generador que llamaremos genpoly; para ello usaremos
la función cyclpoly, que explicaremos más adelante.
Como en las dos situaciones anteriores, también puede codificar un mensaje en base 10 mediante el
parámetro method=’cyclic/decimal’.
Para decodificar emplearemos el comando
[msg,err]=decode(code,n,k,method,...)
Esta función decodifica el código introducido mediante el parámetro code, según la técnica utilizada, la
cual se indica en method. err contiene el número de errores detectados por palabra.
code es una matriz de palabras-código de n columnas, siendo n el tamaño de palabra-código y k el tamaño
de palabras del mensaje.
Al igual que en la función encode, otros parámetros dependen de la técnica utilizada para (de)codificar:
🡪Lineal.
Adicionalmente a method, se necesitan dos parámetros más: genmat y trt. genmat es la matriz
generadora que hemos usado para codificar, y trt es la tabla de síndromes o tabla estándar, es decir, la
tabla de decodificación, la cual generaremos mediante la función syndtable.
🡪Hamming.
No necesita ningún parámetro tras method.
🡪Cíclico.
Tras method se encuentra el parámetro genpoly, que es el polinomio generador que se usó para
codificar, y a continuación va el parámetro trt, que es la tabla estándar que se puede generar mediante
syndtable.
cyclpoly:
genpoly=cyclpoly(n,k);
Con esta función obtenemos el polinomio generador de código cíclico, para un tamaño de palabra- código n
y un tamaño de palabra k dados. genpoly es un vector en el que se almacenan los coeficientes del
polinomio.
cyclgen:
[parmat,genmat]=cyclgen(n,genpoly)
Genera la matriz de comprobación de paridad (ojo: traspuesta) parmat y la matriz generadora
genmat, correspondientes al código cíclico de longitud n y polinomio generador genpoly.
syndtable:
trt=syndtable(parmat)
Genera la tabla estándar para decodificar, a partir de la matriz de comprobación de paridad parmat.
hammgen:
parmat=hammgen(m)
Genera la matriz de comprobación de paridad parmat de un código Hamming de parámetro m.
gen2par:
parmat=gen2par(genmat)
Con esta función obtenemos la matriz de comprobación de paridad a partir de la matriz generadora, y
viceversa.
randerr:
code_error=randerr(i,n,errors)
Esta función genera una matriz de tamaño i x n con el número de bits a 1 en cada fila indicado en
errors.
El parámetro errors puede ser un escalar, un vector, o una matriz de dos filas:
🡪Escalar: Indica el número de 1's que generará la función en cada fila.
🡪Vector: Sus elementos indican las cantidades posibles de 1's
🡪Matriz de dos filas: La primera fila indica las cantidades posibles de 1's y la segunda las probabilidades de
dichas cantidades
Ejercicios
Ejercicio 1: Realizar la codificación bloque lineal genérica sin corrección para un código C(7,4) cuya
matriz generadora es
Decodificar mediante la función decode e indexando la tabla estándar.
Sugerencias para la decodificación por indexación:
1) Multiplicar (en binario, empleando la función rem) la palabra-código recibida con la transpuesta
de la matriz de comprobación de paridad. Esto da lugar al síndrome.
2) Se pasa el síndrome a decimal para indexar.
3) Se obtiene el vector de corrección correspondiente de la tabla.
4) El código corregido se obtiene mediante la suma (binaria, con rem) de la palabra recibida y el
vector de corrección.
Importante: Aunque en teoría se haya visto que el vector obtenido sería [d|r] , siendo la d la palabra del
mensaje y r la redundancia, en MATLAB se obtendrá al revés: [r|d].
Primero hemos de generar el mensaje. Como k=4, generaremos una matriz aleatoria de 100x4, para que
contenga 100 palabras de 4 bits.
msg=randint(100,4,2);
La función randint(x,y,z) genera una matriz de números enteros entre 0 y z-1 de x filas e y
columnas.
Para realizar la codificación, necesitamos la matriz generadora genmat, así que vamos a rellenarla tal y
como indica el enunciado.
genmat=[1 0 1 1 0 0 0; 1 1 1 0 1 0 0; 1 1 0 0 0 1 0; 0 1 1 0 0 0 1];
Tras ello, realizamos la codificación mediante la función encode:
code=encode(msg,7,4,'linear',genmat);
A continuación, generamos el ruido del canal y lo sumamos al código transmitido para dar lugar al código
ruidoso en recepción:
noise=randerr(100,7,[0 1;0.7 0.3]);
Con la función randerr generamos el ruido de canal, en este caso hemos considerado una probabilidad de
error de 1 bit en el canal del 30%.
noisycode=rem(code+noise,2);
Sumamos, en binario, el código y el ruido de canal, de manera que ya tenemos el código ruidoso.
El siguiente paso a realizar, es rellenar la tabla estándar, que en esta ocasión estará rellena de ceros ya que el
enunciado nos indica que no hay corrección:
trt=zeros(2^(7-4),7);
Por último, decodificamos el código ruidoso recibido.
Primero, por su sencillez, lo haremos con decode:
[newmsg,err]=decode(noisycode,7,4,'linear',genmat,trt);
También calculamos el número de palabras erróneas del mensaje:
w_err=find(err~=0);
n_err=length(w_err)
Verificamos el error empleando la función biterr:
[number,ratio]=biterr(msg,newmsg)
C 2.1 Indique la razón por la cual los valores obtenidos en cuanto al error difieren.
C 2.2 ¿Qué porcentaje de errores se ha producido?
ratio=0.0350
A continuación, vamos a realizar la decodificación por indexado, paso a paso: Lo
primero que necesitamos es generar la matriz de comprobación de paridad:
parmat=gen2par(genmat);
Los siguientes pasos los vamos a hacer dentro de un bucle for, para realizarlos con todas las palabras del
mensaje:
for i=1:100
1) Generar el síndrome multiplicando la palabra recibida con la matriz de comprobación de paridad HT
(es decir, con la traspuesta de parmat):
recibida=noisycode(i,:);
sindrome=rem(recibida*parmat',2);
2) Pasamos el síndrome a decimal, para poder indexar en la tabla estándar:
sindrome_de=bi2de(sindrome,'left-msb');
3) Obtenemos el vector de corrección indexando la tabla:
vector_corr=trt(sindrome_de+1,:);
4) El código corregido se obtiene mediante la suma de la palabra recibida y el vector de
corrección: corregido=rem(recibida+vector_corr,2);
newmsg_2(i,:)=corregido(4:7);
end
Ejercicio 2: Realizar una codificación bloque lineal C(7,4) genérica con corrección, aplicando como
matriz generadora la del ejercicio anterior. Hacerlo para una probabilidad de error de 1 bit y de 2 bits.
Creamos el mensaje y rellenamos la matriz generadora:
msg=randint(100,4,2);
genmat=[1 0 1 1 0 0 0; 1 1 1 0 1 0 0; 1 1 0 0 0 1 0; 0 1 1 0 0 0 1];
Codificamos:
code=encode(msg,7,4,'linear',genmat);
Ruido de canal del 30%:
noise=randerr(100,7,[0 1;0.7 0.3]);
Se lo sumamos a la señal codificada para obtener el código ruidoso:
noisycode=rem(code+noise,2);
Generamos la tabla estándar a partir de la matriz de comprobación de paridad:
parmat=gen2par(genmat);
trt=syndtable(parmat); Decodificamos:
1) Utilizando decode:
[newmsg,err]=decode(noisycode,7,4,'linear',genmat,trt);
w_err=find(err~=0);
n_err=length(w_err)
[number,ratio]=biterr(msg,newmsg)
2) Indexado de la tabla estándar, igual que en el ejercicio anterior:
for i=1:100
recibida=noisycode(i,:);
sindrome=rem(recibida*parmat',2);
sindrome_de=bi2de(sindrome,'left-msb');
vector_corr=trt(sindrome_de+1,:);
corregido=rem(recibida+vector_corr,2);
newmsg_2(i,:)=corregido(4:7);
end
[number,ratio]=biterr(msg,newmsg_2)
En nuestro ejemplo, se han detectado un total de 35 errores, y se han corregido todos ellos.
La capacidad de corrección del código es 𝑡 = 𝑑𝑚i𝑛–B = C–B = 1, y hemos introducido errores de 1 bit
2 2
por palabra-código con probabilidad del 30%.
Ahora, vamos a realizar el ejercicio para una probabilidad de error de canal del 30 % teniendo en cuenta que
existe la posibilidad de que exista un error de dos bits.
Sólo vamos a cambiar la línea en la que se genera el error:
noise=randerr(100,7,[0 1 2;0.7 0.2 0.1]);
C 2.3 Indique cuántos errores se han producido tras la decodificación y cuántos se han corregido
correctamente.
Para 1 bit de error: n_err=29; number=0; Todos corregidos.
Para 2 bits: n_err=29; number=17; Se han corregido 12.
Ejercicio 3: Comprobar el teorema de codificación de canal. Para ello supondremos un canal BSC con
probabilidad de error de bit de canal del 20% con codificación de canal C(7,4). ¿Podemos conseguir una
𝑃𝑒 ≤ 0.05? Si no es así, proponer una codificación que sí lo consiga.
Primero vamos a obtener la entropía para la 𝑃𝑒 que deseamos obtener en el canal finalmente, para después
poder comparar con lo que realmente tenemos.
Utilizamos la fórmula explicada anteriormente:
Pe_deseada=0.05;
H_deseada=Pe_deseada*log2(1/Pe_deseada)+(1-Pe_deseada)*log2(1/(1-
Pe_deseada));
Ahora, vamos a obtener la real con los cálculos explicados anteriormente:
n=7; %tamaño de palabra-código
k=4;%tamaño de palabra del mensaje
p=0.2; %probabilidad de error de bit
H_p=p*log2(1/p)+(1-p)*log2(1/(1-p));
C=1-H_p;
R=k/n;
H_real=1-C/R;
C 2.4 Indique la entropía real y si podría conseguirse una 𝑃𝑒 menor de 0.05 con la codificación
citada.
H_real=0.5134; No se puede obtener la Pe deseada o menor.
C 2.5 Indique el valor x de un código C(7,x) con el que sí se podría conseguir la 𝑃𝑒 deseada.
Con una k=2, sabiendo que H(0.05)=0.2864: H_real=0.0267. H_real<H_deseada
Ejercicio 4: Realizar una codificación con corrección mediante un código cíclico C(7,4). Considere en
primer lugar errores de 1 bit por palabra con una cierta probabilidad, y en segundo lugar errores de 2 bits
por palabra.
Lo primero que hacemos, igual que en los ejercicios anteriores, es crear el mensaje y el polinomio
generador:
msg=randint(100,4,2);
genpoly=cyclpoly(7,4);
A continuación codificamos con encode:
code=encode(msg,7,4,'cyclic',genpoly);
Ruido de canal para probabilidad de error de un bit (30%)
noise=randerr(100,7,[0 1;0.7 0.3]); Con
el ruido generamos el código ruidoso:
noisycode=rem(code+noise,2);
Tabla estándar a partir de la matriz de comprobación de paridad:
[parmat,genmat]=cyclgen(7,genpoly);
trt=syndtable(parmat);
1) Decodificación mediante función decode:
[newmsg,err]=decode(noisycode,7,4,'cyclic',genpoly,trt);
w_err=find(err~=0);
n_err=length(w_err)
Verifique de nuevo el error empleando la función biterr.
2) Decodificación por indexado de la tabla estándar:
for i=1:100
recibida= noisycode(i,:);
sindrome=rem(recibida*parmat',2);
sindrome_de=bi2de(sindrome,'left-msb');
vector_corr=trt(sindrome_de+1,:);
corregido=rem(recibida+vector_corr,2);
newmsg_2(i,:)=corregido(4:7);
end
C 2.6 Indique cuántos errores se han producido y cuántos se han corregido.
N_err=31; number=0; Se han corregido todos
Introduzcamos ahora una probabilidad de error de canal del 30%, distribuida entre uno y dos bits.
noise=randerr(100,7,[0 1 2;0.7 0.2 0.1]);
C 2.7 Indique cuántos errores se han producido y cuántos se han corregido satisfactoriamente.
N_err=35; number=29; Se han corregido 6.
Ejercicio 5: Realizar una codificación Hamming (7,4) introduciendo en primer lugar 1 error por palabra, y
en segundo lugar 2 errores por palabra.
Creamos como siempre el mensaje aleatorio:
msg=randint(100,4,2);
Codificamos tal y como se indica en el apartado funciones:
code=encode(msg,7,4,'hamming');
Al ser n=7, k=4, el m que cumple la relación del código Hamming es m=3; El
ruido de canal en este primer caso será de 1 bit por palabra:
noise=randerr(100,7,1); % 1 error en todas las palabras
Se lo sumamos a la señal codificada para obtener el código ruidoso:
noisycode=rem(code+noise,2);
Generamos la matriz de comprobación de paridad y la tabla estándar:
[parmat,genmat]=hammgen(m) trt=syndtable(parmat);
1) Decodificación con decode:
[newmsg,err]=decode(noisycode,7,4,'hamming');
2) Decodificación por indexado:
for i=1:100
recibida= noisycode(i,:);
sindrome=rem(recibida*parmat',2);
sindrome_de=bi2de(sindrome,'left-msb');
vector_corr=trt(sindrome_de+1,:);
corregido=rem(recibida+vector_corr,2);
newmsg_2(i,:)=corregido(4:7);
end
C 2.8 ¿Se han detectado y corregido todos los errores?
Si, ya que n_err=100 y number=0, por lo que se han corregido todos.
Por definición, la capacidad de corrección en el código Hamming es t=1.
Introduzcamos ahora 2 errores por palabra, que es más de lo que este código puede corregir:
noise=randerr(100,7,2);
C 2.9 ¿Se han detectado y corregido los errores en este segundo caso?
Según el programa, se han generado hasta más errores de los que habíamos detectado
mediante n_err, hasta 71 más.
n_err=100; number=171;
3. Códigos BCH y Reed-Solomon
Los códigos BCH son una clase de códigos cíclicos con un polinomio generador particular que operan
sobre un tipo especial de datos denominado extensión de cuerpos o Galois Field (GF). Los más comunes
son los códigos BCH simplificados que tienen de tamaño de bloque 𝑛 = 2G − 1 con m ≥ 3,
con distancia mínima 2𝑡 + 1, por tanto, corrigen t errores. Los códigos Hamming, con t=1, son una
subclase de los códigos BCH.
Los códigos Reed-Solomon son códigos cíclicos no binarios que conforman también una subclase de los
códigos BCH. Este tipo de código trabaja con símbolos en vez de con bits, siendo cada símbolo una
secuencia de m bits; se considerará que un símbolo es erróneo cuando al menos uno de sus bits lo es. Cada
palabra estará formada por k símbolos de información y r de redundancia, por tanto, cada palabra-código
estará formada por n símbolos. La capacidad de corrección es t=r/2 símbolos.
Funciones
bchenc:
code=bchenc(msg,n,k);
Codifica el mensaje con un código BCH (n,k). El mensaje msg debe ser del tipo de datos llamado array
Galois Fields (GF), que obtendremos mediante la función gf.
bchgenpoly:
[genpoly,t]=bchgenpoly(n,k)
Con esta función obtenemos el polinomio generador para la codificación BCH (n,k) y la capacidad
correctora de dicho código t.
bchdec:
[decoded,cnumerr,ccode]=bchdec(code,n,k)
Esta función trata de decodificar el código que se le introduce como parámetro en code, mediante un
decodificador BCH (n,k).
Al decodificar habrá fallos si en la palabra hay más de t errores, siendo t la capacidad correctora del código.
code es también un array GF.
cnumerr es un vector columna en el que cada elemento representa el número de errores corregidos en la
palabra del mensaje correspondiente. Si hay un valor de -1, es que ha habido un error en la decodificación.
ccode se presenta en el mismo formato que code, y representa el código corregido; además, si ha habido
un error de decodificación en una palabra, la deja intacta.
gf:
x_gf=gf(x,m)
Crea un array Galois Fields GF(2m) a partir de la matriz introducida en x; si no se introduce valor de
m, se tomará por defecto 1.
rsenc:
code=rsenc(msg,n,k)
Codifica el mensaje con un código Reed-Solomon (n,k). El mensaje debe ser un array GF, teniendo en
cuenta que cada símbolo ocupará m bits, ya que en este caso no es un código binario, sino con símbolos de
m bits.
rsdec:
[decoded,cnumerr,ccode]=rsdec(code,n,k)
Decodificación y corrección de errores del código introducido por code, mediante un decodificador
Reed-Solomon (n,k).
Ejercicios
Ejercicio 6: Realizar codificación BCH (7,4) y BCH (15,5). Comprobar la capacidad de corrección
introduciendo t errores, y posteriormente t+1.
Primero utilizamos el código BCH (7,4).
n=7;
k=4;
Creamos el mensaje, igual que en los ejercicios anteriores, y transformamos a formato GF con m=1, por ser
binario:
mn=randint(100,k,2);
msg=gf(mn); Codificamos
con bchenc:
code=bchenc(msg,n,k);
Veamos la capacidad de corrección:
[genpoly,t]=bchgenpoly(n,k);
Generamos el ruido de canal con t errores:
noise=randerr(100,n,t); % t errores en todas las palabras
Se lo sumamos a la señal codificada para obtener el código ruidoso:
noisycode=code+noise;
Decodificacion:
[decoded,cnumerr,ccode]=bchdec(noisycode,n,k);
En esta situación tenemos una capacidad correctora de t =1 bit erróneo por palabra.
C 3.1 Compruebe el correcto funcionamiento del código para t errores y su funcionamiento erróneo
para t+1 errores:
[number,ratio]=biterr(double(decoded.x),mn)
Aquí number=0 para t errores, y para t+1, number=170 y ratio=0.4250.
C 3.2 Verifíquelo para una codificación BCH (15,5).
Con n=15 y k=5, para t errores number=0, y para t+1 errores, number=181 y ratio=0.3620
Ejercicio 7: Realizar una codificación RS (7,3) y RS (15,5). Comprobar la capacidad de corrección
introduciendo t errores, y posteriormente t+1.
Empezamos por RS (7,3). En primer lugar introducimos los parámetros n y k, y calculamos m:
n=7;
k=3;
m=log2(n+1);
Creamos un mensaje de 100 palabras de k símbolos, de m bits cada uno. Después lo transformamos a Galois
Field:
mn=randint(100,k,2^m);
msg=gf(mn,m); Codificamos
con rsenc:
code=rsenc(msg,n,k);
Calculamos la capacidad de corrección:
t=(n-k)/2;
Generamos el ruido de canal:
err=randerr(100,n,t);
En err generamos el patrón de error de t unos por palabra, de modo que cambiamos t símbolos en cada
palabra:
noisycode=code.*(1-err)+randint(100,n,2^m).*err;
Decodificamos con rsdec, y comprobamos si es correcto:
[decoded,cnumerr,ccode]=rsdec(noisycode,n,k);
OK=isequal(msg,decoded)&isequal(code,ccode)
C 3.3 ¿Funciona correctamente el código?
Para t errores, OK=1, por lo que los ha corregido y funciona. Sin embargo, para t+1 errores, OK=0,
por lo que no funcionó.
Para errores de t+1 símbolos, cambiamos la línea que define err:
err=randerr(100,n,t+1);
En esta ocasión, como era de esperar, la decodificación no ha sido correcta. Para
comprobar el código RS (15,5), cambiamos el valor de n y k.
n=15;
k=5;
Obtenemos una capacidad correctora de 5 símbolos.
Para t errores obtenemos que se decodifica correctamente; por el contrario, para 6 errores no funciona.
Ejercicio 8: Comparativa de los códigos BCH Y RS: capacidad correctora vs. longitud.
C 3.4 Compare los códigos BCH y RS en función de la longitud del código, la longitud de la
redundancia, y la capacidad correctora del mismo.
