Sei sulla pagina 1di 19

Simulazione Montecarlo di un sistema di comunicazione QPSK

a cura di F.Pecile

Corso Comunicazioni Wireless Dipartimento di Ingegneria Elettrica Gestionale e Meccanica Universit` a di Udine A.Tonello a.a. 2005 - 2006

Listati Matlab
QPSK gure main.m
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Corso Comunicazioni Wireless. % a.a. 2005-2006 % % Lezione MATLAB % Simulazione di un sistema di comunicazione QPSK %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% clear all close all %%% inizializzazione parametri Nb=100; M=4; Ns=Nb/log2(M); N=8; Ts=1; T=N*Ts; SNR=10; Nh = 20; roll_off = 0.2; % % % % % % % % % numero di bit; deve essere un multiplo intero di log2(M), con M cardinalit` a dellalfabeto cardinalit` a dellalfabeto, es. M=4 per la QPSK numero di simboli fattore di interpolazione/sovracampionamento, tipicamente ` e scelto N >= 8 periodo di chip periodo di simbolo rapporto segnale rumore in dB

% la lunghezza della risposta impulsiva filtro in periodi % di simbolo e ` pari a 2*Nh+1 % fattore di roll-off del filtro a radice di coseno % rialzato

tipo_ch = rayle; % tipo di canale sul quale si trasmette % ideal = canale piatto ideale % rayle = canale flat fading avente ampiezza modellata % secondo Rayleigh err_camp = 0; % errore sul campionamento in periodi di chip Ts

%%% BIT MAPPER %%% sorgente bit = sorgente(Nb); a = bit2sym(M,bit); % i simboli a sono a valori in 0,1,...,M-1 [a_gray,mapping] = codifica_Gray(a,M); % i simboli a_gray sono i simboli % a con codifica di Gray c = pskmod(a_gray,M); % i simboli c sono a valori complessi, giacciono % sulla circonferenza di raggio unitario %%% costellazione dei simboli in ingresso scatterplot(c); pt = pskmod([0:M-1],M); % vettore con tutti i punti della costellazione title(Costellazione simboli trasmessi.) text(real(pt)+0.1,imag(pt),dec2bin(mapping)); axis([-1.5 1.5 -1.5 1.5]); % cambia gli assi in modo da contenere le label % nel plot

% traccio le regioni di decisione hold on plot([-1.5 1.5],[-1.5 1.5],k--) plot([-1.5 1.5],[1.5 -1.5],k--) saveas(gcf, sprintf(costellazione_tx_%s,tipo_ch), fig) pause %%% MODULATORE %%% filtro in trasmissione hTX = filtro_TX(roll_off,Nh,Ts,T); if tipo_ch == ideal %%% risposta impulsiva del filtro in trasmissione figure subplot(2,1,1) stem([0:1:length(hTX)-1]-(length(hTX)-1)/2,hTX) title(Filtro in trasmissione. Risposta impulsiva e in frequenza.) xlabel(n) ylabel(h_{TX}(nTs)) subplot(2,1,2) N_punti_FFT = 1024; f = [-N_punti_FFT/2:N_punti_FFT/2-1]; HTX = 1/sqrt(T)*fftshift(Ts*fft(hTX,N_punti_FFT)); plot(f,abs(HTX),b) xlabel(f) ylabel(|H_{TX}(f)|) saveas(gcf, sprintf(filtro_tx_%s,tipo_ch), fig) pause end %%% modulatore x = modulatore(c,hTX,Ts,T); %%% canale trasmissivo hCH = canale(tipo_ch,hTX,Ts,T); y = Ts*conv(x,hCH); %%% andamento della risposta impulsiva del canale figure stem(0:1:length(hCH)-1,abs(hCH)) title(Risposta impulsiva del canale) xlabel(n) ylabel(h_{CH}(nTs)) saveas(gcf, sprintf(canale_%s,tipo_ch), fig) pause %%% rumore termico y = rumore(y,SNR,hTX,Ts,T); %%% DEMODULATORE %%% filtro in ricezione 2

hRX = filtro_RX(hTX); if tipo_ch == ideal %%% andamento della risposta impulsiva del filtro in ricezione figure stem([0:1:length(hRX)-1]-(length(hRX)-1)/2,hRX) title(Filtro in ricezione) xlabel(n) ylabel(h_{RX}(nTs)) saveas(gcf, sprintf(filtro_rx_%s,tipo_ch), fig) pause %%% andamento dellautocorrelazione del filtro k_hTX = Ts*conv(hTX,hTX); % autocorrelazione deterministica del filtro k_hTX_dec = k_hTX(1:T/Ts:end); % autocorrelazione decimata in modo % ottimo k_hTX_dec_err = k_hTX(1+2:T/Ts:end); % autocorrelazione decimata in % modo errato figure subplot(2,1,1) stem([0:1:length(k_hTX)-1]-(length(k_hTX)-1)/2,k_hTX) title(Autocorrelazione deterministica del filtro) xlabel(n) ylabel(k_{hTX}(nTs)) subplot(2,1,2) stem(([0:1:length(k_hTX_dec)-1]-... (length(k_hTX_dec)-1)/2)*T/Ts, k_hTX_dec) hold on; stem(([0:1:length(k_hTX_dec_err)-1] - ... (length(k_hTX_dec_err)-1)/2)*T/Ts, k_hTX_dec_err,r) title(Autocorrelazione deterministica decimata) legend(ottimo,errato) xlabel(n) ylabel(k_{hTX,dec}(nT)) saveas(gcf, sprintf(autocorrelazione_%s,tipo_ch), fig) pause end % risposta impulsiva equivalente hEQ = Ts*conv(Ts*conv(hTX,hCH),hRX); [h_EQ_0 t0_ottimo] = max(hEQ); % il picco della risposta impulsiva % equivalente mi consente di determinare l % istante ideale per iniziare il % campionamento. Questa operazione pu` o % essere fatta solo se conosco la risposta % impulsiva del canale. In un sistema reale % ` e necessario fare sincronizzazione per % determinare lepoca di campionamento. if tipo_ch == ideal %%% andamento della risposta impulsiva equivalente 3

figure stem([0:1:length(hEQ)-1]-(length(hEQ)-1)/2,hEQ) title(Risposta impulsiva equivalente) xlabel(n) ylabel(h_{EQ}(nTs)) saveas(gcf, sprintf(risposta_equivalente_%s,tipo_ch), fig) pause end t0 = t0_ottimo + err_camp; % % % % % % % % lerrore sul campionamento e ` causa di ISI al ricevitore. In questa simulazione non si fa nulla per contrastare leffetto di disturbo introdotto dallISI. In un sistema reale listante di campionamento ideale non e ` noto, quindi si opera in presenza di ISI. Per ridurre lISI e ` necessario effettuare equalizzazione.

%%% demodulatore QPSK z = demodulatore(y,hRX,t0,Ts,T); z = z(1:length(c)); % prendo un numero di campioni pari al numero % di simboli trasmessi, i rimanenti campioni sono % solo rumore %%% andamento del segnale ricevuto dopo il campionamento scatterplot(z) title(Costellazione del segnale ricevuto dopo il campionamento) text(real(pt)+0.1,imag(pt),dec2bin(mapping)); axis([-1.5 1.5 -1.5 1.5]); % traccio le regioni di decisione, sono quelle del caso AWGN in cui non ho % una rotazione della costellazione hold on plot([-1.5 1.5],[-1.5 1.5],k--) plot([-1.5 1.5],[1.5 -1.5],k--) saveas(gcf, sprintf(costellazione_rx_%s,tipo_ch), fig) pause %%% elemento di decisione c_d = decisione(z,hCH,hTX,mapping,M,Ts); a_gray_d = pskdemod(c_d,M); a_d = codifica_Gray(a_gray_d,M); bit_d = sym2bit(M,a_d); %%% calcolo delle probabilit` a derrore [SER BER] = errori(a,a_d,Ns,bit,bit_d,Nb);

QPSK main.m
function [BER SER] = QPSK_main(Nb,tipo_ch,SNR,err_camp) % %%% QPSK_MAIN contiene le stesse istruzioni del file QPSK_figure_main.m, a % meno delle istruzioni per il plot delle figure. Si usa per le % routine di calcolo della probabilit` a di errore (vedi file % BER_AWGN.m, BER_Rayleigh.m, BER_AWGN_ISI.m e BER_Rayleigh_ISI.m). % %%% inizializzazione parametri % Nb=20; % numero di bit M=4; % cardinalit` a dellalfabeto Ns=Nb/log2(M); % numero di simboli N=8; % fattore di interpolazione/sovracampionamento Ts=1; % periodo di chip T=N*Ts; % periodo di simbolo % SNR=20; % rapporto segnale rumore in dB filtro = sqrt; % tipo di impulso del filtro di modulazione % sqrt = radice di coseno rialzato % normal = coseno rialzato % la lunghezza della risposta impulsiva filtro in periodi % di simbolo e ` pari a 2*Nh+1 % fattore di roll-off del filtro a coseno rialzato

Nh = 10; roll_off = 0.2;

% tipo_ch = rayle; % tipo di canale sul quale si trasmette % ideal = canale piatto ideale % rayle = canale avente tempi di arrivo deterministici % multipli di Tc e ampiezze modellate secondo % Rayleigh con power delay profile esponenziale % unilatero con costante gamma % err_camp = 2; % errore sul campionamento in periodi di chip Ts

%%% BIT MAPPER %%% sorgente bit = sorgente(Nb); a = bit2sym(M,bit); % i simboli a sono a valori in 0,1,...,M-1 [a_gray,mapping] = codifica_Gray(a,M); % i simboli a_gray sono i simboli % a con codifica di Gray c = pskmod(a_gray,M); % i simboli c sono a valori complessi, giacciono % sulla circonferenza di raggio unitario %%% MODULATORE %%% filtro in trasmissione hTX = filtro_TX(roll_off,Nh,Ts,T); %%% modulatore x = modulatore(c,hTX,Ts,T); %%% canale trasmissivo hCH = canale(tipo_ch,hTX,Ts,T); y = Ts*conv(x,hCH); %%% rumore termico

y = rumore(y,SNR,hTX,Ts,T); %%% DEMODULATORE %%% filtro in ricezione hRX = filtro_RX(hTX); % risposta impulsiva equivalente hEQ = Ts*conv(Ts*conv(hTX,hCH),hRX); [h_EQ_0 t0_ottimo] = max(hEQ); t0 = t0_ottimo + err_camp; %%% demodulatore QPSK z = demodulatore(y,hRX,t0,Ts,T); z = z(1:length(c)); % prendo un numero di campioni pari al numero % di simboli trasmessi, i rimanenti campioni sono % solo rumore %%% elemento di decisione c_d = decisione(z,hCH,hTX,mapping,M,Ts); a_gray_d = pskdemod(c_d,M); a_d = codifica_Gray(a_gray_d,M); bit_d = sym2bit(M,a_d); %%% calcolo delle probabilit` a derrore [SER BER] = errori(a,a_d,Ns,bit,bit_d,Nb);

sorgente.m
function bit = sorgente(Nb) % %%% SORGENTE genera una sequenza di bit casuali. % %%% bit = sorgente(Nb) % %%% ingressi % Nb -> numero di bit % %%% uscite % bit -> sequenza di Nb bit casuali bit = round(rand(1,Nb)); % la funzione round arrotonda allintero pi` u % vicino

bit2sym.m
function a = bit2sym(M,bit) % %%% BIT2SYM converte una sequenza di bit in simboli % %%% a = bit2sym(M,bit) % %%% ingressi % M -> cardinalit` a dellalfabeto % bit -> sequenza di bit % %%% uscite % a -> vettore di simboli a valori in 0,1,...,M-1 Nb = length(bit); Ns = Nb/log2(M); % numero di simboli temp = transpose(reshape(bit,log2(M),Ns)); % raggruppa i bit (ciascun % gruppo ` e un simbolo)

% come convenzione assumo che i bit vengono trasmessi dal MSB al LSB % converto ogni gruppo di bit in decimale a = transpose(bin2dec(char(temp + double(0)))); % traspongo per avere un % vettore riga

codica Gray.m
function [a_out,mapping] = codifica_Gray(a_in,M) % %%% CODIFICA_GRAY consente di passare da simboli con valori in 0,1,...,M-1 % a simboli con codifica di Gray e viceversa in base al % tipo di ingresso che le viene passato % %%% [a_out,mapping] = codifica_Gray(a_in,M) % %%% ingressi %% % a_in -> simboli con valori in 0,1,...,M-1/con codifica Gray % M -> cardinalit` a dellalfabeto % %%% uscite %% % a_out -> simboli con codifica Gray/con valori in 0,1,...,M-1 % mapping -> vettore contenente la corrispondenza tra simbolo espresso in % decimale e la rispettiva rappresentazione con codifica di Gray % es. per la QPSK mapping=[0 1 3 2], fornisce la seguente % corrispondenza: % % Decimale | Gray % ----------+---------% 0 | 0 % 1 | 1 % 2 | 3 % 3 | 2 % matrice in cui le righe contengono lespressione in codice binario di 7

% ciascun punto della costellazione temp_Bin = double(dec2bin([0:M-1])) - 0;

% per M=4 % temp_Bin = % % % %

0 0 1 1

0 1 0 1

% matrice in cui le righe contengono lespressione in codice Gray di % ciascun punto della costellazione temp_Gray = temp_Bin; for j = [ 1 : M ] for k = [ 2 : size(temp_Bin,2) ] temp_Gray(j,k) = xor(temp_Bin(j,k),temp_Bin(j,k-1)); end end % codice Gray in decimale mapping = transpose(bin2dec(char(temp_Gray + double(0)))); % transpose in modo da avere un % vettore riga a_out = mapping(a_in+1);

ltro TX.m
function hTX = filtro_TX(roll_off,Nh,Ts,T); % %%% FILTRO_TX genera la risposta impulsiva del filtro in usato in % trasmissione % %%% hTX = filtro_TX(tipo,roll_off,Nh,Ts,T); % %%% ingressi %% % roll_off -> fattore di roll-off del filtro % Nh -> lunghezza risposta impulsiva filtro in periodi di simbolo % Ts -> periodo di chip % T -> periodo di simbolo % %%% uscite %% % hTX -> risposta impulsiva del filtro

% impulso in trasmissione hTX a radice di coseno hTX = rcosfir(roll_off, Nh, T/Ts, Ts, sqrt); % % % %

rialzato se invece di sqrt si pone normal la funzione rcosfir genera un coseno rialzato

% % senza utilizzare la funzione presente in MATLAB % hTX = 1/sqrt(T)*isrcos([-Nh:Ts/T:Nh], roll_off);

isrcos.m
function y = isrcos(t, alpha) % %%% ISRCOS Definisce la funzione trasformata inversa di Fourier di radice % di coseno rialzato. % La definizione sul libro di Cariolaro e `: % % sin(pi*(t-1/4)) 1 % isrcos(t, alpha) = --------------- * sinc(alpha*t + -) % 4*t 4 % % 1 sin(pi*(t+1/4)) % + sinc(alpha*t - -) * --------------% 4 4*t % % In letteratura compare inoltre la definizione equivalente: % % sin(pi*t*(1-alpha)) + 4*alpha*t*cos(pi*t*(1+alpha)) % isrcos(t, alpha) = --------------------------------------------------% pi*t (1-(4*alpha*t)^2) % %%% y = isrcos(t, alpha) % %%% ingressi %% % t -> istanti temporali su cui e ` definito il filtro % alpha -> fattore di roll-off del filtro % %%% uscite %% % y -> risposta impulsiva del filtro % prealloco e fisso isrcos(0) = 1 - alpha + (4 * alpha)/pi % (area di srcos(f,alpha)) y = (1 - alpha + (4 * alpha)/pi) * ones(1, length(t)); % determinare isrcos(t) per t ~= 0 i = find(t ~= 0); y(i) = sin(pi*(t(i)-0.25)) ./ (4*t(i)) .* sinc(alpha*t(i)+ 0.25)... + sin(pi*(t(i)+0.25)) ./ (4*t(i)) .* sinc(alpha*t(i)-0.25);

modulatore.m
function x = modulatore(c,hTX,Ts,T) % %%% MODULATORE Interpola la sequenza di simboli e li filtra con il filtro % in trasmissione % %%% x = modulatore(c,hTx,Ts,T) % %%% ingressi % c -> vettore dei simboli da modulare % Ts -> periodo di chip % T -> periodo di simbolo % %%% uscite 9

% x -> segnale modulato x % % % % % % % % % % % % % % % % = T*upfirdn(c,hTX,T/Ts,1); UPFIRDN(X,H,P,Q) e ` la cascata di tre sistemi applicati allingresso X: 1) Interpolazione pura di un fattore P (inserimento di zeri). 2) Filtraggio con un filtro FIR, la cui risposta impulsiva e ` contenuta in H. 3) Decimazione di un fattore Q (togliendo i campioni). % senza utilizzare la funzione presente in MATLAB % Interpolazione di c. Inserimento degli zeri tra un campione e % laltro. L = length(c); % numero di campioni di c temp = zeros(1, L*T/Ts); % preparo un vettore di zeri temp(1:T/Ts:end) = c; % scrivo ogni T/Ts posizioni i campioni di % c. temp ` e la versione "interpolata % pura" di c. x = T*conv(temp,hTX); % filtraggio della versione interpolata pura per % il filtro in trasmissione

canale.m
function [hch] = canale(tipo_ch,hTX,Ts,T); % %%% CANALE genera la risposta impulsiva del canale % %%% [hch] = canale(tipo_ch,Ts) % %%% ingressi % tipo_ch -> tipo di canale sul quale si trasmette: % - ideal = canale piatto ideale % - rayle = canale flat fading avente ampiezza modellata % secondo Rayleigh % Ts -> periodo di chip % T -> periodo di simbolo % %%% uscite % hch -> risposta impulsiva del canale k_hTX = Ts*conv(hTX,hTX); % autocorrelazione deterministica del filtro k_hTX_dec = k_hTX(1:T/Ts:end); % autocorrelazione decimata en_k_hTX_dec = T*sum(abs(k_hTX_dec).^2); % energia dellautocorrelazione % decimata if tipo_ch == rayle % flat fading % singolo tappo power = 1; hch = sqrt(power/2)*(randn(1,1)+i*(randn(1,1)))*1/Ts; % calcolo la costante di normalizzazione affinch` e il segnale ricevuto % abbia la stessa potenza statistica di quello in ingresso al sistema K = 1/(T*power*en_k_hTX_dec); 10

hch = sqrt(K) * hch; elseif tipo_ch == ideal hch = 1/Ts; K = 1/(T*en_k_hTX_dec); hch = sqrt(K) * hch; end

rumore.m
function y = rumore(y,SNR,hTX,Ts,T) % %%% RUMORE genera il rumore additivo e lo somma al segnale ricevuto % %%% rumore(y,SNR,hTX,Ts,T) % %%% ingressi % y -> segnale ricevuto % SNR -> rapporto segnale rumore in dB % hTX -> risposta impulsiva del filtro in trasmissione % Ts -> periodo di chip % T -> periodo di simbolo % %%% uscite % y -> segnale ricevuto + rumore k_hTX = Ts*conv(hTX,hTX); % autocorrelazione deterministica del filtro k_hTX_0 = max(k_hTX); var_c = 1; % potenza della costellazione, ha valore unitario nel caso della % QPSK visto che i simboli giacciono tutti sulla circonferenza % di raggio unitario var_n = var_c/(k_hTX_0 * Ts * 10^(SNR/10)); % varianza del rumore % tale per cui ottengo lSNR % richiesto wgn = sqrt(var_n/2)*(randn(size(y))+ j *randn(size(y))); % equivalente in % banda base del rumore y=y+wgn; % segnale ricevuto + rumore

ltro RX.m
function hRX = filtro_RX(hTX) % %%% FILTRO_RX genera la risposta impulsiva del filtro in ricezione adattato % al filtro in trasmissione % %%% hRX = filtro_RX(hTX) % %%% ingressi % hTX -> risposta impulsiva del filtro in trasmissione % 11

%%% uscite % hRX -> risposta impulsiva del filtro in ricezione hRX = conj(fliplr(hTX)); % hRX(nTs) = hTX*(-nTs)

demodulatore.m
function z = demodulatore(y,hRX,t0,Ts,T); % %%% DEMODULATORE filtra il segnale ricevuto e lo campiona con periodo pari % al periodo di simbolo a partire dallistante t0 % %%% z = demodulatore(y,hRX,t0,Ts,T); % %%% ingressi % y -> segnale ricevuto + rumore % hRX -> risposta impulsiva del filtro in ricezione % t0 -> epoca di campionamento % Ts -> periodo di chip % T -> periodo di simbolo % %%% uscite % z -> sequenza di simboli ricevuti affetti da rumore temp = Ts*conv(y,hRX); % filtraggio con hRX z = temp(t0:T/Ts:end); % campionamento a partire dallistante t0

decisione.m
function [c_d] = decisione(z,hCH,hTX,mapping,M,Ts); % %%% DECISIONE implementa lelemento di decisione in un ricevitore a massima % verosimiglianza. Presuppone la conoscenza della risposta impulsiva % del canale. In un sistema reale si deve effettuare stima di canale % per poter decidere correttamente. % %%% [c_d] = decisione(z,hCH,hTX,mapping,M,Ts); % %%% ingressi % z -> sequenza di simboli ricevuti affetti da rumore % hch -> risposta impulsiva del canale % hTX -> risposta impulsiva del filtro in trasmissione % mapping -> vettore contenente la corrispondenza tra simbolo espresso in % decimale e la rispettiva rappresentazione con codifica di Gray % M -> cardinalit` a dellalfabeto % Ts -> periodo di chip % %%% uscite % c_d -> simboli stimati dall elemento di decisione complex_mapping = pskmod(mapping,M);

12

k_hTX = Ts*conv(hTX,hTX); k_hTX_0 = max(k_hTX); z_d = hCH*k_hTX_0*complex_mapping; % campioni desiderati confronto = transpose(ones(length(z),1)*z_d); [d_min quale] = min(abs(ones(length(complex_mapping),1)*z - confronto)); % il minimo ` e calcolato su ciascuna % colonna c_d = complex_mapping(quale);

sym2bit.m
function bit = sym2bit(M,a) % %%% SYM2BIT converte una sequenza di simboli in bit. % %%% bit = sym2bit(M,a) % %%% ingressi % M -> cardinalit` a dellalfabeto % a -> vettore di simboli a valori in 0,1,...,M-1 % %%% uscite % bit -> sequenza di bit Ns = length(a); temp = transpose(double(dec2bin(a,log2(M)))-double(0)); bit = reshape(temp,1,prod(size(temp)));

errori.m
function [SER BER] = errori(a,a_d,Ns,bit,bit_d,Nb); % %%% ERRORI calcola il numero di errori sui simboli e sui bit. % %%% [SER BER] = errori(a,a_d,Ns,bit,bit_d,Nb); % %%% ingressi % a -> vettore dei simboli trasmessi % a_d -> vettore dei simboli stimati % Ns -> numero di simboli % bit -> sequenza di bit trasmessi % bit_d -> sequenza di bit stimati % Nb -> numero di bit % %%% uscite % SER -> simbol error rate % BER -> bit error rate

13

% calcolo della probabilit` a derrore sul simbolo Nerr=sum(a~=a_d); SER=Nerr/Ns; % calcolo della probabilit` a derrore sul bit, ha valore solo se ho % utilizzato la codifica di Gray nellassegnazione dei bit Nerr=sum(bit~=bit_d); BER=Nerr/Nb;

BER AWGN.m
% BER canale AWGN close all; clear all; Nb = 20; canale = ideal; err_camp = 0; % considero campionamento ottimo al ricevitore SNR_dB = [5:2.5:20]; N_prove = 1000000; BER = zeros(1,length(SNR_dB)); SER = zeros(1,length(SNR_dB)); k=1; for SNR = SNR_dB % azzero lo stato dei generatori di numeri pseudo casuali ad ogni % iterazione in modo da avere le stesse realizzazioni di canale per % ogni valore di SNR rand(state,0); randn(state,0); SNR for prova = [ 1 : N_prove ] [BER_prova SER_prova] = QPSK_main(Nb,canale,SNR,err_camp); SER(k) = SER(k)+SER_prova; BER(k) = BER(k)+BER_prova; end k = k+1; end BER = BER/N_prove; SER = SER/N_prove; temp = sprintf(BER_AWGN_%d.mat, N_prove); save(temp,BER,SER); figure semilogy(SNR_dB, BER, bs-); hold on grid on semilogy(SNR_dB, SER, rs-); 14

SNR_ideale_dB = [5:0.01:20]; SNR_ideale = 10.^(SNR_ideale_dB/10); BER_ideale = Q(sqrt(SNR_ideale)).*(1-1/2*Q(sqrt(SNR_ideale))); semilogy(SNR_ideale_dB, BER_ideale, b--); SER_ideale = 2*Q(sqrt(SNR_ideale)).*(1-1/2*Q(sqrt(SNR_ideale))); semilogy(SNR_ideale_dB, SER_ideale, r--);

BER Rayleigh.m
% BER canale Flat Fading Rayleigh close all; clear all; Nb = 20; canale = rayle; SNR_dB = [5:2.5:20]; err_camp = 0; % considero campionamento ottimo al ricevitore N_prove = 100000; BER = zeros(1,length(SNR_dB)); SER = zeros(1,length(SNR_dB)); k=1; for SNR = SNR_dB % azzero lo stato dei generatori di numeri pseudo casuali ad ogni % iterazione in modo da avere le stesse realizzazioni di canale per % ogni valore di SNR rand(state,0); randn(state,0); SNR for prova = [ 1 : N_prove ] [BER_prova SER_prova] = QPSK_main(Nb,canale,SNR,err_camp); SER(k) = SER(k)+SER_prova; BER(k) = BER(k)+BER_prova; end k = k+1; end BER = BER/N_prove; SER = SER/N_prove; temp = sprintf(BER_RAYLE_%d.mat, N_prove); save(temp,BER,SER); figure semilogy(SNR_dB, BER, bs-); hold on grid on 15

semilogy(SNR_dB, SER, rs-); SNR_ideale_dB = [5:0.01:20]; SNR_ideale = 10.^(SNR_ideale_dB/10); BER_ideale = 1/2 * (1 - 1 ./ sqrt(1 + 2./SNR_ideale)); semilogy(SNR_ideale_dB, BER_ideale, m--);

BER AWGN ISI.m


% BER canale AWGN e ISI dovuta a errato campionamento close all; clear all; Nb = 20; canale = ideal; SNR_dB = [5:2.5:20]; err_camp = 3; % inserisco un errore nel campionamento al ricevitore N_prove = 10000; BER = zeros(1,length(SNR_dB)); SER = zeros(1,length(SNR_dB)); k=1; for SNR = SNR_dB % azzero lo stato dei generatori di numeri pseudo casuali ad ogni % iterazione in modo da avere le stesse realizzazioni di canale per % ogni valore di SNR rand(state,0); randn(state,0); SNR for prova = [ 1 : N_prove ] [BER_prova SER_prova] = QPSK_main(Nb,canale,SNR,err_camp); SER(k) = SER(k)+SER_prova; BER(k) = BER(k)+BER_prova; end k = k+1; end BER = BER/N_prove; SER = SER/N_prove; temp = sprintf(BER_AWGN_ISI_ERR%d_%d.mat, err_camp,N_prove); save(temp,BER,SER); figure semilogy(SNR_dB, BER, bs-); hold on grid on semilogy(SNR_dB, SER, rs-);

16

SNR_ideale_dB = [5:0.01:20]; SNR_ideale = 10.^(SNR_ideale_dB/10); BER_ideale = Q(sqrt(SNR_ideale)).*(1-1/2*Q(sqrt(SNR_ideale))); semilogy(SNR_ideale_dB, BER_ideale, b--); SER_ideale = 2*Q(sqrt(SNR_ideale)).*(1-1/2*Q(sqrt(SNR_ideale))); semilogy(SNR_ideale_dB, SER_ideale, r--);

BER Rayleigh ISI.m


% BER canale Flat Fading Rayleigh e ISI dovuta a errato campionamento close all; clear all; Nb = 20; canale = rayle; SNR_dB = [5:2.5:20]; err_camp = 3; % inserisco un errore nel campionamento al ricevitore N_prove = 10000; BER = zeros(1,length(SNR_dB)); SER = zeros(1,length(SNR_dB)); k=1; for SNR = SNR_dB % azzero lo stato dei generatori di numeri pseudo casuali ad ogni % iterazione in modo da avere le stesse realizzazioni di canale per % ogni valore di SNR rand(state,0); randn(state,0); SNR for prova = [ 1 : N_prove ] [BER_prova SER_prova] = QPSK_main(Nb,canale,SNR,err_camp); SER(k) = SER(k)+SER_prova; BER(k) = BER(k)+BER_prova; end k = k+1; end BER = BER/N_prove; SER = SER/N_prove; temp = sprintf(BER_RAYLE_ISI_ERR%d_%d.mat, err_camp,N_prove); save(temp,BER,SER); figure semilogy(SNR_dB, BER, bs-); hold on grid on semilogy(SNR_dB, SER, rs-); 17

SNR_ideale_dB = [5:0.01:20]; SNR_ideale = 10.^(SNR_ideale_dB/10); BER_ideale = 1/2 * (1 - 1 ./ sqrt(1 + 2./SNR_ideale)); semilogy(SNR_ideale_dB, BER_ideale, m--);

Q.m
function y=Q(a) % %%% Q Calcola la distribuzione complementare di una v.a. gaussiana % normalizzata. y = 1-Phi(a);

Phi.m
function y=Phi(a) % %%% PHI Calcola la distribuzione di una v.a. gaussiana normalizzata. y = 0.5 * erfc( - (a) ./ (sqrt(2)));

18