UNIVERSIDAD AUTÓNOMA DE NUEVO LEÓN

FACULTAD DE INGENIERIA MECÁNICA Y

ELÉCTRICA

Sistemas de Comunicaciones Móviles

Programa “Antena Gráfica en Matlab”

Alumnos:
Gabriela Vázquez Ontiveros 1674057
Gustavo A. Rodriguez Perez 1525047
Celina Marisol Flores Juárez 1665811

Instructor: M.C. Alor Catarino Aguilar

Hora: N1
Dia: L,M,V
 INTRODUCCIÓN
La definición formal de una antena es un dispositivo que sirve para transmitir y recibir
ondas de radio. Convierte la onda guiada por la línea de transmisión (el cable o guía de
onda) en ondas electromagnéticas que se pueden transmitir por el espacio libre. En realidad
una antena es un trozo de material conductor al cual se le aplica una señal y esta es radiada
por el espacio libre. Las antenas deben de dotar a la onda radiada con un aspecto de
dirección. Es decir, deben acentuar un solo aspecto de dirección y anular o mermar los
demás. Esto es necesario ya que solo nos interesa radiar hacia una dirección determinada.
Esto se puede explicar con un ejemplo, hablando de las antenas que llevan los satélites.
Estas acentúan mucho la dirección hacia la tierra y anulan la de sentido contrario, puesto
que lo que se quiere es comunicarse con la tierra y no mandar señales hacia el espacio.

Las antenas también deben dotar a la onda radiada de una polarización. La polarización de
una onda es la figura geométrica descrita, al transcurrir el tiempo, por el extremo del vector
del campo eléctrico en un punto fijo del espacio en el plano perpendicular a la dirección de
propagación. Para todas las ondas, esa figura es normalmente una elipse, pero hay dos
casos particulares de interés y son cuando la figura trazada es un segmento, denominándose
linealmente polarizada, y cuando la figura trazada es un círculo, denominándose
circularmente polarizada.

Una onda está polarizada circularmente o elípticamente a derechas si un observador viese a

esa onda alejarse, y además viese girar al campo en el sentido de las agujas de un reloj.
Lógicamente, si lo viese girar en sentido contrario, sería una onda polarizada circularmente
o elípticamente a izquierdas. Son numerosas las sentencias firmes dictadas en contra de
comunidades de vecinos que trataron de impedir ese derecho. Sin embargo, la instalación
de la antena debe adecuarse a unos requisitos técnicos que es preciso cumplir para que
pueda ser aprobada por la Inspección de Telecomunicaciones y beneficiarse así de la
protección legal.

DESARROLLO
Un sistema de antena inteligente combina múltiples elementos de antena con una capacidad
de procesamiento de señales para optimizar su patrón de radiación y / o recepción
automáticamente en respuesta al entorno de la señal.
Las antenas han sido los componentes más descuidados de todos los sistemas de
comunicaciones personales. Sin embargo, la forma en que la energía se distribuye y se
recolecta en el espacio circundante tiene una profunda influencia en el uso eficiente del
espectro, el costo de establecer nuevas redes y la calidad del servicio proporcionado por
esas redes.
Para tener una idea intuitiva de cómo funciona un sistema de antena adaptable, es adecuado
hacer una analogía al respecto, podríamos cerrar los ojos y conversar con alguien mientras
se mueve por la habitación. Podemos notar que puede determinar su ubicación sin verlos
debido a lo siguiente:
 • Escuchamos las señales del altavoz a través de tus dos oídos, nuestros sensores
acústicos.
• La voz llega a cada oído en un momento diferente.
• Nuestro cerebro, un procesador de señales especializado, realiza una gran cantidad
de cálculos para correlacionar información y calcular la ubicación del hablante.
El hecho de usar múltiples antenas y procesamiento de señales innovador para servir a las
células de manera más inteligente ha existido durante muchos años. Incluso, ya se han
aplicado diversos grados de sistemas de antenas inteligentes relativamente costosos en los
sistemas de defensa. Hasta hace unos años, las barreras de costes han impedido su uso en
sistemas comerciales. La llegada de potentes procesadores de señales digitales (DSP) de
bajo costo, procesadores de propósito general (y ASIC), así como técnicas innovadoras de
procesamiento de señales (algoritmos) basadas en software, han hecho que las antenas
inteligentes sean prácticas para los sistemas de comunicaciones celulares. los sistemas de
antenas son inteligentes. Generalmente coubicado con una estación base, un sistema de
antena inteligente combina una red de antenas con una capacidad de procesamiento de
señales digitales para transmitir y recibir de una manera adaptativa y espacialmente
sensible. En otras palabras, dicho sistema puede cambiar automáticamente la
direccionalidad de sus patrones de radiación en respuesta a su entorno de señal. Esto puede
aumentar drásticamente las características de rendimiento (como la capacidad) de un
sistema inalámbrico.
Los términos comúnmente escuchados en la actualidad que abarcan varios aspectos de la
tecnología de un sistema de antenas inteligentes incluyen antenas inteligentes, arreglo en
fase, SDMA, procesamiento espacial, formación de haz digital, sistemas de antenas
adaptativas y otros. Sin embargo, los sistemas de antenas inteligentes se clasifican
habitualmente como sistemas de haz conmutado o de arreglos adaptativos.
Las siguientes son distinciones entre las dos categorías principales de antenas inteligentes
con respecto a las opciones en la estrategia de transmisión:
• switched beam: un número finito de patrones fijos predefinidos o estrategias de
combinación (sectores).
• adaptive array: un número infinito de patrones (basados en escenarios) que se
ajustan en tiempo real.
Los sistemas de antenas de haz conmutado forman múltiples haces fijos con mayor
sensibilidad en direcciones particulares. Estos sistemas de antenas detectan la intensidad de
la señal, eligen entre varios haces fijos predeterminados y cambian de un haz a otro a
medida que el móvil se mueve por el sector.
En lugar de dar forma al patrón de antena direccional con las propiedades metálicas y el
diseño físico de un solo elemento (como una antena sectorizada), los sistemas de haz
conmutado combinan las salidas de múltiples antenas de tal manera que forman haces
finamente sectorizados (direccionales) con más espacio. Selectividad que se puede lograr
con enfoques convencionales de un solo elemento.
 Fig. 1 Patrón de radiación de antenas Crosspolar

Para el desarrollo de nuestro proyecto usamos el programa MATLAB

¿Qué es MATLAB?

MATLAB, el lenguaje de cálculo técnico desarrollado por MathWorks, es un

entorno de programación para el desarrollo de algoritmos, análisis de datos,
visualización y cálculo numérico. Simulink es un entorno gráfico para simulación y
diseño basado en modelos de sistemas dinámicos multidominio e integrados.

Asimismo, MathWorks pone a su disposición más de ochenta productos adicionales

para tareas especializadas como el análisis de datos y el procesamiento de imágenes.
Entre sus prestaciones básicas se hallan la manipulación de matrices, la representación de
datos y funciones, la implementación de algoritmos, la creación de interfaces de usuario
(GUI) y la comunicación con programas en otros lenguajes y con otros
dispositivos hardware. El paquete MATLAB dispone de dos herramientas adicionales que
expanden sus prestaciones, a saber, Simulink (plataforma de simulación multidominio)
y GUIDE (editor de interfaces de usuario - GUI). Además, se pueden ampliar las
capacidades de MATLAB con las cajas de herramientas (toolboxes); y las de Simulink con
los paquetes de bloques (blocksets).
 Fig. 2 Ejemplo de un arreglo de antena en MATLAB

DESARROLLO DEL PROGRAMA

Para crear el programa abrimos el programa , menú desplegable , damos click en “New” ,
luego en opción “App” , luego vamos a la opción GUIDE , se desplegara una ventana
donde daremos click en “Create New GUI” luego en la opción “Blank GUI” , aquí
comenzaremos el diseño de nuestra interfaz.

Fig. 3 Ventana principal de Matlab

 Fig 4. Ventana de selección GUI
Una vez seleccionado el modo GUI aparecerá una ventana cuadriculada color gris donde se
comenzarán a colocar los botones en la interfaz dependiendo de los que usaremos para
nuestro proyecto.

Fig. 5 Ventana GUI

Ya que se insertan los botones necesarios y las ventanas de imágenes que se van a
necesitar , presionamos la flecha verde para guardar la configuración , con la cual se creara
un código , la interfaz da como resultado:
 Fig. 6 Interfaz de MATLAB
Como se mencionó arriba en el 3er paso , al guardar la interfaz se crea un código
automáticamente , en donde se muestran los botones que se crearon en la misma interfaz

Después comenzamos a desarrollar todo el programa , se agregan líneas por ejemplo el

pushbutton “Calcula”, asignado para calcular las secciones en donde se graficaran los
lobulos y mostrarlo en el axes1. Se recaban los valores de los distintos ángulos con el
comando:
¿ eval(get (handles . angulo ,' string '));
Se utiliza la palabra ángulo, el cual se refiere al primer usuario, es necesario realizarlo para
todos los demás usuarios, se agregar también un condicional if que delimite los ángulos a
los preestablecidos entre -360° y 360°, también se limita el valor del número de elementos
con su condicional correspondiente que deje el número de elementos entre 4 y 24. Si un
criterio no se cumple, se despliega una ventana de advertencia.
Se asigna un nuevo nombre (angle, angle2, angle3, angle4, angle5), de acuerdo con el
número del usuario y N para el número de elementos.
Esta parte del código se encarga de crear el patrón de radiación, con el comando:
m= polar ((th ), AF 2 ,' b ' )

Este comando será la base de la programación, formará el patrón de radiación azul, el cual
actúa de manera secuencial mostrándose y borrándose, haciendo parecer que el patrón se
mueve a lo largo de la carta polar.
Seguimos con el código para el primer usuario (angle), utilizando las condicionales if, la
primer condición es que si el ángulo es igual a 0, se guarda la variable “a” que es el patrón
de radiación para el primer usuario y se grafica en el ángulo 0. Si el ángulo es mayor a 0,
entonces el patrón se moverá en dirección positiva a su ángulo, este patrón será azul y se
moverá grado por grado, una vez llegado a su objetivo se desplegará un patrón con nombre
de la variable “a”. Se realiza lo mismo para el lado negativo, pero mostrando el movimiento
en dirección en favor de las manecillas del reloj y así sucesivamente para todos los demás
usuarios.
El uso del comando “pause”, ayuda a realizar un retardo entre la gráfica de cada patrón de
radiación azul, el cual ejemplifica el movimiento del patrón. Un punto para tomar en cuenta
es el comando “delete(m)”, recordemos que m es la variable que sirve para mover el patrón
al mostrarla y borrarla, de modo que primero se gráfica, después se realiza el retardo y
después se borra, de esta manera el patrón azul se mueve y llegando al objetivo, la variable
a, muestra el patrón en el ángulo indicado para el primer usuario.
Lo siguiente es el código para el segundo usuario, la primera condición es si el ángulo es
mayor a cero, es mayor que el ángulo del primer usuario y el ángulo 1 es menor que cero.
Lo importante de dejar en claro los condicionales es porque el resto del programa es
exactamente el mismo pero variando el número de ángulo y creando nuevas variables que
guarden los valores de ángulos anteriores.

Dado por hecho esto , el programa queda de la siguiente

manera:

function varargout = moviles(varargin)

% MOVILES MATLAB code for moviles.fig
% MOVILES, by itself, creates a new MOVILES or raises the existing
% singleton*.
%
% H = MOVILES returns the handle to a new MOVILES or the handle to
% the existing singleton*.
%
% MOVILES('CALLBACK',hObject,eventData,handles,...) calls the local
% function named CALLBACK in MOVILES.M with the given input
arguments.
%
% MOVILES('Property','Value',...) creates a new MOVILES or raises
the
% existing singleton*. Starting from the left, property value pairs
are
% applied to the GUI before moviles_OpeningFcn gets called. An
% unrecognized property name or invalid value makes property
application
% stop. All inputs are passed to moviles_OpeningFcn via varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only
one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES

% angulo the above text to modify the response to help moviles

% Last Modified by GUIDE v2.5 28-May-2021 00:15:47

% Begin initialization code - DO NOT angulo

gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @moviles_OpeningFcn, ...
'gui_OutputFcn', @moviles_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
% End initialization code - DO NOT angulo

% --- Executes just before moviles is made visible.

function moviles_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to moviles (see VARARGIN)

% Choose default command line output for moviles

handles.output = hObject;

% Update handles structure

guidata(hObject, handles);

% UIWAIT makes moviles wait for user response (see UIRESUME)

% uiwait(handles.figure1);
if strcmp(get(hObject,'Visible'),'off')
 set(0,'defaultfigurecolor','w')
N=12;
d=.5;
th=-pi:.01:pi;
ang=th*180/pi;
AF2=abs(sin(N*pi*d*sin(th/2))./(N*sin(pi*d*sin(th/2))));

%Resuelve el error en la carta polar

polar((th),AF2,'r');
view(0,90)
end

% --- Outputs from this function are returned to the command line.
function varargout = smart_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure

varargout{1} = handles.output;

function angulo_Callback(hObject, eventdata, handles)

% hObject handle to angulo (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of angulo as text

% str2double(get(hObject,'String')) returns contents of angulo as
a double

% --- Executes during object creation, after setting all properties.

function angulo_CreateFcn(hObject, eventdata, handles)
% hObject handle to angulo (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function angulo2_Callback(hObject, eventdata, handles)

% hObject handle to angulo2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of angulo2 as text

% str2double(get(hObject,'String')) returns contents of angulo2 as
a double
% --- Executes during object creation, after setting all properties.
function angulo2_CreateFcn(hObject, eventdata, handles)
% hObject handle to angulo2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function angulo3_Callback(hObject, eventdata, handles)

% hObject handle to angulo3 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of angulo3 as text

% str2double(get(hObject,'String')) returns contents of angulo3 as
a double

% --- Executes during object creation, after setting all properties.

function angulo3_CreateFcn(hObject, eventdata, handles)
% hObject handle to angulo3 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function angulo4_Callback(hObject, eventdata, handles)

% hObject handle to angulo4 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of angulo4 as text

% str2double(get(hObject,'String')) returns contents of angulo4 as
a double

% --- Executes during object creation, after setting all properties.

function angulo4_CreateFcn(hObject, eventdata, handles)
% hObject handle to angulo4 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function angulo5_Callback(hObject, eventdata, handles)

% hObject handle to angulo5 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of angulo5 as text

% str2double(get(hObject,'String')) returns contents of angulo5 as
a double

% --- Executes during object creation, after setting all properties.

function angulo5_CreateFcn(hObject, eventdata, handles)
% hObject handle to angulo5 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

function element_Callback(hObject, eventdata, handles)

% hObject handle to element (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)

% Hints: get(hObject,'String') returns contents of element as text

% str2double(get(hObject,'String')) returns contents of element as
a double

% --- Executes during object creation, after setting all properties.

function element_CreateFcn(hObject, eventdata, handles)
% hObject handle to element (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% Hint: edit controls usually have a white background on Windows.

% See ISPC and COMPUTER.
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

% --- Executes on button press in calcula (para el botón calcular).

function calcula_Callback(hObject, eventdata, handles)
% hObject handle to calcula (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
angle=eval(get(handles.angulo,'string'));
if angle < -360
errordlg('El valor debe ser mayor a -360 y menor a 360','Primer
usuario');
elseif angle > 360
errordlg('El valor debe ser mayor a -360 y menor a 360','Primer
usuario');
end

angle2=eval(get(handles.angulo2,'string'));
if angle2 < -360
errordlg('El valor debe ser mayor a -360 y menor a 360','Segundo
usuario');
elseif angle2 > 360
errordlg('El valor debe ser mayor a -360 y menor a 360','Segundo
usuario');
end

angle3=eval(get(handles.angulo3,'string'));
if angle3 < -360
errordlg('El valor debe ser mayor a -360 y menor a 360','Tercer
usuario');
elseif angle3 > 360
errordlg('El valor debe ser mayor a -360 y menor a 360','Tercer
usuario');
end

angle4=eval(get(handles.angulo4,'string'));
if angle4 < -360
errordlg('El valor debe ser mayor a -360 y menor a 360','Cuarto
usuario');
elseif angle4 > 360
errordlg('El valor debe ser mayor a -360 y menor a 360','Cuarto
usuario');
end

angle5=eval(get(handles.angulo5,'string'));
if angle5 < -360
errordlg('El valor debe ser mayor a -360 y menor a 360','Quinto
usuario');
elseif angle5 > 360
errordlg('El valor debe ser mayor a -360 y menor a 360','Quinto
usuario');
end

N=eval(get(handles.element,'string'));
if N < 4
errordlg('El valor debe estar entre 4 y 24','Núm de elementos');
elseif N > 24
errordlg('El valor debe estar entre 4 y 24','Núm de elementos');
end
d=.5;
th=-pi:.01:pi;
ang=th*180/pi;
AF2=abs(sin(N*pi*d*sin(th/2))./(N*sin(pi*d*sin(th/2))));

%Resuelve el error en la carta polar

h=0;
x=(6.304)/360;
alo=abs(angle);
m=polar((th),AF2,'r');
view(0,90)
hold on
if angle == 0
h=0;
a=polar((th),AF2,'r');
view(0,90)
end

if angle > 0
for c=1:(alo)
pause(0.005);
delete(m);
m=polar((th+(h)),AF2,'b');
view(0,90)
h=h+x;
end
delete(m);
pause(0.005);
a=polar((th+(h)),AF2,'r');
view(0,90)
end

if angle < 0
for c=1:(alo)
pause(0.005);
delete(m);
m=polar((th+(h)),AF2,'b');
view(0,90)
h=h-x;
end
delete(m);
pause(0.005);
a=polar((th+(h)),AF2,'r');
view(0,90)
end

%%%%%%%%%%%%%%%%%graficar angulos en la carta

if angle2 >= 0 && angle2 >= angle && angle <= 0
p=0;
c=0;
com2=abs(angle2);
com2=com2+alo;
for c=1:(com2)
e=h+p;
m=polar((th+(e)),AF2,'b');
view(0,90)
 pause(0.005);
delete(m);
p=p+x;
end
delete(m);
pause(0.005);
e=h+p;
b=polar((th+(e)),AF2,'g');
view(0,90)
end

if angle2 >= 0 && angle2 >= angle && angle >= 0

p=0;
c=0;
com2=abs(angle2);
com2=com2-alo;
for c=1:(com2)
e=h+p;
m=polar((th+(e)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
p=p+x;
end
delete(m);
pause(0.005);
e=h+p;
b=polar((th+(e)),AF2,'g');
view(0,90)
end

if angle2 >= 0 && angle2 <= angle && angle >= 0

p=0;
c=0;
com2=abs(angle2);
com2=alo-com2;
for c=1:(com2)
e=h-p;
m=polar((th+(e)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
p=p+x;
end
delete(m);
pause(0.005);
e=h-p;
b=polar((th+(e)),AF2,'g');
view(0,90)
end

if angle2 <= 0 && angle >=0

p=0;
c=0;
com2=abs(angle2);
com2=alo+com2;
for c=1:(com2)
 e=h-p;
m=polar((th+(e)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
p=p+x;
end
delete(m);
pause(0.005);
e=h-p;
b=polar((th+(e)),AF2,'g');
view(0,90)
end

if angle2 <= 0 && angle <=0 && angle>=angle2

p=0;
c=0;
com2=abs(angle2);
com2=com2-alo;
for c=1:(com2)
e=h-p;
m=polar((th+(e)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
p=p+x;
end
delete(m);
pause(0.005);
e=h-p;
b=polar((th+(e)),AF2,'g');
view(0,90)
end

if angle2 <= 0 && angle <=0 && angle<=angle2

p=0;
c=0;
com2=abs(angle2);
com2=alo-com2;
for c=1:(com2)
e=h+p;
m=polar((th+(e)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
p=p+x;
end
delete(m);
pause(0.005);
e=h+p;
b=polar((th+(e)),AF2,'g');
view(0,90)
end

%%%%%%%%%
if angle3 >= 0 && angle3 >= angle2 && angle2 <= 0
k=0;
c=0;
com2=abs(angle2);
com3=abs(angle3);
com3=com3+com2;
for c=1:(com3)
j=k+e;
m=polar((th+(j)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
k=k+x;
end
delete(m);
pause(0.005);
j=k+e;
d=polar((th+(j)),AF2,'c');
view(0,90)
end

if angle3 >= 0 && angle3 >= angle2 && angle2 >= 0

k=0;
c=0;
com2=abs(angle2);
com3=abs(angle3);
com3=com3-com2;
for c=1:(com3)
j=k+e;
m=polar((th+(j)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
k=k+x;
end
delete(m);
pause(0.005);
j=k+e;
d=polar((th+(j)),AF2,'c');
view(0,90)
end

if angle3 >= 0 && angle3 <= angle2 && angle2 >= 0

k=0;
c=0;
com2=abs(angle2);
com3=abs(angle3);
com3=com2-com3;
for c=1:(com3)
j=e-k;
m=polar((th+(j)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
k=k+x;
end
delete(m);
pause(0.005);
j=e-k;
d=polar((th+(j)),AF2,'c');
view(0,90)
end

if angle3 <= 0 && angle2 >=0

k=0;
c=0;
com3=abs(angle3);
com2=abs(angle2);
com3=com2+com3;
for c=1:(com3)
j=e-k;
m=polar((th+(j)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
k=k+x;
end
delete(m);
pause(0.005);
j=e-k;
d=polar((th+(j)),AF2,'c');
view(0,90)
end

if angle3 <= 0 && angle2 <=0 && angle2>=angle3

k=0;
c=0;
com3=abs(angle3);
com2=abs(angle2);
com3=com3-com2;
for c=1:(com3)
j=e-k;
m=polar((th+(j)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
k=k+x;
end
delete(m);
pause(0.005);
j=e-k;
d=polar((th+(j)),AF2,'c');
view(0,90)
end

if angle3 <= 0 && angle2 <= 0 && angle2 <= angle3

k=0;
c=0;
com3=abs(angle3);
com2=abs(angle2);
com3=com2-com3;
for c=1:(com3)
j=e+k;
m=polar((th+(j)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
k=k+x;
end
delete(m);
pause(0.005);
j=e+k;
d=polar((th+(j)),AF2,'c');
view(0,90)
end

%%%%%%%%%
if angle4 >= 0 && angle4 >= angle3 && angle3 <= 0
w=0;
c=0;
com4=abs(angle4);
com3=abs(angle3);
com4=com4+com3;
for c=1:(com4)
y=w+j;
m=polar((th+(y)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
w=w+x;
end
delete(m);
pause(0.005);
y=w+j;
t=polar((th+(y)),AF2,'m');
view(0,90)
end

if angle4 >= 0 && angle4 >= angle3 && angle3 >= 0

w=0;
c=0;
com4=abs(angle4);
com3=abs(angle3);
com4=com4-com3;
for c=1:(com4)
y=w+j;
m=polar((th+(y)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
w=w+x;
end
delete(m);
pause(0.005);
y=w+j;
t=polar((th+(y)),AF2,'m');
view(0,90)
end

if angle4 >= 0 && angle4 <= angle3 && angle3 >= 0

w=0;
c=0;
com4=abs(angle4);
com3=abs(angle3);
com4=com3-com4;
for c=1:(com4)
y=j-w;
m=polar((th+(y)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
w=w+x;
end
delete(m);
pause(0.005);
y=j-w;
t=polar((th+(y)),AF2,'m');
view(0,90)
end

if angle4 <= 0 && angle3 >=0

w=0;
c=0;
com4=abs(angle4);
com3=abs(angle3);
com4=com3+com4;
for c=1:(com4)
y=j-w;
m=polar((th+(y)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
w=w+x;
end
delete(m);
pause(0.005);
y=j-w;
t=polar((th+(y)),AF2,'m');
view(0,90)
end

if angle4 <= 0 && angle3 <=0 && angle3 >= angle4

w=0;
c=0;
com4=abs(angle4);
com3=abs(angle3);
com4=com4-com3;
for c=1:(com4)
y=j-w;
m=polar((th+(y)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
w=w+x;
end
delete(m);
pause(0.005);
y=j-w;
t=polar((th+(y)),AF2,'m');
view(0,90)
end

if angle4 <= 0 && angle3 <=0 && angle3<=angle4

w=0;
c=0;
com4=abs(angle4);
com3=abs(angle3);
com4=com3-com4;
for c=1:(com4)
y=j+w;
m=polar((th+(y)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
w=w+x;
end
delete(m);
pause(0.005);
y=j+w;
t=polar((th+(y)),AF2,'m');
view(0,90)
end

%%%%%%%%%%
if angle5 >= 0 && angle5 >= angle4 && angle4 <= 0
i=0;
c=0;
com5=abs(angle5);
com4=abs(angle4);
com5=com5+com4;
for c=1:(com5)
z=i+y;
m=polar((th+(z)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
i=i+x;
end
delete(m);
pause(0.005);
z=i+y;
q=polar((th+(z)),AF2,'y');
view(0,90)
end

if angle5 >= 0 && angle5 >= angle4 && angle4 >= 0

i=0;
c=0;
com5=abs(angle5);
com4=abs(angle4);
com5=com5-com4;
for c=1:(com5)
z=i+y;
m=polar((th+(z)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
i=i+x;
end
delete(m);
pause(0.005);
z=i+y;
q=polar((th+(z)),AF2,'y');
view(0,90)
end

if angle5 >= 0 && angle5 <= angle4 && angle4 >= 0

i=0;
c=0;
com5=abs(angle5);
com4=abs(angle4);
com5=com4-com5;
for c=1:(com5)
z=y-i;
m=polar((th+(z)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
i=i+x;
end
delete(m);
pause(0.005);
z=y-i;
q=polar((th+(z)),AF2,'y');
view(0,90)
end

if angle5 <= 0 && angle4 >=0

i=0;
c=0;
com5=abs(angle5);
com4=abs(angle4);
com5=com4+com5;
for c=1:(com5)
z=y-i;
m=polar((th+(z)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
i=i+x;
end
delete(m);
pause(0.005);
z=y-i;
q=polar((th+(z)),AF2,'y');
view(0,90)
end

if angle5 <= 0 && angle4 <=0 && angle4 >= angle5

i=0;
c=0;
com5=abs(angle5);
com4=abs(angle4);
com5=com5-com4;
for c=1:(com5)
z=y-i;
m=polar((th+(z)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
i=i+x;
end
delete(m);
pause(0.005);
z=y-i;
q=polar((th+(z)),AF2,'y');
view(0,90)
end

if angle5 <= 0 && angle4 <=0 && angle4<=angle5

i=0;
c=0;
com5=abs(angle5);
com4=abs(angle4);
com5=com4-com5;
for c=1:(com5)
z=y+i;
m=polar((th+(z)),AF2,'b');
view(0,90)
pause(0.005);
delete(m);
i=i+x;
end
delete(m);
pause(0.005);
z=y+i;
q=polar((th+(z)),AF2,'y');
view(0,90)
end

% --- Executes during object creation, after setting all properties.

function axes1_CreateFcn(hObject, eventdata, handles)
% hObject handle to axes1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns
called

% --- Executes on button press in Salir (para salir de la interfaz).

function Salir_Callback(hObject, eventdata, handles)
% hObject handle to Salir (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
close(gcbf)

% --- Executes on button press in limpiar.

function limpiar_Callback(hObject, eventdata, handles)
% hObject handle to limpiar (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
ini=char(' ');
set(handles.angulo, 'String' , ini);
set(handles.angulo2, 'String' , ini);
set(handles.angulo3, 'String' , ini);
set(handles.angulo4, 'String' , ini);
set(handles.angulo5, 'String' , ini);
set(handles.element, 'String' , ini);
cla reset

RESULTADO FINAL EN INTERFAZ

 FIG 7 Imagen de interfaz final

FUNCIONAMIENTO

Fig. 8 y 9 Introducción de datos en usuarios

 Fig 9

Fig. 10 Introducción de datos a elementos

Fig. 11 Comienza a calcular los lóbulos

Fig. 12 limpia los lóbulos graficados

 CONCLUSIONES
Al terminar el proyecto , pudimos observar que hay miles de soluciones que se pueden
aplicar en diferentes áreas en los sistemas de antenas , pudimos encontrar una manera de
aplicar un problema real , y a reforzar el entendimiento de la programación en MATLAB ,
y que cualquier punto débil que podamos ver en algún lugar podemos transformarlo en una
solución y una oportunidad para desarrollar más nuestro aprendizaje.

REFERENCIAS
Aznar, Á. C., Robert, J. R., Casals, J. M. R., Roca, L. J., Boris, S. B., & Bataller, M. F.
(2004). Antenas. Univ. Politèc. de Catalunya.

Huidobro, J. M. (2013). Antenas de telecomunicaciones. Revista Digital de ACTA, 18.

Espinosa Díaz, P., & Villarroel González, C. (2007). Proposición y simulación de un algoritmo
adaptativo para sistemas de antenas inteligentes. Ingeniare. Revista chilena de ingeniería, 15(3),
344-350.

Ruiz Salazar, A. (2021). Análisis y diseño de antenas mediante Matlab.

Palonés Llopis, N. (2013). Desarrollo del entorno interactivo de un programa de análisis de antenas
empleando Matlab GUI (Doctoral dissertation).