UNIVERSITATEA TEHNICĂ ,,GHEORGHE ASACHI” DIN IAŞI

Facultatea de Electronică, Telecomunicaţii şi Tehnologia Informaţiei

B-dul Carol I nr. 11A
IAŞI - 700506

PROIECT
COMUNICAȚII MOBILE

Student Emanuel Botezat

Studentă Maria-Valentina Mareș Îndrumător: șef lucrări
Ciprian COMȘA
 Capitolul I Breviar Teoretic

I.1. Despre rețelele celulare

Ce înțelegem prin comunicație ? Înțelegem un serviciu telefonic (comunicații vocale), transmisii

de imagini statice sau în mișcare, transmisii fax, transmisii de date, poștă electronică sau transmisii
multimedia (transmisii simultane de voce, imagini și de date, asociate sau complementare informațional).
O rețea de comunicații prin radio se numește:
•fixă, dacă antena utilizatorului nu-și modifică poziția;
•portabilă, dacă antena utilizatorului se deplasează între două servicii de comunicație, dar rămâne
fixă în timpul comunicației;
•mobilă, dacă antena utilizatorului este în mișcare în timpul efectuării comunicației.
Utilizatorii mobili pot comunica între ei fie direct, fie prin stații intermediare (repetoare pasive,
stații de bază, stații de comutare). Dacă toate acestea sunt instalate pe sol rețeaua se numește rețea mobilă
terestră. Dacă cel puțin una se află pe satelit rețeaua se numește rețea mobilă prin satelit. În funcție de
localizarea utilizatorilor rețelele de radiocomunicații mobile se clasifică în terestre, maritime, aeronautice
și spațiale. Rețelele de radiocomunicații mobile asigură utilizatorilor posibilitatea de a se deplasa liber în
zona de acoperire în timp ce comunică între ei. Scopul dezvoltării conceptului celular de organizare a unei
rețele de comunicații este acela de a avea posibilitatea creșterii, teoretic, nelimitate a capacității rețelei
folosind o bandă de frecvență dată. Deși principiul organizării celulare este întâlnit în literatura de
specialitate a rețelelor de comunicații încă din anii ‘50 ai secolului trecut, prima expunere și analiză
completă a acestuia au fost realizate în 1979 de către cercetătorii de la Bell Laboratories. Pe parcurs acest
concept a fost rafinat și completat cu noi idei, însă expunerea inițială este fundamentală și își păstrează
valabilitatea și astăzi, motiv pentru care o reluăm succint în continuare. La baza conceptului celular de
organizare a unei rețele de comunicații stau două principii: reutilizarea frecvenței și divizarea celulelor.
Primul asigură capacitatea de comunicație impusă folosind o bandă limitată de frecvență, iar al doilea
permite creșterea acestei capacități în funcție de creșterea traficului oferit, fără creșterea benzii de
frecvențe alocate rețelei

I.2 Despre trafic într-o rețea mobilă

Rețelele celulare de comunicații mobile sunt organizate ca rețele cu acces multiplu (trunking).
Aceasta înseamnă că un număr mare de utilizatori folosesc în comun un număr mult mai mic de canale de
comunicație. Rețelele cu acces multiplu își bazează funcționarea pe comportarea statistică a utilizatorilor,
în sensul că fiecare din ei inițiază comunicații la momente de timp aleatoriu distribuite și independent de
acțiunile celorlalți utilizatori; în plus, un utilizator petrece doar o fracțiune de timp pentru a comunica, cea
mai mare parte din timp el neaccesând resursele rețelei de comunicație. Din această cauză la un anumit
moment numai o mică parte din utilizatori sunt angajați în comunicație. O rețea cu acces multiplu asigură
o calitate dorită a comunicațiilor dacă are suficiente canale pentru a susține în fiecare moment
marea majoritate a comunicațiilor solicitate de utilizatorii ei. Dacă la primirea unui apel de comunicație
toate canalele rețelei sunt ocupate, comunicația nu se poate desfășura și cererea este respinsă. Se spune că
apelul este blocat. Calitatea comunicațiilor (QoS - Quality of Service) într-o rețea cu acces multiplu este
apreciată, în principal, prin numărul de apeluri blocate raportat la numărul total de apeluri lansate într-o
perioadă de timp, raport denumit probabilitate de blocare deoarece este un parametru cu evoluție
aleatoare în timp. Dacă rețeaua are posibilitatea de a memora apelurile neservite și de a le oferi canale în
momentul în care se eliberează unul din ele, atunci QoS este apreciată prin timpul mediu de așteptare a
apelurilor.
Intensitatea traficului realizat pe un canal de comunicație este raportul dintre timpul în care
canalul a fost ocupat și timpul total de observare. Perioada de observare poate fi minutul, ora, o perioadă a
zilei, ziua întreagă etc. Intensitatea traficului este o mărime adimensională. Totuși ei îi este asociată o
unitate de măsură − Erlang − în cinstea savantului danez cu acest nume ce a elaborat prima teorie privind
traficul în rețelele cu acces multiplu. O intensitate a traficului realizat de 1 Erlang înseamnă un canal
ocupat permanent pe perioada de observare. Dacă, de exemplu, un canal este ocupat în medie 15 minute
în fiecare oră, atunci traficul realizat de acest canal are intensitatea de 0,25 Erlangi, iar dacă este ocupat în
medie 12 ore pe zi, atunci intensitatea traficului este de 0,5 Erlangi.
Traficul maxim realizabil de o rețea celulară este egal cu produsul dintre numărul total de canale și
numărul de cluster-e definite pe aria rețelei. Abstracție făcând de nivelul inacceptabil de mare al
interferenței în rețea atunci când toate canalele sunt ocupate, această valoare maximă nu se poate atinge
nici principial, deoarece ar presupune o ordonare perfectă a comunicațiilor pe fiecare canal și în fiecare
celulă, astfel încât să nu se suprapună în timp, dar nici să existe pauze între ele. În realitate apelurile de
comunicații sosesc aleatoriu și durata comunicațiilor este, de asemenea, aleatorie. În perioadele de timp
cu trafic de intensitate mică există intervale de timp în care multe din canalele rețelei sunt libere, iar în
perioadele de timp cu trafic de intensitate mare unele apeluri sunt blocate din cauză că nu există canale
libere. Traficul realizat de o rețea este, deci, totdeauna mai mic decât traficul oferit de utilizatori.
Proiectarea unei rețele de comunicații se realizează cu obiectivul ca probabilitatea de blocare a apelurilor
în ora cea mai ocupată să nu depășească un prag prestabilit (de exemplu, 2% sau 1%). În rețelele fără
memorie în care apelurile blocate sunt eliminate probabilitatea de blocare este dată de formula Erlang B:

unde A este intensitatea traficului oferit în rețea, iar M este numărul total de canale aflate la dispoziția
rețelei. Dacă probabilitatea de blocare a apelurilor este o măsură a calității comunicațiilor într-o rețea,
atunci formula Erlang B poate fi folosită pentru analiza acesteia. Când se cunoaște intensitatea traficului
oferit și numărul de canale pe care rețeaua le are la dispoziție, atunci formula Erlang B permite calcularea
probabilității de blocare.
 Capitolul II Implementare temei de proiectare

Pentru realizarea acestui proiect ne propunem să realizăm un script în Matlab, care să permită utilizarea
formulei B a lui Erlang pentru calcularea unor caracteristici dintr-o rețea unicelulară.

a) Calcularea probabilității de blocare pentru o intensitate de trafic dată și număr de canale

cunoscut;
b) Calcularea numărului de canale necesar pentru o intensitate de trafic dată și o probabilitate de
blocare maximă impusă;
c) Calcularea intensității maxime de trafic ce poate fi preluată de o rețea, cu un număr de canale
cunoscut și pentru o probabilitate de blocare maximă impusă;

Limite:

 Număr de canale: 1 – 256

 Probabilitate de blocare: 0,01% - 2 %
 Intensitate de trafic: 0,001 – 100 Erlang

Script realizat (fără interfață grafică și cu date introduse de la consolă):

clear;
clc;
close all;

Calcularea Probabilității de blocare, în funcție de numărul de canale și intensitatea de trafic.

%introduceti numarul de canale m:

fprintf('Introduceti numarul de canale:\n');
m=input('m=');
while (m<1 || m>256 || floor(m)~=m)
fprintf('Numarul de canale trebuie sa fie intreg, m>=1 si m<=256:\n');
m=input('m=');
end
%introduceti intensitate de trafic
fprintf('Introduceti valoarea intensitatii de trafic:\n');
a=input('a=');
while (a<0.001 || a>100 )
fprintf('Introduceti valorea intensitatii de trafic, a>=0.001 si
a<=100:\n');
a=input('A=');
end
Calcularea numărătorului din formula B a lui Erlang
x=power(a,m);
y=factorial(m);
z=x/y;
mm=m;
aa=a;
Calcularea numitorului din formula B a lui Erlang
syms k a m;
kfac=sym('k!');
f=symsum(power(aa,k)/subs(kfac,k,k),k,0,mm);
Pb = z/f;
Pb = double(z/f);

Afișare rezultate
fprintf('\a Probabilitatea de blocare pentru %4.0f numar de canale \n
si %4.0f intensitate de trafic este%4.4f %% \r',mm,aa,Pb*100);

fprintf('\n \n \n');

Calcularea numărului canale, în funcție de probabilitatea de blocare și intensitatea de trafic.

%introduceti intensitate de trafic

fprintf('Introduceti valoarea intensitatii de trafic:\n');

a=input('a=');
while (a<0.001 | a>100 )
fprintf('Introduceti valorea intensitatii de trafic, a>=0.001 si
a<=100:\n');
a=input('A=');
end

%introduceti probabilitatea de blocare dorita

fprintf('Introduceti valoarea prbabilitatii de blocare (intre 0.0001 si
0.02) :\n');
p=input('p=');
while (p<0.0001 | p>0.02 )
fprintf('Introduceti valorea prbabilitatii de blocare, p>=0.01% si
p<=2%:\n');
p=input('p=');
end

Generarea unei matrici Pb cu probabilități de blocare pentru un număr finit de elemente. Este necesar
acest lucru pentru a limita durata calculelor. În acest caz am generat o matrice de dimensiuni
30X30=900 de elemente. Vom efectua o căutări repetate în această matrice pentru a identifica
numărul de canale.
A=[0.0:1.0:30];

m=[1:1:30];

for i=1:length(A)
for j=1:length(m)
Pb(i,j)=0;
end;
end;
Pentru ușurința implementării soluției, am folosit funcția erlangb(N,A)cu dezavantajul introducerii
unor erori de rotunjire.
for i=1:length(A)
for j=1:length(m)
Pb(i,j)=erlangb(m(j),A(i));
end;
end;

%100.^

rand=1;

for (i=1:length(A) )
if (a==A(rand))
pozi=rand;
else rand=rand+1;
end;
end;

pp=p*100;
pp=floor(pp);
for (j=1:length(m))
comp1=(Pb(pozi,j)*100);
comp1=floor(comp1);
if (comp1==pp)
pozj=j;
end;
end;

fprintf('\a Pentru %4.0f [Erlangi] intensitate de trafic \n si probabilitate

de blocare %4.4f \n numarul de canale necesar este %4.0f\r',a,p,pozj);

Calcularea intensității maxime de trafic ce se poate obține, în funcție de probabilitatea de blocare și

număr de canale cunoscut.

%introduceti numar de canale

fprintf('Introduceti numar de canale :\n');
N=input('N=');
while (N<1 | N>256 )
fprintf('Introduceti numar de canale):\n');
N=input('N=');
end

%introduceti probabilitatea de blocare dorita

fprintf('Introduceti valoarea prbabilitatii de blocare (intre 0.0001 si
0.02) :\n');
B=input('B=');
while (B<0.0001 | B>0.02 )
fprintf('Introduceti valorea prbabilitatii de blocare, p>=0.01% si
p<=2%:\n');
B=input('B=');
end
Și în acest caz am generat o matrice Pb de probabilități de blocare, dar diferită pentru fiecare număr
de canal introdus, de dimensiune 30XN. Acest număr poate să difere, dar l-am ales 30 pentru ușurință
și rapiditatea calculelor ce se efectuează. Efectuăm căutări succesive și comparăm probabilitatea de
blocare introdusă de la tastatură cu probabilitatea de blocare generată de funcția erlangb(N,A).
A=[0.0:1.0:30];
m=[1:1:N];

for i=1:length(A)
for j=1:length(m)
Pb(i,j)=0;
end;
end;

for i=1:length(A)
for j=1:length(m)
Pb(i,j)=erlangb(m(j),A(i));
end;
end;

pozji=0;
pp2=B*100;
pp2=floor(pp);
for (i=1:length(A))
comp2=(erlangb(N,A(i))*100);
comp2=floor(comp2);
if (comp2==pp2)
pozji=i;
end;
end;

fprintf('\a Pentru %4.0f canale si probabilitate de blocare %4.4f \n

intensitatea maxima este %4.0f\r',N,B,pozji-1);
Pentru a realiza o interfață grafică prietenoasă am făcut apel la funcția GUIDE și am realizat 3 interfețe
grafice pentru fiecare subpunct al temei noastre de proiectare.
Realizarea primei interfețe grafice

function varargout = final_a(varargin)

gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @final_a_OpeningFcn, ...
'gui_OutputFcn', @final_a_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end

Configurarea modui de realizare

function final_a_OpeningFcn(hObject, eventdata, handles, varargin)

handles.output = hObject;
guidata(hObject, handles);

function varargout = final_a_OutputFcn(hObject, eventdata, handles)

varargout{1} = handles.output;
Realizarea casetelor text pentru introducerea datelor și validarea datelor intruse (la introducere unor
date dinafara intervalului se va afișa un mesaj de eroare)
function intensitate_Callback(hObject, eventdata, handles)
a= str2double(get(hObject, 'String'));
if a<0.001 || a>100
set(hObject, 'String', 0);
msgbox('Intensitatea trebuie sa fie cuprinsa intre 0.001 si
100','EROARE!!','error');
end
handles.a = a;

Realizarea casetelor text pentru introducerea datelor și validarea datelor intruse (la introducere unor
date dinafara intervalului se va afișa un mesaj de eroare)

function intensitate_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function canale_Callback(hObject, eventdata, handles)

m= str2double(get(hObject, 'String'));
if m<1 || m>256 || floor(m)~=m
set(hObject, 'String', 0);
msgbox('Intensitatea trebuie sa fie cuprinsa intre 1 si 256 si numar
intreg','EROARE!!','error');
end
handles.m = m;

function canale_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

Realizarea calculului pentru afișarea valorii obținute

function rezultat_Callback(hObject, eventdata, handles)
a=str2double(get(handles.intensitate,'String'));
m=str2double(get(handles.canale,'String'));
x=power(a,m);
y=factorial(m);
z=x/y;
mm=m;
aa=a;
syms k a m;
kfac=sym('k!');
f=symsum(power(aa,k)/subs(kfac,k,k),k,0,mm);
Pb = z/f;
Pb = double(z/f);
Pb100=Pb*100;
set(handles.rezultat_de_afisat,'String',Pb100);
set(handles.rezultat100,'String',Pb100/100);
guidata(hObject,handles);

Am preferat să afișăm rezultatul în cele două forme (procentual și zecimal) pentru ca mai târziu să
putem utiliza rezultatul zecimal.
function rezultat_de_afisat_Callback(hObject, eventdata, handles)
set(handles.rezultat_de_afisat_Callback,'String',handles.rezultat_Callback);

function rezultat_de_afisat_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function rezultat100_CreateFcn(hObject, eventdata, handles)

function varargout = final_b(varargin)

gui_Singleton = 1;
gui_State = struct('gui_Name',
'gui_Singleton',
'gui_OpeningFcn',
'gui_OutputFcn',
'gui_LayoutFcn',
'gui_Callback',
mfilename, ...
gui_Singleton, ...
@final_b_OpeningFcn, ...
@final_b_OutputFcn, ...
[] , ...
[]);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end

function final_b_OpeningFcn(hObject, eventdata, handles, varargin)

handles.output = hObject;
guidata(hObject, handles);

function varargout = final_b_OutputFcn(hObject, eventdata, handles)

varargout{1} = handles.output;

function uitable1_CellEditCallback(hObject, eventdata, handles)

function slider1_Callback(hObject, eventdata, handles)

function slider1_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor',[.9 .9 .9]);
end

function trafic_Callback(hObject, eventdata, handles)

a= str2double(get(hObject, 'String'));
if a<0.001 || a>100
set(hObject, 'String', 0);
msgbox('Intensitatea trebuie sa fie cuprinsa intre 0.001 si
100','EROARE!!','error');
end
handles.a = a;

function trafic_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function probabilitate_Callback(hObject, eventdata, handles)

p= str2double(get(hObject, 'String'));
if p<0.0001 || p>0.02
set(hObject, 'String', 0);
msgbox('Probabilitatea trebuie sa fie cuprinsa intre 0.0001 si
0.02','EROARE!!','error');
end
handles.p = p;

function probabilitate_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
 set(hObject,'BackgroundColor','white');
end

function pushbutton1_Callback(hObject, eventdata, handles)

a=str2double(get(handles.trafic,'String'));
p=str2double(get(handles.probabilitate,'String'));
A=[0.0:1.0:30];
m=[1:1:30];
for i=1:length(A)
for j=1:length(m)
Pb(i,j)=0;
end;
end;

for i=1:length(A)
for j=1:length(m)
Pb(i,j)=erlangb(m(j),A(i));
end;
end;

rand=1;

for (i=1:length(A) )
if (a==A(rand))
pozi=rand;
else rand=rand+1;
end;
end;

pp=p*100;
pp=floor(pp);
pozj1=0;
for (j=1:length(m))
comp1=(Pb(pozi,j)*100);
comp1=floor(comp1);
if (comp1==pp)
pozj=j;
end;
end;
set(handles.rezultat,'String',pozj);

function rezultat_Callback(hObject, eventdata, handles)

function rezultat_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function valori_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function edit4_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function varargout = final_c(varargin)

gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @final_c_OpeningFcn, ...
'gui_OutputFcn', @final_c_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end

function final_c_OpeningFcn(hObject, eventdata, handles, varargin)

handles.output = hObject;
guidata(hObject, handles);

function varargout = final_c_OutputFcn(hObject, eventdata, handles)

varargout{1} = handles.output;

function canale_Callback(hObject, eventdata, handles)

N = str2double(get(hObject, 'String'));
if N<1 || N>256
set(hObject, 'String', 0);
msgbox('Numar de canale incorect (N<1 || N>256)','EROARE!!','error');
end
handles.N = N;

function canale_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function probabilitate_Callback(hObject, eventdata, handles)

B = str2double(get(hObject, 'String'));
if B <0.01 || B>2
set(hObject, 'String', 0);
msgbox('Probabilitatea trebuie sa fie cuprinsa intre 0.01% si
2%','EROARE!!','error');
end
handles.B = B;

function probabilitate_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function pushbutton1_Callback(hObject, eventdata, handles)

N=str2double(get(handles.canale,'String'));
B=str2double(get(handles.probabilitate,'String'));
A=[0.0:1.0:30];

m=[1:1:N];

for i=1:length(A)
for j=1:length(m)
Pb(i,j)=0;
end;
end;

for i=1:length(A)
for j=1:length(m)
Pb(i,j)=erlangb(m(j),A(i));
end;
end;
pozji=0;
pp2=B*100;
pp2=floor(pp2);
for (i=1:length(A))
comp2=(erlangb(N,A(i))*100);
comp2=floor(comp2);
if (comp2==pp2)
pozji=i;
end;
end;
pozji=pozji-1;
set(handles.edit6,'String',pozji);

function edit6_Callback(hObject, eventdata, handles)

function edit6_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
Capitolul III Concluzii

În acest proiect realizat un script în Matlab care să calculeze probabilitatea de blocare a unui sistem
unicelular, pentru o intensitate de trafic dată și un număr de canale dat. Astfel folosind formula amintită
în capitolul I (formula B a lui Erlang) am reușit să îndeplinim acest punct al proiectului nostru, dar cum în
inginerie nimic nu este perfect și pentru că noi folosim un sistem de calcul pentru realizarea scriptului
am introdus mici erori de aproximare în momentul efectuării calculelor. Erorile sunt de ordinul 0,001,
astfel pentru cazul tratat de noi, intensitate de trafic de 9 Erlang și 15 canale am obținut 1,9865%
probabilitate de eroare, iar funcția erlangb(15,9) returnează 1,99.

Credem că am realizat tema de proiect cu succes și cu erori minime ce intervin în aflarea rezultatelor
pentru toate cele trei cazuri.