Para alunos de Sistemas de Comunicação II (e para quem for "corajoso o suficiente!")

Constelação 4-PSK com ruído.

Esta postagem é "específica" para os alunos da disciplina de Sistemas de Comunicação II (IFCE).

Problema: escrever um código Scilab que simule a geração de símbolos de uma constelação M-PSK, adicione ruído e faça a demodulação em seguida, calculando a taxa de erro de bit e de símbolo.

Solução: o código exemplo abaixo satisfaz o enunciado acima, mas não usa Codificação Gray e também não está otimizado.

Problema proposto:

• incluir a Codificação Gray;
• otimizar o código exemplo;
• incluir gráfico com a taxa de erro de bit x SNR.

Código exemplo:

------------------------------------------------

// Exemplo de modulação/demodulação M-PSK
// usando o Scilab. Prof. Francisco José

// função de modulação
// Entrada: vetor de bits e índice de modulação (4, 8, 16, ...)
// Saída: vetor de símbolos da constelação
function vs=m_pskf(vbits, md);
    tb = max(size(vbits));
    soma = 0;
    vs = [];
    n = log2(md);
    for k=1:n:(tb-n)
        soma = 1;
        for p=0:n-1
            soma = soma + vbits(k+p)*2^p;
        end
        sg = exp(%i*%pi*(2*soma-1)/md);
        vs = [vs, sg];  // armazenando os dados no vetor de saída
    end
endfunction

// função de demodulação
// Entrada: vetor de símbolos, índice de modulação
// Saída: vetor de bits e vetor de símbolos sem ruído
function [vb, vsdd]=d_pskf(vs, md);
    tb = max(size(vs));
    dist = 10;
    vb = [];
    vsdd = vb;
    n = log2(md);
    vsf = zeros(1,md)
    for k=1:md
        sg = exp(%i*%pi*(2*k-1)/md);
        vsf(k) = sg;
    end
    for k=1:tb
        dist = 10;
        bits = zeros(1,n);
        for p=1:md
            dp = abs(vsf(p)-vs(k))
            if dp<dist then  // menor distância -> símbolo decidido
                dist = dp;
                bt = p;
            end
        end
        select bt   // tabela de bits
            case 1 then bits = [0,0,0,0]
            case 2 then bits = [1,0,0,0]
            case 3 then bits = [0,1,0,0]
            case 4 then bits = [1,1,0,0]        
            case 5 then bits = [0,0,1,0]
            case 6 then bits = [1,0,1,0]        
            case 7 then bits = [0,1,1,0]
            case 8 then bits = [1,1,1,0]                   
            case 9 then bits = [0,0,0,1]
            case 10 then bits = [1,0,0,1]
            case 11 then bits = [0,1,0,1]
            case 12 then bits = [1,1,0,1]        
            case 13 then bits = [0,0,1,1]
            case 14 then bits = [1,0,1,1]        
            case 15 then bits = [0,1,1,1]
            case 16 then bits = [1,1,1,1] 
        end
        bits = bits(1:n);  // "pegando" somente os bits que interessam
        vsdd = [vsdd, vsf(bt)];        
        vb = [vb, bits];
    end
endfunction

// Programa principal:
clc;
close;

Nb = 1024*8;  // número de bits
bits = round(rand(1,Nb,'uniform')); // gerando bits 0,1 aleatoriamente

imd = 16; // indice de modulação
vsig = m_pskf(bits,imd); // sinal modulado

tt=0:0.01:6.29; cc=cos(tt); ss=sin(tt); // para gerar um círculo

figure;
subplot(2,2,1); plot(cc,ss,real(vsig),imag(vsig),'.'); xgrid;
tit = 'Modulação ' + string(imd) + '-PSK, sem ruído.'
title(tit);

//// ruído complexo:
[aa,bb] = size(vsig);
A = 0.07;
r = A*(rand(aa,bb,'normal') + %i*rand(aa,bb,'normal'));
SNR = -10*log10(A*A*2);
SNR = round(100*SNR)/100;

vsigr = vsig + r;
subplot(2,2,2); plot(cc,ss,real(vsigr),imag(vsigr),'.'); xgrid;
tit2 = 'Modulação ' + string(imd) + '-PSK, com ruído, SNR = '+string(SNR)+' dB.';
title(tit2);

//// demodulando:
[bitsr, vsimb] = d_pskf(vsigr,imd);

/// calculando erros:
mbb = min([max(size((bits))),max(size(bitsr))]);
v_erro_b = abs(bitsr(1:mbb) - bits(1:mbb));
erros_b = sum(v_erro_b);
subplot(2,2,3); plot(v_erro_b,'-o'); 
title('Erros de bits');
disp([erros_b, erros_b/mbb],'Erros de bit:')

// erros de símbolos:
n_erro_s = 0;
for k=1:max(size(vsimb))
    if abs(vsimb(k)-vsig(k))>0.01 then
        n_erro_s = n_erro_s + 1;
    end
end
disp([n_erro_s, n_erro_s/k],'Erros de símbolo:');

----------------------------------------

Exemplo de execução:

Erros de bit:  
     12.    0.0014656 

 Erros de símbolo:  
     8.    0.0039082

Gráficos: