Projeto de Um Codec Turbo Em Matlab

UNIVERSIDADE FEDERAL DO AMAZONAS FACULDADE DE TECNOLOGIA

ESPECIALIZAÇÃO EM TELEVISÃO DIGITAL

PROJETO DE UM CODEC TURBO EM MATLAB

JOSÉ MARIA AMORAS PESSOA

MANAUS

2011



JOSÉ MARIA AMORAS PESSOA

PROJETO DE UM CODEC TURBO EM MATLAB

Orientador: D. Sc. Eddie Batista de Lima Filho

MANAUS

2011

Monografia apresentada como parte do critério de avaliação e como requisito parcial para obtenção do grau de especialista em televisão digital.



MONOGRAFIA FINAL DE CURSO

CURSO DE PÓS-GRADUAÇÃO: Especialização em Televisão Digital TITULO DE TRABALHO: Projeto de um Codec Turbo em Matlab_________________________ ALUNO: José Maria Amoras Pessoa_

PROFº ORIENTADOR: D.Sc. Eddie Batista de Lima Filho____________

Manaus – AM, Junho de 2011

MANAUS

JUNHO – 2011

AGRADECIMENTOS

Agradecimentos especiais a minha esposa Elisangela e aos meus filhos Ricardo,

Eduardo, Beatriz e Leonardo, pelo grande apoio que me permitiu concluir com êxito este

curso de especialização.

Sou eternamente grato aos meus pais por todo apoio, confiança, amor, incentivo e

pelos esforços realizados para minha formação pessoal e profissional.

Meus sinceros agradecimentos ao D. Sc. Eddie Lima pelo apoio e orientações na

elaboração deste trabalho.

RESUMO

Os Códigos Turbo tem sido objeto de muita pesquisa nos últimos anos,

produzindo resultados muito próximos ao limite teórico definido por Shannon. A razão para

esse excelente desempenho baseia-se principalmente no uso de codificadores recursivos

sistemáticos e em um procedimento de decodificação iterativa.

Este trabalho descreve o projeto e a implementação de um Codec Turbo

desenvolvido em Matlab e baseado na decodificação MAP, proporcionando uma

ferramenta para a simulação e o desenvolvimento de sistemas baseados em códigos turbo.

O desempenho do Codec é avaliado através de simulações de transmissão de dados através

de um canal AWGN. Alguns fatores que influenciam o seu desempenho são analisados,

como o tipo de entrelaçador, o seu tamanho e o número de iterações do algoritmo de

decodificação. Os resultados obtidos mostram que uma combinação adequada dessas

características pode produzir ganhos significativos. Assim, é possível estabelecer um

modelo de Código Turbo com alto desempenho.

PALAVRAS-CHAVE: Códigos Turbo, Códigos Corretores de Erros, Decodificação Iterativa.

ABSTRACT

Turbo codes have been an important research topic in recent years, producing

results which are very close to the theoretical limit set by Shannon. The reason for this

excellent performance is mainly based on the use of recursive systematic encoders and an

iterative decoding procedure.

This paper describes the design and implementation of a Turbo Codec in Matlab,

with a decoding procedure based on MAP probabilities, providing a tool for simulation and

system developing. The performance evaluation of this codec is carried through simulations

of data over an AWGN channel. Features that influence system performance are evaluated,

like interleaver type, its size and number of iterations of the decoding algorithm, and the

results show that a suitable combination of these features can produce significant

improvements. Thus, it is possible to establish a reference turbo Codec with high

performance.

KEY-WORDS: Turbo Codes, Error Correcting Coding, Iterative Decoding.

LISTA DE FIGURAS Figura 2.1 - Sistema de Comunicação .................................................................................. 14

Figura 2.2 – Sistema de Comunicação com adição de ruído (AWGN) ................................ 17

Figura 3.1 - Modelo de canal discreto sem memória ........................................................... 20

Figura 3.2 - Capacidade de um canal binário discreto sem memória em

função da probabilidade de transição .............................................................. 21

Figura 4.1 - Codificador Turbo genérico .............................................................................. 24

Figura 4.2 - Codificador convolucional recursivo (RSC) típico .......................................... 26

Figura 4.3 - Decodificador Turbo iterativo .......................................................................... 30

Figura 6.1 - Curva de desempenho (BER) para o codificador turbo com

entrelaçador s-randômico, taxa 1/2, 20 iterações, N=1.000

(vermelho), N=5.000 (verde) e N=10.000 (azul) .......................................... 44

Figura 6.2 - Curva de desempenho (BER) para o codificador turbo com taxa 1/2

para um entrelaçador s-randômico com tamanho N = 1.000, número

de iterações I = 1 (azul), I = 4 (verde), I = 7 (vermelho), I = 11 (amarelo),

I = 14 (ciano), I = 18 (magenta) e I = 20 (preto) ............................................. 46


Para um entrelaçador randômico com tamanho N = 1.000, número


I = 14 (ciano), I = 18 (magenta) e I = 20 (preto) .............................................. 47


Para um entrelaçador cíclico com tamanho N = 1.000, número


I = 14 (ciano), I = 18 (magenta) e I = 20 (preto) ............................................. 48

Figura 6.5 - Curva de desempenho (BER) para o codificador turbo com

taxa 1/2 e entrelaçadores cíclico (azul), randômico (verde) e

s-randômico (vermelho) .................................................................................. 50

LISTA DE SIGLAS

ARQ Automatic Request Repeat

AWGN Additive White Gaussian Noise

BCJR L. Bahl, J. Cocke, F. Jelinek, J. Raviv

BER Bit Error Rate

BPSK Binary Phase Shift Keying

BSC Binary Simmetric Channel

CODEC Codificador/decodificador

DMC Discrete Memoryless Channel

Eb/N0 Razão entre a energia de bit e a energia de ruído

FEC Forward Error Correction

LLR Log-Likelihood Ratio

MAP Maximum A posteriori Probability

RSC Recursive Systematic Convolutional

SISO Soft-In Soft-Out

SNR Signal-Noise Ratio

SUMÁRIO 1 INTRODUÇÃO .......................................................................................................... 11

2 SISTEMA DE COMUNICAÇÃO ............................................................................. 14

2.1 Modelo do Sistema de Comunicação ...................................................................... 14 2.2 Codificador/Decodificador de Canal ...................................................................... 15 2.3 Codificador/Decodificador de Canal ...................................................................... 16

2.3.1 O canal AWGN ................................................................................................ 17 3 CODIFICAÇÃO CONTRA ERROS EM SISTEMAS DE COMUNICAÇÃO .... 19

3.1 Introdução ............................................................................................................... 19 3.2 Canais Discretos sem Memória .............................................................................. 19 3.3 Capacidade de Canal ............................................................................................... 21 3.4 Teorema da Codificação de Canal .......................................................................... 22

4 CÓDIGOS TURBO .................................................................................................... 24

4.1 O Codificador Turbo ............................................................................................... 24 4.2 O Codificador Convolucional Recursivo ................................................................ 25 4.3 O Entrelaçador ........................................................................................................ 27 4.4 O Decodificador Turbo ........................................................................................... 29

5 DESCRIÇÃO E IMPLEMENTAÇÃO ..................................................................... 31

5.1 Implementação do Algoritmo BCJR ....................................................................... 31 5.2 Pseudo-código para a Codificação Turbo ............................................................... 33 5.3 Pseudo-código para a Decodificação Turbo ........................................................... 34 5.4 Descrição do programa ........................................................................................... 35

5.4.1 Dados ............................................................................................................... 36 5.4.2 Entrelaçador ..................................................................................................... 36 5.4.3 Codificador ....................................................................................................... 37 5.4.4 Canal AWGN ................................................................................................... 38 5.4.5 Avaliação dos Erros na entrada do Decodificador ........................................... 38 5.4.6 Decodificador ................................................................................................... 39 5.4.7 Descrição do Programa .................................................................................... 40

6 RESULTADO DAS SIMULAÇÕES ........................................................................ 42

6.1 O Efeito do tamanho do entrelaçador ..................................................................... 43

6.2 O Efeito do número de iterações no desempenho do Código Turbo ...................... 45 6.3 O Efeito do tipo de entrelaçador adotado ............................................................... 49 6.4 Análise dos Resultados ........................................................................................... 51

7 CONCLUSÃO ............................................................................................................. 53

REFERÊNCIAS BIBLIOGRÁFICAS ............................................................................. 55

APÊNDICE ......................................................................................................................... 57

U n i v e r s i d a d e F e d e r a l d o A m a z o n a s – U F A M P á g i n a | 11

1 INTRODUÇÃO

Ao longo dos anos, houve um enorme crescimento nos serviços de

telecomunicações, especialmente nas áreas de telefonia móvel, comunicações via satélite e

televisão digital. Tal avanço é conseqüência de importantes descobertas em comunicações,

aliadas ao surgimento de novas tecnologias, que possibilitam a criação de dispositivos

eletrônicos cada vez mais baratos e eficientes. O advento de novos serviços e aplicações em

comunicações tende a aumentar a demanda por maiores taxas de dados e capacidade de

comunicação em geral.

A tarefa fundamental de um sistema de comunicação é transmitir e receber

informação. Em teoria, um sistema de comunicação exige que as informações sejam

enviadas do transmissor ao receptor, de tal forma que a informação recebida seja

“semelhante” à informação transmitida. Na prática, a presença de perturbações nem sempre

permite que isto seja possível, especialmente em comunicações sem fio. Como um sistema

de comunicação deve possuir meios de se proteger contra essas perturbações, o projetista de

sistemas de comunicações faz uso da codificação de canal para realizar tal tarefa.

Em 1948, Shannon introduziu o conceito de capacidade do canal [1], descrevendo

o limite para a quantidade de dados que pode ser transmitida através de um canal. Esse

resultado provou que é possível implementar um código de controle de erro capaz de

garantir alta confiabilidade à informação recebida, desde que a taxa de transmissão seja

menor que a capacidade do canal. Desde então, atingir essa máxima capacidade teórica tem

sido o objetivo de muitos pesquisadores da área de comunicações.


Nas últimas décadas, inúmeros algoritmos foram propostos, na tentativa de

aproximar o limite de Shannon. Em 1974, Bahl, Cocke, Jelinek e Raviv publicaram um

algoritmo de decodificação baseado em “probabilidades a posteriori” [2]. Mais tarde, esse

algoritmo foi denominado BCJR, em homenagem aos autores, e também maximum a

posteriori (MAP). Devido à sua implementação, que era muito complexa, o mesmo

permaneceu cerca de duas décadas sem utilização prática. Entretanto, a situação foi alterada

quando, em 1993, Berrou, Glavieux e Thithimajshima publicaram um artigo intitulado

“Near Shannon Limit Error Coding and Decoding: Turbo Codes” [3], introduzindo a

Codificação Turbo, cujo decodificador usava uma versão modificada do algoritmo BCJR.

Surgia, então, um modelo com chances de finalmente atingir o limite de Shannon.

O objetivo do presente trabalho é apresentar a implementação de um Codec Turbo,

em Matlab, proporcionando uma ferramenta para a simulação e o desenvolvimento de

sistemas baseados em códigos turbo. Vale ressaltar que, apesar da simplicidade e da

praticidade da linguagem, é raro encontrar esse tipo de implementação em Matlab. Um dos

motivos é o fato deste utilizar uma linguagem interpretada, o que torna as simulações mais

lentas quando comparadas a opções compiladas como, por exemplo, C. Entretanto, neste

trabalho será apresentado um Codec com bom desempenho, que utiliza a precisão e a

complexidade do algoritmo MAP, combinadas a uma implementação simples.

Além disso, serão exploradas três características importantes, que influenciam o

desempenho de um Codec Turbo: o tipo de entrelaçador, o seu tamanho e o número de

iterações do algoritmo de decodificação. Assim, será possível avaliar o desempenho do

Codec para cada uma dessas características. As simulações realizadas têm o objetivo de

avaliar se a implementação proposta apresenta os mesmos resultados demonstrados na


literatura e também permitirão estabelecer um modelo de código com as melhores

configurações.

O presente trabalho está organizado como segue. O capítulo 2 apresenta uma

introdução sobre sistemas de comunicação. O capítulo 3, por sua vez, aborda a codificação

contra erros aplicada a sistemas de comunicação. Os códigos turbo são avaliados no

capítulo 4 e a sua implementação em Matlab é introduzida no capítulo 5. Finalmente, o

capítulo 6 apresenta os resultados de simulações e as conclusões do trabalho são discutidas

no capítulo 7.


2 SISTEMAS DE COMUNICAÇÃO 2.1 Modelo do Sistema de Comunicação

O diagrama de blocos mostrado na Figura 2.1 ilustra o fluxo de sinal e os blocos de

processamento típicos para um sistema de comunicação digital. A parte superior (fonte de

informação, codificador de fonte, codificador de canal e modulador digital) mostra a transformação

do sinal desde a fonte até o transmissor; o bloco inferior mostra a transformação do sinal desde o

receptor até o destino, realizando o processo inverso [4].

Figura 2.1 – Sistema de Comunicação.

A fonte gera as informações a serem transmitidas, que podem ser analógicas ou

discretas. As fontes discretas possuem um alfabeto de fonte e uma distribuição de

probabilidade de cada símbolo, o que facilita a obtenção de um modelo probabilístico. Em

geral, as fontes de informação são não-uniformes, ou seja, as mensagens produzidas por ela

possuem redundância [5].

Canal de

Transmissão

Destinatário

Decodificador

de Fonte

Decodificador

de Canal

Demodulador

Digital

fonte de

Informação

Codificador

de Fonte

Codificador

de Canal

Modulador

Digital


O bloco codificador de fonte recebe a seqüência de símbolos da fonte de

informação e tem como objetivo melhorar a eficiência de transmissão da informação. Para

isso, as informações são tratadas de modo a eliminar a parcela redundante, diminuindo a

largura de banda necessária à transmissão da informação. Idealmente, o codificador de

fonte remove toda a redundância da seqüência de entrada e converte a informação em uma

seqüência digital binária, além de também poder realizar compressão. No receptor, o

decodificador de fonte fará a operação inversa, ou seja, a recuperação da seqüência de

símbolos, entregando-a ao destinatário [6].

O bloco modulador digital gera um sinal adequado ao canal de comunicação e

melhora a utilização da largura de banda, servindo como interface com o canal de

comunicação. O seu principal objetivo é mapear a seqüência digital proveniente do

codificador de canal em um conjunto de M valores distintos de um sinal elétrico. Assim,

por exemplo, se M = 2 diz-se que a modulação é binária. No Receptor, o demodulador faz o

trabalho inverso, ou seja, a partir da informação recebida do canal de comunicação, gera a

seqüência digital a ser entregue ao decodificador de canal.

2.2 Codificador/Decodificador de Canal

O bloco codificador de canal tem a função de introduzir redundância, de forma

controlada, na seqüência digital binária, de modo a tornar a transmissão mais confiável. O

decodificador de canal do receptor tem a missão de recuperar a seqüência digital binária

original, que foi afetada pelas interferências presentes no canal. Logo, a redundância

permite aumentar a confiabilidade na informação recebida pelo receptor. Em outras

palavras, considerando-se um dado valor de relação sinal-ruído (SNR), é possível reduzir a


probabilidade de erro de bits na recepção, utilizando-se a codificação de canal, de modo a

maximizar a qualidade da transmissão [6]. Devido à adição de redundância, a codificação

de canal tem como conseqüência a expansão da largura de banda. A técnica de codificação

adotada definirá, então, a maneira como o codificador e o decodificador atuarão.

É possível dividir as técnicas de correção de erro em dois tipos [4]: Forward Error

Correction (FEC) e Automatic Reapeat reQuest (ARQ). No FEC, o receptor utiliza códigos

corretores para recuperar os dados, enquanto que no ARC um código detector de erros, no

receptor, emite um pedido de retransmissão ao identificar erros na mensagem. No FEC, bits

extras são adicionados aos bits de informação originais, antes da transmissão, para se criar

uma nova estrutura de código, que é mais resistente a erros. O decodificador de controle de

erro, então, interpreta os sinais recebidos para obter uma estimativa da informação original.

Os códigos corretores de erro são classicamente divididos em dois grandes grupos: códigos

de bloco e códigos convolucionais [7].

2.3 O canal de Comunicação

O canal de comunicação é qualquer meio físico através do qual a informação pode

ser transmitida ao receptor. Seja qual for o canal de comunicação utilizado, o sinal é

normalmente corrompido de forma imprevisível por diversas fontes, como ruído térmico,

por exemplo. Sendo assim, o canal pode ser considerado o maior fator limitante do

desempenho dos sistemas de comunicação [5].

Muitos fatores, como a atenuação, não-linearidades e ruídos fazem com que um

sinal na saída de um canal seja diferente do sinal introduzido em sua entrada. Todos esses

fatores contribuem para que haja, em um canal de comunicação, uma relação de entrada-


y x

no

saída normalmente complexa [7]. Existem muitos modelos matemáticos de canais de

comunicação, que descrevem como os sinais são afetados pelo ambiente. O modelo de

canal adotado neste trabalho será o de ruído branco gaussiano aditivo (Additive White

Gaussian Noise - AWGN).

2.4 O canal AWGN

O canal AWGN é um dos padrões de ruído mais utilizados em simulações, pois

apresenta resultados muito próximos à solução exata [4] e caracteriza-se por ser um canal

discreto sem memória (DMC). Em sua saída, é adicionado um ruído gaussiano de banda

larga. O canal AWGN pode ser representado pela equação:

y = x + no,

onde no é uma variável aleatória gaussiana com média zero e variância σ2 , x é o sinal na

saída do transmissor e y é o sinal corrompido pelo ruído, que chega à entrada do receptor. A

Figura 2.2 ilustra o modelo de canal AWGN.

Figura 2.2 – Sistema de Comunicação com adição de ruído (AWGN).

Assim, a função densidade de probabilidade da variável y, condicionada à entrada

xi, pode ser escrita como:

( ) ( )⎟⎟⎠

⎞⎜⎜⎝

⎛ −−= 2

2

2exp

21|

σσπi

ixy

xyp .

+


Este ruído é caracterizado, principalmente, pelo ruído térmico presente em

circuitos de receptores eletrônicos. O canal AWGN é útil na representação de um canal de

comunicação via satélite ou com fio, sem seletividade em freqüência [7].


3 CODIFICAÇÃO CONTRA ERROS EM SISTEMAS DE COMUNICAÇÃO

3.1 Introdução

A presença de ruído, em um sistema de comunicação digital, é inevitável e,

consequentemente, este ruído provoca erros. Para a obtenção de altos níveis de

desempenho, faz-se necessário o uso de técnicas de codificação de canal. O objetivo destas

é aumentar a robustez de um sistema de comunicação digital, na presença de ruído.

Basicamente, este processo consiste da inserção de redundâncias na seqüência binária, por

um codificador de canal, antes da transmissão. Na recepção, um decodificador de canal

verifica a seqüência recebida e, com o auxílio da redundância introduzida, corrige

automaticamente alguns padrões de erro [7].

3.2 Canais Discretos sem Memória

Um canal discreto sem memória (DMC) é um modelo estatístico, com uma entrada

X e uma saída Y, que é uma versão ruidosa de X, conforme demonstrado na Figura 3.1.

Tanto os símbolos que entram (X) quanto os que saem (Y) são variáveis aleatórias. Em

outras palavras, é um canal que, em cada unidade de tempo, aceita um símbolo de entrada

xj, pertencente a um alfabeto X, e, em resposta, emite na saída um símbolo yk, de um

alfabeto Y. O termo discreto significa que os dois alfabetos possuem tamanhos finitos e o

termo sem memória significa que o símbolo corrente presente na saída depende apenas do

símbolo corrente presente na entrada e de nenhum outro anterior.


Figura 3.1 – Modelo de canal discreto sem memória.

Um caso particular de canal discreto sem memória é canal binário simétrico

(BSC). O alfabeto de entrada do canal possui dois símbolos (x0 = 0, x1 = 1) e o de saída

também (y0 = 0, y1 = 1). O canal é simétrico porque a probabilidade de se receber um 1

quando um 0 é transmitido é a mesma de se receber um 0 quando um 1 é transmitido. Neste

caso, tem-se que p10 = P (y=1| x=0), p01 = P ( y=0| x=1) e p01 = p10 = p.

A entropia condicional de X, representada pela notação H( X|Y ), identifica a

quantidade de incerteza restante sobre a entrada do canal, depois da saída ter sido

observada. H(X) representa a incerteza sobre a entrada do canal antes da observação da

saída. Conseqüentemente, a diferença H(X) - H(X|Y) representa a incerteza sobre a entrada

do canal, que é resolvida pela observação da sua saída. Essa diferença é chamada de

informação mútua do canal, representada por I(X; Y). A informação mútua mede a

transferência de informação por amostra de y, no destino. Portanto, depende não somente

do canal, mas também da maneira como este é usado [7].

p( yk|xj )

X { x0, x1,..., xJ-1 }

X

Y Y { y0, y1,..., yk-1 }


3.3 Capacidade de canal

A Capacidade de um canal discreto sem memória C é a informação mútua máxima

I(X; Y), em qualquer uso particular do canal. Assim, a transferência máxima de informação

por amostra de y é obtida maximizando-se I(X; Y). A capacidade de canal C é medida em

bits por uso do canal e depende apenas das probabilidades de transições p(yk | xj), que

definem o canal [7].

A Figura 3.2 mostra o gráfico de capacidade de um canal simétrico, binário e

discreto sem memória, em função da probabilidade de transição. A entropia H(X) é

maximizada quando os símbolos do alfabeto de entrada são equiprováveis, isto é,

p(xi=0) = p(xi=1) = 1/2.

Figura 3.2 – Capacidade de um canal binário discreto sem memória, em função da probabilidade de transição [7].

p – Probabilidade de transição

1

C – Capacidade de canal

1 0,5

0,5


3.4 Teorema da Codificação de canal

A fidelidade entre a seqüência decodificada no receptor e a originalmente

transmitida influencia a probabilidade de erro final, sendo que este resultado depende do

código utilizado e de algumas características do canal. Como regra geral, quanto maior é a

capacidade de correção de erros do código, maior deve ser a quantidade de redundância

introduzida e a complexidade de decodificação. A reconstrução precisa da seqüência

original, no destino, requer que a probabilidade média de erros seja arbitrariamente baixa.

Segundo Shannon [1] (segundo teorema de Shannon), existe um esquema de codificação de

canal eficiente o suficiente, capaz de tornar essa tarefa possível [7].

Seja uma fonte discreta e sem memória, com alfabeto S e entropia H(S), que

produz um símbolo a cada Ts segundos e o mesmo é transmitido em um canal discreto sem

memória, de capacidade C, usado a cada Tc segundos. De acordo com o Teorema da

Codificação de Canal, se

CS T

CT

SH≤

)( ,

então existe um esquema de codificação no qual a saída da fonte pode ser

transmitida pelo canal, com uma taxa de erros arbitrariamente baixa.

O parâmetro C/Tc é chamado de taxa crítica. Quando a igualdade é obtida, diz-se

que o sistema está transmitindo na taxa crítica. Caso contrário, diz-se que não é possível

transmitir, com taxa arbitrariamente baixa, a informação pelo canal.

Seja um canal simétrico binário, onde uma fonte discreta sem memória emite dois

símbolos com probabilidades iguais. A entropia da fonte é igual a um bit por símbolo, ou


seja, esta emite informação a uma taxa de 1/Ts. Seja também um codificador de canal com

uma taxa de codificação r, tal que r = k/n, onde k é o número de bits de informação e n é o

número de bits do bloco codificado. De acordo com o teorema da codificação de canal, se

CS T

CT

≤1 ,

Então a probabilidade de erros pode ser arbitrariamente baixa, se um esquema de

codificação de canal adequado for utilizado. Como r = Tc/Ts, então

Cr ≤ .

Assim, para Cr ≤ , existe uma técnica de codificação tal que a saída da fonte pode

ser transmitida através do canal, com uma taxa de erros arbitrariamente pequena, apesar da

presença de ruído. Caso contrário, se Cr > , não é possível a transmissão sem erros.

Vale ressaltar que o segundo teorema de Shannon não mostra como construir bons

códigos e deve ser interpretado como uma prova de existência, isto é, desde que a limitação

imposta pelo teorema seja satisfeita, então o código existe. Além disso, o teorema não

apresenta um resultado preciso para a probabilidade de erro após a decodificação de canal e

indica que a mesma tende para zero à medida que o comprimento do código aumenta [7].


4 CÓDIGOS TURBO 4.1 O Codificador Turbo

Um codificador turbo genérico está representado na Figura 4.1 e consiste na

concatenação paralela de dois ou mais codificadores convolucionais recursivos sistemáticos

(RSC) (codificadores constituintes), conectados por um entrelaçador. Os codificadores

constituintes são definidos pelos seus polinômios geradores. Se os mesmos forem iguais,

diz-se que o codificador é simétrico; caso contrário, é assimétrico. Como cada um dos

codificadores recebe a mesma seqüência de entrada, diz-se que a concatenação é

paralela [8].

Figura 4.1 – Codificador Turbo.

O codificador 1 opera diretamente sobre a seqüência de entrada xS (bits

sistemáticos), enquanto que o codificador 2 opera sobre uma versão entrelaçada xS’ dos

CODIFICADOR 1

CODIFICADOR 2

ENTRELAÇADOR

u = xS

PERFURADOR

x1p

x2p

x1p x2p

u’ = xS’


mesmos. O entrelaçador permuta a ordem de uma seqüência de símbolos de entrada de

maneira inteiramente determinística, produzindo os mesmos símbolos na saída, mas em

ordem diferente. Após a codificação, três fluxos de dados são gerados: os bits sistemáticos

xS e os bits de paridade x1p e x2p. Os bits de paridade x1p e x2p são então perfurados, antes da

transmissão através do canal. Assim, taxas de código mais altas, como 1/2, 2/3, 3/4, por

exemplo, podem ser obtidas através da perfuração do codificador turbo de taxa 1/3. O

perfurador, então, tem o objetivo de excluir certos bits de paridade e adaptar a taxa de

código, mas ainda mantendo a máxima distância entre as palavras-código [9]. Vale ressaltar

que o uso do mapa de perfuração não é requisito obrigatório na formação dos Códigos

Turbo.

O entrelaçador troca as posições dos N bits de entrada, de modo que o código

pareça aleatório para o canal, o que melhora o seu desempenho [9]. A introdução do

entrelaçador pseudo-aleatório é uma das razões do bom desempenho dos códigos turbo,

visto que a teoria assegura que um código escolhido aleatoriamente é capaz de se aproximar

do limite de Shannon, desde que o tamanho de bloco seja suficientemente grande [10].

Os códigos turbo são códigos de bloco, sendo que o tamanho da mensagem é

determinado pelo entrelaçador. Como os codificadores constituintes são lineares, diz-se que

os códigos turbo são códigos de bloco lineares [7].

4.2 O codificador Convolucional Recursivo

A Figura 4.2 mostra um codificador convolucional recursivo (RSC) típico,

utilizado em Codificadores Turbo. Com base na Figura 4.2, é fácil notar que g0 = 1+D+D²


e g1 = 1+D². Em notação octal, tem-se [7 5]; já em notação binária, os polinômios seriam

descritos por [111 , 101].

A matriz geradora de um código convolucional sistemático é dada por

⎥⎦

⎤⎢⎣

⎡=

0

11)(ggDG .

Se a seqüência de entrada for divisível por g0(D), o peso de Hamming da

seqüência de saída será finito; caso contrário, o peso será infinito [9].

Figura 4.2 – Codificador convolucional recursivo (RSC) típico.

O objetivo da adoção de codificadores convolucionais recursivos é fazer com que

o estado interno do registrador de deslocamento dependa das saídas passadas. Isso resulta

em um melhor do desempenho de decodificação, porque afeta o comportamento do padrão

de erro, haja vista que um único erro no bit sistemático resulta em infinitos erros de

paridade [11].

Palavras código com peso alto são desejáveis, pois isso significa que as mesmas

são mais distintas entre si e, com conseqüências, a probabilidade do decodificador

diferenciá-las aumenta. Assim, um codificador recursivo é uma boa alternativa como

D D

+

+

+

u

xS

x1p


codificador constituinte, pois permite que uma seqüência de entrada com peso baixo resulte

em uma seqüência de paridade com peso alto [12].

4.3 O Entrelaçador

O entrelaçador, ao trocar as posições dos bits de entrada, faz com que o código

pareça aleatório para o canal, o que melhora o seu desempenho [10]. O entrelaçamento dos

bits entregues ao segundo codificador componente garante a geração de palavras-código de

alto peso. Supondo-se que uma seqüência de entrada produza palavras-código de baixo

peso na saída do primeiro codificador componente, então esta mesma seqüência será

permutada pelo entrelaçador e entregue ao segundo codificador componente, garantindo a

geração de palavras-código de alto peso. Essa melhora no peso médio das palavras-código é

chamada de ganho do entrelaçador [10].

O entrelaçador influencia diretamente o desempenho dos códigos turbo, pois é

projetado para tirar vantagem das propriedades de distância dos mesmos. Ao se evitar

palavras-código de baixo peso, a taxa de erro de bits de um código turbo pode melhorar

significativamente. Outro objetivo do entrelaçador é tornar aleatória a posição dos erros

inseridos durante a transmissão, combatendo a ocorrência de erros em rajada [13].

O projeto do entrelaçador é um fator determinante para o bom desempenho do

código turbo. Assim, muitas pesquisas têm sido feitas e diversos tipos de entrelaçadores

foram desenvolvidos. Neste trabalho, serão abordados apenas três deles: o randômico, o

cíclico e o s-randômico.

Em um entrelaçador cíclico, a seqüência de informação é escrita em uma matriz

com m linhas e n colunas, tal que m > n. Em seguida, as seqüências de m colunas, de


tamanho n, são aplicadas a um banco de m registradores. O i-ésimo registrador desloca a i-

ésima seqüência de colunas na matriz, ciclicamente e para a esquerda, por (i–1)B, onde B é

o menor inteiro tal que mnB ≤ . As seqüências deslocadas formam uma nova matriz e os

dados são lidos da matriz coluna. O desentrelaçador executa uma operação similar, sendo

que a i-ésima seqüência de colunas na matriz é ciclicamente deslocada para a direita, por

(i–1)B [16].

O entrelaçador randômico usa uma permutação aleatória fixa e mapeia uma

seqüência de entrada de acordo com a ordem da permutação. Porém, uma vez definida, esta

ordem se mantêm para toda a seqüência em sua entrada [13]. Nas simulações realizadas

neste trabalho, a função rand do Matlab foi usada para se gerar uma matriz de números

aleatórios com distribuição uniforme. A partir dessa matriz, gerou-se um entrelaçador

randômico.

O entrelaçador s-randômico, proposto em [14], difere do entrelaçador randômico

por exigir que haja uma distância S (spread factor) entre os inteiros selecionados. Esse

entrelaçador é construído como segue. Cada número inteiro, escolhido randomicamente, é

comparado aos S inteiros precedentes; se o valor absoluto da diferença entre a seleção atual

e qualquer um dos S inteiros for menor que S, então esta será rejeitada. Tal processo é

repetido até que todos os N inteiros distintos sejam selecionados. Esse algoritmo não

garante a convergência para uma solução completa, porém, utilizando-se o critério

2NS ≤ , é possível obter um entrelaçador em tempo razoável [14].


4.4 O Decodificador Turbo

O decodificador turbo, mostrado na Figura 4.3, consiste em dois decodificadores

operando paralelamente e cooperativamente, através de um algoritmo conhecido como

BCJR [Bahl]. Esse algoritmo é, na verdade, um decodificador MAP, pois minimiza os erros

de bits através da estimação das probabilidades a posteriori dos bits individuais, em uma

palavra-código; para se reconstruir a seqüência de dados original, as saídas do algoritmo

BCJR são então limitadas [7]. No BCJR, as informações sobre a confiabilidade dos bits de

um dos decodificadores alimentam a entrada do outro decodificador, aumentando assim a

confiabilidade na estimativa para cada bit.

O decodificador componente 1, na Figura 4.3, tem como entrada yS (versão ruidosa

de xS ) e a paridade y1p (versão ruidosa de x1p ). Esse decodificador então produz uma saída

eL12 , chamada de probabilidade extrínseca, a qual é permutada pelo entrelaçador e usada

para melhorar a estimativa da probabilidade a priori para o segundo decodificador.

O decodificador componente 2 recebe outras duas entradas: a seqüência yS

permutada e a paridade y2p (versão ruidosa de x2p ). Esse decodificador também produz uma

saída suave, a probabilidade extrínseca eL21 , a qual passa pelo desentrelaçador e é usada

para melhorar a estimativa da probabilidade a priori para o primeiro decodificador.

Tal processo de decodificação iterativa continua até que um determinado número

de iterações seja alcançado; quando isso acontece, o processo é interrompido e o

decodificador toma uma decisão para cada bit [12].


Figura 4.3 – Decodificador Turbo iterativo.

py2

eL12

DESENTRELAÇADOR

ENTRELAÇADOR

ENTRELAÇADOR

DECODIFICADOR COMPONENTE 2

DECODIFICADOR COMPONENTE 1

eL21

py1

Sy

DESENTRELAÇADOR

^x

LIMITADOR RÍGIDO


5 DESCRIÇÃO E IMPLEMENTAÇÃO 5.1 Implementação do algoritmo BCJR

No algoritmo BCJR, o decodificador toma a decisão sobre o dado transmitido com

base no cálculo da probabilidade a posteriori logarítmica (LLR), definida como

⎟⎟⎠

⎞⎜⎜⎝

⎛−=+=

=)|1()|1(ln)(

yuPyuPuL

k

kk ,

onde ku é o sinal de entrada do codificador modulado em BPSK.

O sinal, positivo ou negativo, de )( kuL indicará que o bit enviado foi +1 ou -1,

respectivamente, e o seu valor absoluto traduzirá uma maior ou menor confiança nesta

suposição. Assim, quanto mais afastado )( kuL estiver do limiar de decisão nulo, mais

confiança haverá na estimativa do bit [19].

Como os codificadores são convolucionais, é possível expressar a LLR por

treliças [17]:

⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

==∑

==∑=

⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

==∑

==∑=

−

−

−

−

−

+

−

+

),,'(

),,'(

)(/),,'(

)(/),,'()(

1

1

1

1

yssssp

yssssp

ypyssssp

ypysssspuL

kkS

kkS

kkS

kkS

k

No numerador, +S significa que o somatório se estende às transições entre estados

's e s , provocadas por um bit de mensagem 1+=ku . Da mesma maneira, −S no

denominador designa os outros ramos da treliça, que são originados por um bit de

mensagem 1−=ku [19].

Com o uso da regra de Bayes, obtém-se


)'(.),'(.)(),,'(),,'( 11 ssssysssspyssp kkkkk −− ==== αγβ .

Esta probabilidade conjunta, ),,'( yssp , pode ser calculada como o produto das

três probabilidades βα , e γ . Vale ressaltar que, no instante k, as probabilidades βα , e

γ estão associadas ao passado, ao presente e ao futuro da seqüência y,

respectivamente [19].

)(skα é obtido com uma recursão para frente, )'(1 sk−β com uma recursão para

trás e ),'( sskγ depende do canal [17]. Na treliça, os valores de α e β estão associados

aos estados do codificador e ),'( sskγ aos ramos ou transições entre estados [19]. Os

valores iniciais de )(0 sα e )(sNβ necessitam que o percurso na treliça comece e termine

no estado nulo (treliça terminada). Para isso, é necessário acrescentar, ao fim da mensagem,

alguns bits de terminação, que obriguem a máquina de codificação a regressar ao estado

nulo inicial [19].

)(skα , )'(1 sk−β e ),'( sskγ são calculados da seguinte maneira:

)()()|()'|,(),'( 1 kkkkkkk uPuPuypssysspss ==== −γ ,

∑ ∑∑

−

−===S S kk

S kkkkk sss

sssyssps

' 1

' 11 ),'()'(

),'()'(),()(

γαγα

α

e

∑ ∑∑

−−− ===

S S kk

S kk

Nkk sss

sssssyps

' 1

'11 ),'()'(

),'()()'|()'(

γαγβ

β .

Finalmente, a LLR a posteriori é dada pela expressão


⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

∑

∑=

−

−

−

+

)'(.),'(.)(

)'(.),'(.)(ln)(

1

1

ssss

ssssuL

kkkS

kkkS

k αγβ

αγβ.

Supondo-se que a modulação utilizada seja BPSK, a característica do canal cL é

definida como

0

4N

ErL b

c = ,

Onde 2/0N é a densidade espectral de potência bilateral do ruído, bE é a energia

transmitida por bit de mensagem e r é a taxa de código.

Como resultado final, tem-se

)()()( kekaskck uLuLyLuL ++= .

skc yL é o valor do canal, composto por quantidades relativas ao canal de

comunicação, )( ka uL é a informação a priori, isto é, a informação extrínseca enviada pelo

decodificador complementar e )( ke uL é a informação extrínseca a ser calculada, que

posteriormente será enviada ao outro decodificador [18].

5.2 Pseudo-código para a Codificação Turbo Início

for k = 1 : N

• Entrar com Sxu = (bits sistemáticos).

• Calcular px1 (bits de paridade do codificador 1) e px 2 (bits de paridade do

codificador 2).


• Perfurar fluxos px1 e px 2 .

• Multiplexar Sx , px1 e px 2 .

end

end

5.3 Pseudo-código para a Decodificação Turbo Início

1. Obter sky (bits sistemáticos), p

ky1 (bits de paridade do codificador 1) e pky 2 (bits de

paridade do codificador 2).

for k = 1 : iteração

DECODIFICADOR 1:

1. Estabelecer a informação a priori )()( keka uLuL = . Condição inicial: 0)( =ka uL

2. Calcular ),( ' ssyk .

3. Calcular )(skα . Condição inicial: ( )⎩⎨⎧

≠=

=0001

0 sparaspara

sα

4. Calcular )(skβ . Condição inicial: ( )⎩⎨⎧

≠=

=0001

0 sparaspara

sβ .

5. Calcular ⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

∑

∑=

−

+

)(.),'(.)(

)(.),'(.)(ln)(

ssss

ssssuL

kkkS

kkkS

k αγβ

αγβ

6. Calcular )()()( kaskckke uLyLuLuL −−= (informação extrínseca).

DECODIFICADOR 2:

1. Entrelaçar )( ke uL e sky .


2. Estabelecer a informação a priori )()( keka uLuL = .

3. Calcular ),( ' ssyk .

4. Calcular )(skα

5. Calcular )(skβ estabelecendo como condição inicial: ( ) )(0 ss kαβ = .

6. Calcular ⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

∑

∑=

−

+

)(.),'(.)(

)(.),'(.)(ln)(

ssss

ssssuL

kkkS

kkkS

k αγβ

αγβ

7. Calcular )()()( kaskckke uLyLuLuL −−=

end

ESTIMATIVA FINAL:

1. Calcular )()()( kekaskck uLuLyLuL ++=

2. Aplicar o Limitador rígido a )( kuL para obter ^u

end

5.4 Descrição do programa

O código fonte, presente no Apêndice, é composto pelas seguintes partes: dados,

entrelaçador, codificador, canal AWGN, avaliação dos erros na entrada, decodificador,

limitador e saída de dados. A opção por um programa composto por um módulo único teve

o objetivo de tornar a execução mais rápida, principalmente quando do uso de blocos

grandes (superiores a 1.000 bits); apenas duas funções externas foram desenvolvidas: o

entreleçador s-randômico e o cíclico. As seções seguintes apresentarão uma descrição do

funcionamento de cada uma dessas partes.


5.4.1 Dados

O código inicia com a entrada dos dados de configuração, necessários ao

funcionamento do programa, tais como:

• bloco – Define o tamanho do bloco;

• num_blocos – Define o número de blocos (tamanho do entrelaçador);

• iteracao – Define o número de iterações;

• SNR – Define a intensidade do ruído (SNR em dB);

• taxa_codigo – Define a taxa de código;

• polinomio – Define o polinômio gerador a ser adotado.

5.4.2 Entrelaçador

Esta parte do código cria o entrelaçador. O entrelaçador Randômico é obtido

através da função rand, nativa do Matlab e responsável pela geração de uma matriz de

números aleatórios com distribuição uniforme, média zero e desvio padrão dependente da

intensidade de ruído. Então, cria-se o vetor P, cujo comprimento é igual ao tamanho do

bloco.

Exemplo 1: Considerando-se uma mensagem de bloco = 20, o programa apresentará o

seguinte resultado:

P = [16 5 1 9 11 13 15 7 20 18 6 17 19 14 8 12 3 2 10 4].

O entrelaçador Cíclico é formado a partir da função ciclico1, descrita no

apêndice B. O produto entre linha e coluna deve corresponder ao tamanho do bloco. Dessa

forma, os seguintes dados devem ser fornecidos:

• deslocamento – Define o deslocamento dentro da matriz;


• linha – Define o número de linhas da matriz;

• coluna – Define o número de colunas da matriz.

Exemplo 2: Considerando-se uma mensagem de bloco = 20, com deslocamento = 3, linha

= 2 e coluna = 10, o programa apresentará o seguinte resultado:

P = [1 16 3 18 5 20 7 2 9 4 11 6 13 8 15 10 17 12 19 14].

O entrelaçador S-randômico é formado a partir da função s_randomico, descrita

no apêndice C. Nesse caso, definido-se o tamanho do bloco, a função fornecerá o

entrelaçador desejado.

Exemplo 3: Considerando-se uma mensagem de bloco = 20 e S = 3, o programa

apresentará o seguinte resultado:

P = [2 13 9 3 20 15 10 16 18 4 6 8 11 14 7 5 12 17 1 19].

5.4.3 Codificador

O codificador é composto pelo Codificador Componente 1, o Codificador

Componente 2 e o Perfurador. A variável Dados, gerada a partir da função rand do Matlab,

corresponde à mensagem transmitida na forma binária. Parte deste codificador foi obtida a

partir do código fonte apresentado em [7].

O codificador gera a seqüência TX = {Y, P1, Y, P2, Y, P1, Y, P2, ...}, onde Y é o

bit sistemático, P1 é o bit de paridade do codificador componente 1 e P2 é o bit de paridade

do codificador componente 2. O sinal TX, modulado em BPSK, é transmitido através de

um canal AWGN.

Exemplo 4: Supõe-se uma mensagem transmitida com 20 bits, sendo 18 bits de dados e 2

bits de terminação, conforme mostrado abaixo.


Dados = [1 0 1 0 1 1 1 0 0 1 1 0 1 0 1 1 0 1 1 0].

Entrelaçador S-randômico: P = [2 13 9 3 20 15 10 16 18 4 6 8 11 14 7 5 12 17 1 19].

Polinômio gerador: polinômio = [111;101].

Taxa de código: taxa_codigo = 1/2.

Então, o programa apresentará o seguinte resultado:

P1y = [ 1 1 0 1 1 1 0 0 1 0 0 1 1 0 1 0 0 0 1 0 ] (Bits de paridade 1 antes da perfuração).

P2y = [ 0 1 1 0 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 ] (Bits de paridade 2 antes da perfuração).

TX= [1 1-1 1 1-1-1-1 1 1 1 1 1-1-1-1-1 1 1-1 1-1-1 1 1 1-1 1 1 1 1 1-1-1 1 1 1 1-1 1].

5.4.4 Canal AWGN

O ruído gaussiano é gerado pala função randn, do Matlab a partir das informações

de SNR e taxa de código.

Exemplo 5: Para bloco = 20, snr = 1 dB e taxa_codigo = 1/2, obtêm-se

ruido = [0.2847 0.6880 -0.7578 0.6170 -0.0410 0.2308 1.2412 0.0195 0.9610 ...

-0.3589 -1.3393 0.0076 -0.1831 1.6637 1.2029 0.3638 -0.2888 -1.3296 -1.3077 ...

0.3597 1.3321 -0.6514 -0.4060 0.5192 -0.9428 -0.1679 0.8000 -0.3992 -1.5881 ...

0.5473 0.3658 1.1439 -1.2523 0.4083 0.1205 -0.3154 1.2239 -0.4187 -0.4867 0.8298].

5.4.5 Avaliação dos Erros na entrada do Decodificador

Nessa parte do código, avalia-se a quantidade de erros de bits recebida pelo

decodificador, através da variável rec. Os dois últimos bits de terminação da mensagem não

são considerados.

Exemplo 6: Considerando-se os mesmos dados usados nos exemplos 4 e 5, o canal ruidoso

causará o surgimento de 5 bits errados, conforma mostrado abaixo.


Dados = [1 0 1 0 1 1 1 0 0 1 1 0 1 0 1 1 0 1]

Dados_rec = [1 0 1 1 1 0 1 1 0 0 1 0 1 0 0 1 0 1]

Rec = 5 erros.

5.4.6 Decodificador

Os vetores ENT e SAI são obtidos a partir da treliça resultante do codificador

convolucional, cujo polinômio gerador é [111;101]. O vetor ENT está associado aos bits

sistemáticos, enquanto SAI está associado aos bits de paridade. As oito transições de estado

possíveis geram os seguintes vetores:

ENT = [-1 1 1 -1 1 -1 -1 1]

e

SAI = [-1 1 -1 1 1 -1 1 -1].

Nesta etapa, calculam-se os seguintes itens:

• La – LLR a priori;

• Le – Informações extrínseca;

• gama – Probabilidade ),'( sskγ ;

• alfa – Probabilidade )(skα ;

• beta – Probabilidade )(1 sbk− ;

• LLR – Saída do Limitador.

Exemplo 7: Supõe-se os mesmos dados usados nos exemplos 4, 5 e 6, para se calcular a

LLR, adotando-se também duas iterações. Os resultados são apresentados abaixo e

demonstram que o decodificador é realmente capaz de corrigir os 5 erros, ao final da

segunda iteração.


Dados = [1 0 1 0 1 1 1 0 0 1 1 0 1 0 1 1 0 1]

Dados_rec = [1 0 1 1 1 0 1 1 0 0 1 0 1 0 0 1 0 1]

LLR = [1 0 1 0 1 0 1 1 0 0 1 0 1 0 1 1 0 1] – Primeira iteração: Rec = 3 erros.

LLR = [1 0 1 0 1 1 1 0 0 1 1 0 1 0 1 1 0 1] – Segunda iteração: Rec = 0 erros.

5.4.7 Descrição do programa

O código fonte descrito no Apêndice é composto por três partes, Codificador,

Canal AWGN e Decodificador. O código inicia com a entrada dos dados necessários para o

funcionamento do programa, tais como: tamanho do bloco, número de blocos, número de

iterações do decodificador, SNR, taxa de código e o polinômio gerador. Em seguida,

escolhe-se o tipo de entrelaçador usado. Foram implementados três tipos de entrelaçadores:

- Randômico, obtido através da função rand, nativa do Matlab, e responsável pela

geração de uma matriz de números aleatórios com distribuição uniforme;

- Cíclico, formado a partir da função ciclico1, descrito no apêndice B;

- S-randômico; formado a partir da função s_randomico, também descrito no

apêndice C;

O Codificador é composto pelo Codificador Componente 1, Codificador

Componente 2 e o Perfurador. Na saída do Codificador é gerada a seqüência

TX = {Y, P1, Y, P2, Y, P1, Y, P2, ...}, onde Y é o bit sistemático, P1 é o bit de paridade

do codificador componente 1 e P2 é o bit de paridade do codificador componente 2. Parte

deste codificador foi obtida do código fonte apresentado em [7].

O sinal TX modulado em BPSK é transmitido através de um canal AWGN. Em

seguida, é feita uma avaliação dos erros obtidos na entrada do decodificador.


O Decodificador é composto pelo Decodificador 1, Decodificador 2 e o Limitador

Rígido. Cada decodificador é composto pelas probabilidades gama, alfa e beta. Gama é

calculado primeiro e em seguida são calculados alfa e beta. No cálculo de alfa percorre-se a

treliça do início par o fim, enquanto o beta percorre o sentido contrário. Alfa e beta estão

associados aos estados do codificador, enquanto gama está associado às transições entre

estados.

Depois de atingido o número pré-determinado de iterações a LLR na saída do

segundo decodificador é desentrelaçada e o limitador rígido estima o bit de informação de

acordo com o sinal.


6 RESULTADOS DAS SIMULAÇÕES

As simulações apresentadas neste capítulo foram obtidas através da

implementação do Código Turbo em Matlab, com execução em ambiente Windows. A

avaliação de desempenho do Código Turbo foi realizada a partir da medida da taxa de erro

de bits (BER), assumindo-se que existe uma perfeita sincronização entre transmissor e

receptor. Os parâmetros utilizados nas simulações foram:

• Fonte binária de dados;

• Canal AWGN;

• Modulação BPSK (+1 / -1);

• Algoritmo BCJR para decodificação MAP;

• Taxa de código R=1/2 obtida através de perfuração;

• Polinômios geradores go = (7) e g1 = (5);

• Faixa de variação de Eb/No de 0 dB a 2 dB.

Foram avaliadas três características importantes, que geralmente influenciam o

desempenho do Código Turbo:

• O tamanho do entrelaçador;

• O número de iterações do algoritmo de decodificação;

• O tipo de entrelaçador adotado.


6.1 O Efeito do tamanho do entrelaçador

Para se analisar o efeito do tamanho do entrelaçador, no desempenho do código

turbo, realizaram-se simulações com os seguintes parâmetros:

• Entrelaçador s-randômico de tamanhos N = 1.000, 5.000 e 10.000;

• Taxa de código de 1/2, obtida através de perfuração;

• Polinômios geradores g0 = (7) e g1 = (5);

• Número de iterações igual a 20;

• Canal AWGN;

• Algoritmo MAP.

Os resultados das simulações estão mostrados na Figura 6.1. A curva em azul

corresponde a N = 10.000, a curva em verde a N = 5.000 e a curva em vermelho a N=1.000.

Após uma breve análise, verificar-se que:

i) O desempenho do Código Turbo melhora à medida que o tamanho do entrelaçador

aumenta.

ii) O efeito do aumento do tamanho do entrelaçador é muito significativo tanto nas médias

SNR’s (de 0,5 a 1,5 dB), quanto nas altas SNR’s (de 1,5 a 2,0 dB).


Figura 6.1 - Curva de desempenho (BER) para o codificador turbo com entrelaçador s-randômico, taxa 1/2, 20 iterações, N=1.000 (vermelho), N=5.000 (verde) e N=10.000 (azul).

Entretanto, as conseqüências devidas ao aumento do tamanho do entrelaçador não

são uma completa surpresa. Shannon, eu seu desenvolvimento matemático sobre canais de

comunicação, já havia chegado à conclusão de que blocos muito grandes resultariam na

redução da taxa de erros [15].

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 210

-7

10 -6

10 -5

10 -4

10 -3

10 -2

10 -1

10 0

Eb/No (dB)

BER


O aumento do tamanho do entrelaçador tem o efeito de acrescentar mais

aleatoriedade à seqüência de dados na entrada do segundo decodificador.

Conseqüentemente, as entradas dos dois decodificadores componentes tornam-se menos

correlacionadas em relação ao ruído, melhorando o desempenho da decodificação [10].

6.2 O Efeito do Número de Iterações no Desempenho do Código Turbo

Para se analisar o efeito do número de iterações no desempenho do código, turbo

foram feitas simulações adotando-se os seguintes parâmetros:

• Entrelaçadores s-randômico, randômico e cíclico;

• Taxa de código de 1/2, obtida através de perfuração;


• Número de iterações I = 1, 4, 7, 11, 14, 18 e 20;

• Canal AWGN;

• Algoritmo MAP.

As Figuras 6.2, 6.3 e 6.4 mostram os resultados das simulações. Após uma breve

análise, verificar-se que:

i) Para os três entrelaçadores, o aumento do número de iterações corresponde a uma

melhora considerável no desempenho do código. Entretanto, tal melhora tende a diminuir

para números de iterações maiores.

ii) Para o entrelaçador s-randômico (Figura 6.2), de uma a onze iterações há uma crescente

e significativa melhora no desempenho do código. Entretanto, de quatorze a vinte iterações,

a melhora não é tão significativa.


iii) Para o entrelaçador s-randômico a partir de dezoito iterações não há melhora

significativa no desempenho. Assim, para se manter uma complexidade computacional

aceitável e ainda obter bons resultados, pode-se fixar o número de iterações em dezoito.

Figura 6.2 - Curva de desempenho (BER) para o codificador turbo com taxa 1/2 para um entrelaçador s-randômico com tamanho N = 1.000, número de iterações I = 1 (azul), I = 4 (verde), I = 7 (vermelho), I = 11 (amarelo), I = 14 (ciano), I = 18 (magenta) e I = 20 (preto).

iv) Para o entrelaçador randômico (Figura 6.3), de uma a sete iterações há uma crescente e

significativa melhora no desempenho do código. Entretanto, de onze a vinte iterações, a

melhora não é tão significativa.

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2 10-7

10-6

10-5

10-4

10-3

10-2

10-1

100

Eb/No (dB)

BER


v) Para o entrelaçador randômico a partir de onze iterações não há melhora significativa no

desempenho. Assim, para se manter uma complexidade computacional aceitável e inda

obter bons resultados, pode-se fixar o número de iterações em onze.

Figura 6.3 - Curva de desempenho (BER) para o codificador turbo com taxa 1/2 para um entrelaçador randômico com tamanho N = 1.000, número de iterações I = 1 (azul), I = 4 (verde), I = 7 (vermelho), I = 11 (amarelo), I = 14 (ciano), I = 18 (magenta) e I = 20 (preto). vi) Para o entrelaçador cíclico (Figura 6.4), de uma a onze iterações há uma crescente e

significativa melhora no desempenho do código. Entretanto, de quatorze a vinte iterações, a

melhora não é tão significativa.

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2 10-7

10-6

10-5

10-4

10-3

10-2

10-1

100

Eb/No (dB)

BER


vii) Para o entrelaçador cíclico, a partir de quatorze iterações não há melhora significativa

no desempenho. Assim, para se manter uma complexidade computacional aceitável e ainda

obter bons resultados, pode-se fixar o número de iterações em quatorze.

Figura 6.4 - Curva de desempenho (BER) para o codificador turbo com taxa 1/2 para um entrelaçador cíclico com tamanho N = 1.000, número de iterações I = 1 (azul), I = 4 (verde), I = 7 (vermelho), I = 11 (amarelo), I = 14 (ciano), I = 18 (magenta) e I = 20 (preto).

O desempenho do decodificador turbo, em geral, melhora com o número de

iterações do algoritmo de decodificação, pois após a informação inicial ser compartilhada

entre os decodificadores, os mesmos terão mais informação sobre os bits de entrada, o que

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 210

-7

10 -6

10 -5

10 -4

10 -3

10 -2

10 -1

10 0

Eb/No (dB)

BER


torna a decisão mais acurada. Isso ocorre porque a informação extrínseca da saída do

decodificador 1 alimenta a entrada do decodificador 2 e proporciona um conhecimento

novo sobre as estatísticas dos dados que, por sua vez, são aliados à informação da paridade

do decodificador 2. Em seguida, a informação extrínseca da saída do decodificador 2 é

entregue ao decodificador 1, permitindo que o processo de decodificação iterativa prossiga

naturalmente [7].

6.3 O Efeito do Tipo de Entrelaçador adotado

Para se analisar o efeito do tipo de entrelaçador no desempenho do código turbo,

foram realizadas simulações adotando-se os seguintes parâmetros:

• Entrelaçadores s-randômico, randômico e cíclico;

• Taxa de código de 1/2, obtida com perfuração;


• Número de iterações I = 18;

• Tamanho do entrelaçador N = 1.000;

• Canal AWGN;

• Algoritmo MAP.

O resultado das simulações é mostrado na Figura 6.5. Os pontos vermelhos

pertencem à curva do entrelaçador s-randômico, os pontos verdes correspondem ao

randômico e os pontos azuis ao cíclico.

Como resultado de uma análise simples, a figura 6.5 mostra que:

i) Nas regiões de baixas SNR’s (de 0 a 0,5 dB), não houve diferença no desempenho dos

três entrelaçadores.


ii) Nas regiões de médias SNR’s (de 0,5 a 1,5 dB), o entrelaçador s-randômico apresentou

desempenho superior ao randômico e ao cíclico. O entrelaçador randômico, por sua vez,

apresentou desempenho superior ao cíclico.

iii) Nas regiões de altas SNR’s (de 1,5 a 2,0 dB), o entrelaçador s-randômico apresentou

desempenho significativamente superior ao randômico e ao cíclico. O entrelaçador

randômico, por sua vez, apresentou desempenho superior ao cíclico.

Figura 6.5 - Curva de desempenho (BER) para o codificador turbo com taxa 1/2 e entrelaçadores cíclico (azul), randômico (verde) e s-randômico (vermelho).

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 210-7

10-6

10-5

10-4

10-3

10-2

10-1

100

Eb/No (dB)

BER


O comportamento observado com relação aos entrelaçadores reside no fato de que,

quanto mais aleatório os código parecem para o canal de comunicação, melhor é o

desempenho do sistema como um todo, o que também já havia sido observado por

Shannon [15].

O entrelaçador s-randômico, além de introduzir aleatoriedade, ainda garante uma

distância mínima entre os dados originais na seqüência embaralhada. Essa técnica evita

ciclos curtos no código, que acabam por reduzir o desempenho da decodificação

iterativa [15].

6.4 Análise dos Resultados

As simulações realizadas demonstraram que uma implementação com alto

desempenho empregando Códigos Turbo deve incluir um entrelaçador s-randômico com

tamanho igual a 10.000 e adotar 18 iterações no decodificador.

A opção pelo entrelaçador s-randômico deve-se ao seu superior desempenho nas

regiões de médias e altas SNR’s (acima de 0,5 dB). Este excelente desempenho deve-se à

sua capacidade de quebrar padrões de entrada de baixo peso e consequentemente originar

seqüências de paridade de alto peso.

O estabelecimento do tamanho do entrelaçador em 10.000 é um compromisso

entre manter um bom desempenho em termos de probabilidade de erro de bits (ganho do

entrelaçador) e não aumentar muito a complexidade computacional.

A escolha do número de iterações do decodificador deu-se em função dos

resultados das simulações realizadas para o entrelaçador s-randômico. Para esse tipo de

entrelaçador obtêm-se um ótimo desempenho adotando-se as 18 iterações. Vale a pena


ressaltar que aumentar ainda mais o número de iterações, além de não trazer resultados

significativos, resultaria em desperdício de recursos computacionais.


7 CONCLUSÃO

Foi desenvolvido um Codec Turbo, em Matlab, visando proporcionar uma

ferramenta para a simulação e o desenvolvimento de sistemas baseados em códigos turbo.

O uso da linguagem do Matlab permitiu a criação de um código simples, graças a sua

praticidade e a existência de uma vasta biblioteca de funções. Entretanto, por tratar-se de

uma linguagem interpretada, as simulações ocorreram de forma mais lenta, quando

comparadas a outras linguagens compiladas.

Neste trabalho, foram apresentadas simulações para tamanhos de entrelaçador

variando entre 1.000 e 10.000 bits. Constatou-se que, à medida que se aumenta o tamanho

do entrelaçador, obtêm-se um desempenho significativamente melhor. Entretanto, a escolha

do tamanho do entrelaçador deve se baseada em um compromisso: maximizar o ganho do

entrelaçador enquanto se minimiza a complexidade computacional. Portanto, uma boa

relação custo-benefício é obtida para um tamanho de entrelaçador de 10.000 bits.

Os resultados de simulações apontaram o entrelaçador s-randômico como a opção

de melhor desempenho. Essa superioridade ocorre nas regiões de médias e altas SNR’s

(acima de 0,5 dB), devido a sua capacidade de quebrar padrões de entrada de baixo peso e

consequentemente originar seqüências de paridade de alto peso.

No que diz respeito ao ponto de convergência dos decodificadores, em relação ao

número de iterações, verificou-se que, para cada tipo de entrelaçador, houve um

comportamento diferente; o entrelaçador s-randômico convergiu na 18ª iteração, o

randômico na 11ª e o cíclico na 14ª. Portanto, utilizar um processo de decodificação com

número de iterações fixo e único não é eficiente. Dessa forma, é necessário fazer com que o


critério de parada seja uma função do entrelaçador adotado ou devem ser criados critérios

de parada eficientes, para que atrasos na decodificação sejam evitados, como a entropia

cruzada e o CRC propostos em [10].

Os objetivos pretendidos com a realização deste trabalho foram alcançados, pois

foi obtido um Codec Turbo, em Matlab, com bom desempenho e capaz de realizar

simulações. Entretanto, outras melhorias podem ser realizadas em trabalhos futuros, tais

como:

• Implementar decodificadores com outros algoritmos, tais como o Log-MAP, o Max-

Log-MAP e o SOVA;

• Inserir mais esquemas de modulação;

• Realizar análises em outros tipos de canais (não Gaussianos);

• Implementar outros tipos de entrelaçadores;

• Implementar outros esquemas de perfuração;

• Deixar a incorporação de polinômios geradores mais flexível.


REFERÊNCIAS BIBLIOGRÁFICAS [1] SHANNON, C. E., A Mathematical Theory of Communication, Bell Syst. Tech. Journal, Vol. 27, pp. 379-423, 1948. [2] BAHL L., COCKE J., JELINEK F., & RAVIV J., Optimal decoding of linear codes for inimizing symbol error rate, IEEE Transactions on Information Theory, v. 20, p. 284 – 287, Março 1974.Journal, Vol. 27, pp. 379-423, 1948.

[3] BERROU, C.; GLAVIEUX, A. ; THITIMAJSHIMA, P., Near optimun error correcting coding and decoding: Turbocodes, IEEE Transactions on Information Theory, p. 1261 – 1271, Outubro 1996.

[4] SKLAR, B., Digital Communication - Fundamentals and Applications, 2 ª ed. Prentice

Hall 1998.

[5] B. P. LATHI, Modern Digital and Analog Communication Systems, 2ª ed. Oxford University Press, Março 1998.

[6] PROAKIS, J. G., Digital Communication, 2 ª ed., Mc Graw-Hill, 1989.

[7] HAYKIN, S., Communication Systems, 2 ª ed., John Wiley, 2001. [8] MORELOS, R. H., The Art of Error Correcting Coding, 2 ª ed., John Wiley, 2006. [9] FILHO, E. B. L., Aplicações em Codificação de Sinais: O casamento aproximado de

padrões multiescalas e a codificação distribuída de eletrocardiograma, Tese de Doutorado, COPPE/UFRJ, Rio de Janeiro, 2008.

[10] VUCETIC, B., Turbo Codes: Principles and Applications, 2 ª ed., Springer, Junho

2000. [11] WICKER, S. B., Error Control Systems for Digital Communicatios and Storage,

Prentice Hall, 1995. [12] MOREIRA, J. C., Essentials of Error-Control Coding, John Wiley, 2006. [13] MOON, T. K., Error Correction Coding Mathematical Methods and Algorithms John

Wiley, 2005. [14] DOLINAR, S. & DIVSALAR, D.,Weight distributions for turbo codes using random

and nonrandom permutations, JPL TDA Progress Report, v. 42, p. 56 – 65, agosto 1995.


[15] H. R. SADJADPOUR, H. R., SLOANE, N. J. A., SALEHI, M., NEBE G., Interleaver Design for Turbo Codes, JSAC Journal on Selected Areas in Communications, vol. 19, pp. 831 - 837, 2000. [16] VUCETIC, B.,YUAN, J., TAN, M., Cyclic Shift Interleavers for Turbo Codes. 2nd

international Symposium on Turbo Codes pp. 547- 550, 2000. [17] RYAN, W. E., A Turbo Code Tutorial, New México State University. Disponível em:

http://vada.skku.ac.kr/ClassInfo/digital-com2000/slides/turbo2c.pdf. Acesso em: junho de 2011.

[18] SILVA, E.A.B., FILHO, E.B.L. MENDONÇA, G. V., Códigos de Controle de Erros,

COPPE/UFRJ - UFAM, 2009. [19] ABRANTES A. S., Do algoritmo BCJR à descodificação turbo, FEUP - 2004.

Disponível em: http://repositorio-aberto.up.pt/bitstream/10216/19744/2/12018.pdf. Acesso em: junho de 2011.


APENDICE A

Neste apêndice, são mostrados os códigos fonte do Codec Turbo implementado em

Matlab.

%%%%%%%% CODEC TURBO – MAP %% %%%%%%%%%%%%%

%%%%%%%% MODULAÇÃO BPSK %%%%%%%%%%%%%

%%%%%%%% JOSÉ MARIA PESSOA - 23/04/2011 %% %%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

clc;

clear;

%%%% DADOS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

bloco = 1000; % TAMANHO DO BLOCO

num_blocos = 10; %NÚMERO DE BLOCOS

iteracao = 20; %NÚMERO DE ITERAÇÕES

SNR = 1; % SNR EM dB

taxa_codigo = 1/2; %TAXA DE CÓDIGO

polinomio = [ 1 1 1; 1 0 1]; %POLINÔMIO GERADOR

%%%% ENTRELAÇADOR %%%%%%%%%%%%%%%%%%%%%%%%%%

[D, P] = sort(rand(1,bloco));%ENTRELAÇADOR (RANDÔMICO)

%%% Para adotar o entrelaçador S-RANDÔMICO substitua a linha acima pela %%%

linha: P = s_randomico(bloco);

%%% Para adotar o entrelaçador CÍCLICO substitua a linha acima pela

%%% linha: P = ciclico1;

%%%%%%%%%% CODIFICADOR %%%%%%%%%%%%%%%%%%%%%%

[n,K]=size(polinomio);

m = K - 1;

total_erros=0;

total_erros_ite = zeros(1,iteracao);

rec=0;

for h=1:num_blocos


Dados = round(rand(1, bloco - m));

%%% CODIFICADOR COMPONENTE 1 %%%%%%%%%%%%%%%%%%%%

Dad = length(Dados);

Y = zeros(1,Dad + m);

P1y = zeros(1,Dad + m);

estado = zeros(m,1);

for i = 1: Dad + m

if i <= Dad

d = Dados(1,i);

elseif i > Dad

d = rem( polinomio(1,2:K) * estado, 2 );

end

a = rem( polinomio(1,:) * [d ;estado], 2 );

v = polinomio(2,1)*a;

for j = 2:K

v = xor(v, polinomio(2,j) * estado(j-1));

end;

estado = [a ; estado(1:m-1)];

Y(i) = d;

P1y(i) = v; % BITS DE PARIDADE DO CODIFICADOR 1

end

%%% CODIFICADOR COMPONENTE 2 %%%%%%%%%%%%%%%%%%%%

P2y = zeros(1,Dad + m);

Yp = Y(P);

estado = zeros(m,1);

for i = 1: Dad + m

d = Yp(1,i);

a = rem( polinomio(1,:)*[d ;estado], 2 );

v = polinomio(2,1)*a;

for j = 2:K

v = xor(v, polinomio(2,j)*estado(j-1));


end;

estado = [a; estado(1:m-1)];

P2y(i) = v; % BITS DE PARIDADE DO CODIFICADOR 2

end

%%% PERFURADOR %%%%%%%% %%%%%%%%%%%%%%%%%%%%

for i=1: bloco

TX(2*i-1) = 2*Y(i)-1;

if rem(i,2)

TX(2*i) = 2*P1y(i)-1;

else

TX(2*i) = 2*P2y(i)-1;

end

end

%%%% CANAL AWGN %%%%%%%%%%%%%%%%%%%%%%%%%%

snr = 10^(SNR/10);

Lc = 4 * snr * taxa_codigo;

ruido = sqrt( 1/(2 * taxa_codigo * snr)) * randn(1,bloco*2);

RX = TX + ruido;

bits_errados(1,1:iteracao) = zeros(1, iteracao);

comp = fix(length(RX)/2);

P1 = zeros(1,comp);

P2 = zeros(1,comp);

for i = 1: comp

X(i) = RX(2*i-1);

if rem(i,2)>0

P1(i) = RX(2*i);

end

if rem(i,2)<1

P2(i) = RX(2*i);

end

end


%%% AVALIAÇÃO DOS ERROS NA ENTRADA DO DECODIFICADOR %%%

Dados_rec = (sign(X)+1)/2;

Dados_rec = Dados_rec(1:bloco - m);

Erros_rec = length(find(Dados_rec ~= Dados));

rec= Erros_rec+rec;

%%%%%%% DECODIFICADOR % %%%%%%%%%%%%%%%%%%%%%%%

Le=zeros(1,bloco);

ENT = [-1 1 1 -1 1 -1 -1 1];

SAI = [-1 1 -1 1 1 -1 1 -1];

for ite=1:iteracao

%%%%% DECODIFICADOR 1 %%%%%%%%%%%%%%%%%%%%%%%%%

La(P)=Le;

XP= X(P);

gama = zeros(8,bloco);

for n=1:bloco

for r=1: 8

gama(r,n)= exp(ENT(r)*(0.5*La(n)+0.5*Lc*X(n))+ SAI(r)*0.5*Lc*P1(n));

end

end

alfa = zeros(4,bloco);

alfa(1,1)=1;

for n=1:bloco

alfa(1,n+1)= alfa(1,n)*gama(1,n) + gama(5,n)*alfa(3,n);




soma=sum(alfa(1:4,n+1));

alfa(1,n+1)= alfa(1,n+1)/soma;





end

beta = zeros(4,bloco+1);

beta(1,bloco+1)=1;

for n=bloco:-1:1

beta(1,n)= beta(1,n+1)*gama(1,n) + gama(2,n)*beta(2,n+1);




soma=sum(beta(1:4,n));

beta(1,n)= beta(1,n)/soma;




end

for n=1:bloco

R1(1,n) = alfa(1,n)*beta(2,n+1)*gama(2,n);




soma1=sum(R1(1:4,n));





soma2 = sum(R0(1:4,n));

L(n) = log(soma1/soma2);

Le(n) = L(n) - La(n) - Lc*X(n) ;

end

%%%%% DECODIFICADOR 2 %%%%%%%%%%%%%%%%%%%%%%%%%

La=Le(P);


for n=1:bloco

for r=1: 8

gama(r,n)= exp(ENT(r)*(0.5*La(n)+0.5*Lc*XP(n))+SAI(r) *0.5*Lc*P2(n));

end

end

for n=1:bloco





soma=sum(alfa(1:4,n+1));





end

beta = zeros(4,bloco+1);

beta(1,bloco+1)=alfa(1,n+1);




for n=bloco:-1:1





soma=sum(beta(1:4,n));






end

for n=1:bloco





soma1=sum(R1(1:4,n));





soma2 = sum(R0(1:4,n));

L(n) = log(soma1/soma2);

Le(n) = L(n) - La(n) - Lc*XP(n) ;

end

%%% LIMITADOR RÍGIDO %%%%%%%%%%%%%%%%%%%%%%%

LLR(P) = (sign(L)+1)/2;

LLR = LLR(1:bloco - m);

bits_errados(ite) = length(find(LLR ~= Dados));

end

%%% SAÍDA DE DADOS %%%%%%%%%%%%%%%%%%%%%%%%%%

total_erros_ite = total_erros_ite + bits_errados;

total_erros = total_erros + bits_errados(iteracao);

BER = total_erros/ (bloco * h);

BER_ite = total_erros_ite/ (bloco * h);

fprintf('Bloco = '); disp(h);fprintf('\b');

fprintf('Erros recebidos no bloco = '); disp(Erros_rec);fprintf('\b');

fprintf('Erros recebidos acumulados = '); disp(rec);fprintf('\b');

fprintf('Bits não corrigidos em cada iteração = '); disp(bits_errados);fprintf('\b');

fprintf('Total de bits não corrigidos ='); disp(total_erros);fprintf('\b');


fprintf('Total de bits transmitidos ='); disp(bloco * h);fprintf('\b');

fprintf('BER ='); disp(BER);fprintf('\b');

fprintf('BER_ite ='); disp(BER_ite);fprintf('\b');

end


APENDICE B

Este código fonte gera um entrelaçador s-randômico.

%%%% ENTRELAÇADOR S_RANDÔMICO %%%%%%%%%%%%%%%%%%%

function P = s_randomico(bloco)

bloco_s = bloco;

count_max = 10000;

i = 1;

count = 0;

A(i) = randint(1,1,bloco_s)+1;

s = fix (sqrt(bloco_s/2));

i=i+1;

flag_count = 0;

h=1;

while i <= bloco_s && count <= (count_max + 1)

ref_entrada = length (A);

A(i) = randint(1,1,bloco_s) + 1;

flag = 0;

final = length (A);

inicio = final - s;

if inicio <= 0

inicio = 1;

end

%%%%%% TESTA SE NUMERO É REPETIDO %%%%%%%%%%%%%%%%

D = length (A) - 1;

while ( D > 0 ) && (flag == 0)

if ( A(i) ~= A(D) )

D = D - 1;

flag = 0; % NÚMERO NÃO REPETIDO


else

flag = 1; % NÚMERO REPETIDO

end

end

%%%%%% TESTA SE O NÚMERO É MAIOR QUE “s” % %%%%%%%%

while (final > inicio) && (flag == 0)

if abs( A(i) - A(final - 1) ) > s

final = final - 1;

flag = 0; % NUMERO APROVADO

else

flag = 1; % NUMERO REPROVADO

end

end

%%%%%%%%% DESCARTA NÚMERO REPROVADO %%%%%%%%%

if flag == 1

i = i - 1;

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

i = i + 1;

% IDENTIFICA REDUNDÂNCIAS

ref_saida = length (A);

if ref_saida - ref_entrada == 0

count = count + 1;

else

count = 0;

end

%%%% CONDIÇÃO DE PARADA OU REDUÇÃO DE “s” %%%%%%%%%%

if count >= count_max && i < (bloco_s*0.99)

A=[ ];

i = 1;

count = 0;


A(i) = randint(1,1,bloco_s)+1;

s = fix (sqrt(bloco_s/2)/2);

i=i+1;

flag_count = 0;

end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

end

if count >= count_max

A=A(1,1: i-1);

end

B = [1:1:bloco_s];

C = [ ];

k = 1;

for n = 1 : length(B)

flag = 1;

m = 1;

while B(n) ~= A(m) && flag == 1

m = m + 1;

if m > length(A)

C(k) = B(n);

flag = 0;

m = 1;

k = k + 1;

end

end

end


APENDICE C

Este código fonte gera um entrelaçador cíclico.

%%%% ENTRELAÇADOR CÍCLICO %%%%%%%%%%%%%%%%%%%%%

function Alpha= ciclico1()

x=1;

deslocamento=2; % ESCOLHA DO DESLOCAMENTO

linha=20; % ESCOLHA DO NÚMERO DE LINHAS

coluna=50; % ESCOLHA DO NÚMERO DE COLUNAS

for n=1:coluna

for m=1:linha

A(m,n)=x;

x = x + 1;

end

end

for P=2:linha

A(P,:)=[A(P,(coluna-(P-1)*deslocamento+1):coluna) ...

A(P,1:(coluna-(P-1)*deslocamento))];

end

x=1;

for n=1:coluna

for m=1:linha

Alpha(x)=A(m,n);

x = x + 1;

end

end

Projeto de Um Codec Turbo Em Matlab

Documents

Transcript of Projeto de Um Codec Turbo Em Matlab