DATOS INFORMATIVOS:

UNIVERSIDAD TÉCNICA DE AMBATO.

FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E
INDUSTRIAL
CARRERA DE INGENIERÍA EN
TELECOMUNICACIONES INFORME
DE LABORATORIO #1 DE
COMUNICACIÓN DIGITAL

NOMBRES :
✓ Cueva Toaquiza Henry Fernando
✓ Gallegos Gallegos Christopher Emmanuel
✓ Lopez Ricachi Jessica Lizbeth
✓ Morales Guanga Christian Andrés
✓ Manobanda Jimenez Kevin Andres
✓ Revelo Paredes Alex Marcelo
✓ Tualombo Nuñez Ricardo Feliciano
✓ Zamora Medina Jarod Vinicio

NIVEL : Séptimo “A”

FECHA : 22 de octubre del 2023
PROF. : Ing. Juan Pablo Pallo
TEMA : SERIE TRIGONOMETRICA DE FOURIER

I. INTRODUCCIÓN
La serie de Fourier trigonométrica es una herramienta matemática esencial que se
emplea para descomponer una señal periódica en una combinación de funciones
trigonométricas, como senos y cosenos, con diferentes frecuencias (denominadas
armónicas). Este enfoque se aplica ampliamente en el análisis de señales y la teoría de
la comunicación con el propósito de desglosar y reconstruir señales periódicas. La
premisa central de la serie de Fourier radica en la capacidad de representar cualquier
señal periódica como una suma ponderada de senos y cosenos con diversas frecuencias
y amplitudes.

La descomposición de una señal periódica en series de Fourier permite estudiar las

características de los componentes de frecuencia de una señal, lo que resulta
fundamental en el análisis de señales y la creación de nuevas señales, así como en
aplicaciones como el filtrado de señales. Esta técnica encuentra aplicaciones
 destacadas en diversos campos de la ciencia y la ingeniería.

II.OBJETIVOS

1. OBJETIVOS GENERALES

• Crear una interfaz en MATLAB que tenga la capacidad de calcular la serie

trigonométrica de Fourier y representar sus espectros.

2. OBJETIVOS ESPECÍFICOS
• Desarrollar una investigación sobre el análisis matemático y teórico sobre las
series trigonométricas de Fourier.
• Analizar los parámetros utilizados para la programación y diseño utilizado en
Matlab.
• Verificar el rendimiento del software mediante ejercicios previamente
realizados durante las lecciones.

III. RESUMEN
Este informe aborda la simulación de la Serie Trigonométrica de Fourier
utilizando la plataforma MATLAB. La Serie Trigonométrica de Fourier es una
herramienta matemática fundamental para descomponer señales periódicas en una
combinación de funciones trigonométricas, como senos y cosenos, con distintas
frecuencias.

Para el análisis de una señal cualquiera, seguiremos un orden en específico:

• Definir la señal periódica que se desea analizar, en términos de su frecuencia
y amplitud.
• Calcular los coeficientes de Fourier de la señal, utilizando las fórmulas de
Fourier correspondientes.
• Utilizar los coeficientes de Fourier para construir la serie trigonométrica de
Fourier de la señal.
• Como resultado podremos visualizar la señal original y su serie de Fourier en
un gráfico para analizar su comportamiento.

En la simulación, MATLAB se emplea como una poderosa herramienta para

llevar a cabo los cálculos necesarios en la descomposición de señales periódicas
en sus componentes de Fourier. Esto permite comprender y visualizar la
contribución de diferentes frecuencias a una señal periódica y su representación
 gráfica en términos de espectros.

En resumen, este informe proporciona una visión completa de la simulación de la

Serie Trigonométrica de Fourier en MATLAB, destacando su importancia
matemática y su aplicabilidad en el análisis de señales periódicas.
IV. ABSTRACT

This report addresses the simulation of the Fourier Trigonometric Series using the
MATLAB platform. The Fourier Trigonometric Series is a fundamental
mathematical tool for decomposing periodic signals into a combination of
trigonometric functions such as sines and cosines with different frequencies.
For the analysis of any given signal, we will follow a specific order:
• Define the periodic signal to be analyzed in terms of its frequency and
amplitude.
• Calculate the Fourier coefficients of the signal using the relevant Fourier
formulas.
• Utilize the Fourier coefficients to construct the Fourier trigonometric series of
the signal.
• As a result, we will be able to visualize the original signal and its Fourier series
in a graph to analyze its behavior.

In the simulation, MATLAB is used as a powerful tool to perform the necessary

calculations for breaking down periodic signals into their Fourier components.
This allows us to understand and visualize the contribution of different
frequencies to a periodic signal and its graphical representation in terms of spectra.
In summary, this report provides a comprehensive view of the simulation of the
Fourier Trigonometric Series in MATLAB, highlighting its mathematical
significance and its applicability in the analysis of periodic signals.

V. MARCO TEÓRICO

SERIE TRIGONOMÉTRICA DE FOURIER

La serie trigonométrica de Fourier es una herramienta matemática utilizada para

descomponer una señal periódica en una suma de funciones trigonométricas, como
senos y cosenos, de diferentes frecuencias y amplitudes. Fue desarrollada por el
matemático francés Jean Baptiste Joseph Fourier en el siglo XIX y ha encontrado
aplicaciones en una amplia variedad de campos, como la ingeniería eléctrica, la física,
las ciencias de la computación, la teoría de la comunicación, entre otros [1].

La serie de Fourier establece que cualquier señal periódica puede expresarse como
una combinación de una suma infinita de funciones seno y coseno con diferentes
frecuencias y amplitudes. La serie se define por medio de los coeficientes de Fourier,
que son valores que indican la amplitud y fase de cada componente frecuencia de la
señal. La serie de Fourier es importante porque permite analizar y sintetizar señales
periódicas de manera eficiente y efectiva. [1]

Además de la serie trigonométrica de Fourier, existen otras variantes de la serie de

Fourier, como la serie exponencial de Fourier y la serie de Fourier compleja, que
utilizan funciones exponenciales complejas en lugar de funciones trigonométricas. [1]

FORMULA:
La serie trigonométrica de Fourier es una suma infinita de funciones seno y coseno de
diferentes frecuencias y amplitudes. La fórmula general de la serie trigonométrica de
Fourier para una señal periódica f(t) con periodo T es:
∞
𝑎0
𝑓 (𝑡 ) = + ∑ 𝑎𝑛 cos(𝑛𝜔0 𝑡) + 𝑏𝑛 sin(𝑛𝜔0 𝑡)
2
𝑛=1

Donde:
• a0 es el coeficiente de Fourier de orden cero y representa el valor medio
de la función f(t) en un periodo T.
• an y bn son los coeficientes de Fourier de orden n y representan la amplitud
de las funciones coseno y seno, respectivamente, en un periodo T.
• ω0 = 2π/T es la frecuencia angular fundamental de la señal.
Los coeficientes de Fourier se calculan a partir de las siguientes fórmulas:
𝑇
2
𝑎𝑛 = ∫[𝑓(𝑡) cos(𝑛𝜔0 𝑡)𝑑𝑡]
𝑇
0
𝑇
2
𝑏𝑛 = ∫[𝑓(𝑡) sin(𝑛𝜔0 𝑡)𝑑𝑡]
𝑇
0

Donde la integral se toma en un periodo T de la señal.

Condiciones de simetría
Las condiciones de simetría son dos: par e impar.
Una función es par, siempre y cuando 𝑓 (𝑡) = −𝑓(𝑡), en este caso 𝑏𝑛 = 0 y su
serie de Fourier únicamente los términos coseno, es decir, el coeficiente 𝑎𝑛 se
obtiene un valor. [4]

𝑁
𝑎0 2𝜋
𝑓 (𝑡 ) = + ∑ [𝑎𝑛 cos(𝑛𝜔𝑡)] 𝜔=
2 𝑇
𝑛=1

Una función es impar, siempre y cuando 𝑓 (𝑡) = −𝑓(−𝑡), en este caso 𝑎𝑛 = 0 y

su serie de Fourier solo tendrá términos seno, es decir, el coeficiente 𝑏𝑛 es
diferente de cero.
𝑁
𝑎0 2𝜋
𝑓 (𝑡 ) = + ∑ [𝑏𝑛 sen(𝑛𝜔𝑡)] 𝜔=
2 𝑇
𝑛=1

Señales Periódicas
Señal continua en el tiempo x(t) es periódica si existe un valor distinto a cero T y
positivo, para el cual: [2]
𝑥 (𝑡 + 𝑛𝑇) = 𝑥 (𝑡) 𝑝𝑎𝑟𝑎 𝑡𝑜𝑑𝑜 𝑡; 𝑛 𝑒𝑛𝑡𝑒𝑟𝑜
1
Donde T es el periodo fundamental y = 𝑓 denominada como frecuencia
𝑇
2𝜋
fundamental. La frecuencia angular fundamental viene dada por 𝜔 = = 2𝜋𝑓
𝑇

La función o señal f(t), cumple con ciertas condiciones de Dirichlet:

Ilustración 1 Discontinuidades en el periodo T

1. Número finito de discontinuidades en T, discontinua en ese periodo.
2. No tiene asíntotas verticales, es decir, el valor medio en T es finito.
3. Número finito de máximos y mínimo en T. [3]
Las denominadas series trigonométrica de Fourier, entonces convergen a los
valores de f(t) en todos los puntos del intervalo [0, 𝑇], la representación está dada
por:

𝑎0 2𝜋𝑡 2𝜋(2)𝑡 2𝜋𝑁𝑡

𝑓 (𝑡 ) = + [𝑎1 cos ( ) + 𝑎2 cos ( ) + ⋯ + 𝑎𝑁 cos ( )]
2 𝑇 𝑇 𝑇
2𝜋𝑡 2𝜋(2)𝑡 2𝜋𝑁𝑡
+ [𝑏1 sen ( ) + 𝑏2 sen ( ) + ⋯ + 𝑏𝑁 sen ( )]
𝑇 𝑇 𝑇
𝑁
𝑎0 2𝜋𝑛𝑡 2𝜋𝑛𝑡
𝑓 (𝑡 ) = + ∑ [𝑎𝑛 cos ( ) + 𝑏𝑛 sen ( )]
2 𝑇 𝑇
𝑛=1

2𝜋
O en función de la frecuencia angular 𝜔 = ;
𝑇

𝑎0
𝑓 (𝑡 ) = + [𝑎1 cos(𝜔𝑡) + 𝑎2 cos(2𝜔𝑡) + ⋯ + 𝑎𝑁 cos(𝑁𝜔𝑡) ]
2
+ [𝑏1 sen(𝜔𝑡) + 𝑏2 sen(2𝜔𝑡) + ⋯ + 𝑏𝑁 sen(𝑁𝜔𝑡) ]
𝑁
𝑎0
𝑓 (𝑡 ) = + ∑[𝑎𝑛 cos(𝑛𝜔𝑡) + 𝑏𝑛 sen(𝑛𝜔𝑡) ]
2
𝑛=1

𝑃𝑎𝑟𝑎 (𝑡0 < 𝑡 < 𝑡0 − 𝑇)

Espectro de Fourier
El espectro de Fourier consta del cálculo de armónicos y su representación en el
espectro de frecuencias.
La representación de la serie de Fourier para una función 2p-perdiódica en forma
de armónicos es:
𝑁

𝑓 (𝑡) = 𝐴0 + ∑ [𝐴𝑛 sen(𝑛𝜔𝑡 + 𝜙𝑛 )]

𝑛=1

O a su vez, se puede expresar como:

𝑓 (𝑡) = 𝐴0 + ∑[𝐴𝑛 cos(𝑛𝜔𝑡 − 𝜑𝑛 )]

𝑛=1

Donde:
𝑎0 𝑎𝑛 𝑏𝑛
𝐴0 = ; 𝐴𝑛 = √𝑎𝑛2 + 𝑏𝑛2 ; 𝜙𝑛 = 𝑎𝑟𝑡𝑔 ; 𝜑𝑛 = 𝑎𝑟𝑐𝑡𝑔
2 𝑏𝑛 𝑎𝑛
Quedaría definida la función f(t) por infinitas funciones coseno y constante a los
denominados armónicos, empezando por n=1 el primer armónico la frecuencia
igual a la frecuencia fundamental y o demás de frecuencia superior.

Espectro de frecuencia: Denominada así a la gráfica compuesta por las

amplitudes 𝐴𝑛 , con respecto a la frecuencia 𝜔, múltiplos de la frecuencia
fundamental. [4]

Ilustración 2 Espectro de frecuencia.

𝐴𝑛 , con respecto a la frecuencia 𝜔 son las amplitudes, representadas como

impulsos unitarios a la frecuencia del armónico y su longitud depende de la
amplitud.
𝜑𝑛 , con respecto a la frecuencia 𝜔, es el espectro de fase.

Cada armónico es parte de la composición de la función periódica permitiendo un

análisis de la señal. Las señales desarrolladas en el laboratorio como: ondas
cuadradas y dientes de sierra principalmente, su espectro se representa con
impulsos que van decreciendo. Para ondas periódicas sin discontinuidades, su
espectro el decrecimiento de los armónicos es rápido por lo cual se escogería
pocos armónicos para su representación.
 Ilustración 3 Señal cuadrada y su espectro de frecuencia.

VI. LISTADO DE EQUIPOS Y MATERIALES

• Computadora
• Software Matlab
• Internet
• Cuaderno
• Lápiz
• Apuntes de clase

VII. LABORATORIO

DESARROLLO:

1. Creación de a interfaz gráfica, en la cual vamos a poder escoger entre la

serie de Fourier trigonométrica y la exponencial:

Ilustración 4 Interfaz de usuario del programa en Matlab.

2. Obtención de datos ingresados mediante teclado
 Ilustración 5 Parámetros de configuración del programa en Matlab.
3. Cálculo y graficacion de los armónicos mediante la integración de los
coeficientes An y Bn.

syms t k n;%Declara las variables como símbolos

T=str2double(get(handles.periodo,'String'));
f= 1;%funciones
ao1 = (2/T)*(int(f,t,0,T/2)+int(-f,t,T/2,T));
a1 = (2/T)*(int(f*cos(k*pi*t),t,0,T/2)+int(-
f*cos(k*pi*t),t,T/2,T))*0;
b1 = (2/T)*(int(f*sin(k*pi*t/T),t,0,T/2)+int(-
f*sin(k*pi*t/T),t,T/2,T));
fsum= symsum(b1*sin(k*pi*t/T),k,1,n);
r=simplify(ao1);%Simplifica la función
u=simplify(a1);%Simplifica la función
v=simplify(b1);%Simplifica la función
fsu=simplify(fsum);%Simplifica la función

4. Impresión en la interfaz gráfica de los resultados y graficas de las funciones.

syms t k n;%Declara las variables como símbolos

f= t;%funciones
T=str2double(get(handles.periodo,'String'));
ao2 = 2*int(f,t,0,T)/T;
a2 = (2/T)*int(f*cos(k*pi*t/T),t,-T,T);
b2 = (2/T)*int(f*sin(k*pi*t/T),t,-T,T);
fsum2= ao2+symsum(a2*cos(k*pi*t/T)+b2*sin(k*pi*t/T),k,1,n);
r2=simplify(ao2);%Simplifica la función
u2=simplify(a2);%Simplifica la función
v2=simplify(b2);%Simplifica la función
fsu2=simplify(fsum2);%Simplifica la función
axes(handles.axes9);
cla
T = strcat('$$', 'A_0 = ', char(latex(r2)),'$$');
text('Interpreter','latex',...
 'String',T,...
'Position',[0 .9],...
'FontSize',12);
T = strcat('$$', 'A_k = ', char(latex(u2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .5],...
'FontSize',12);
T = strcat('$$', 'B_k = ', char(latex(v2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .2],...
'FontSize',12);
axis off;
axes(handles.axes10);
cla
T = strcat('$$', 'f(t) = ', char(latex(fsu2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .9],...
'FontSize',14);
axis off;

RESULTADOS
Ejecución del programa

Ilustración 6 Ventana principal del programa.

Ingreso de parámetros por teclado

Ilustración 7 Configuración de las funciones.

Cálculo de los armónicos y grafica del espectro
 Ilustración 8 Funcionamiento y visualización del espectro en el programa.

VIII. CONCLUSIONES Y RECOMENDACIONES.

• La Serie Trigonométrica de Fourier es una herramienta matemática empleada para
descomponer una señal periódica en una suma de funciones trigonométricas, como
senos y cosenos, con diversas frecuencias y amplitudes. Esta técnica permite
analizar las características de la señal en términos de sus componentes de
frecuencia y se utiliza en diversas aplicaciones, como el análisis y la síntesis de
señales, así como el filtrado de señales
• MATLAB ofrece diversas herramientas para crear interfaces gráficas intuitivas
para el usuario. La elección de la interfaz dependerá de las necesidades específicas,
y en este caso, se requería programar parámetros matemáticos, incluyendo el uso
de integrales que se encuentran en el Symbolic Math Toolbox.
• Durante la realización de ejercicios en clases, se confirmó la precisión de los
cálculos, y las gráficas demostraron que se llevaron a cabo de manera correcta. Se
permitió la modificación de los parámetros para ajustar la forma de la onda según
la función requerida. El principal desafío radicó en la introducción manual de
constantes y su análisis en los cálculos matemáticos.
RECOMENDACIONES
Es fundamental establecer de manera precisa los datos de entrada para asegurar una
ejecución matemática correcta. En muchos cálculos de funciones, diversas variables
pueden surgir, lo que podría interferir con los procesos matemáticos. Por tanto, es esencial
prestar especial atención a la gestión de datos y la transformación de estos en formatos
adecuados para las operaciones matemáticas.

IX. FE DE ERRATAS
Durante el desarrollo de la práctica de laboratorio, se tuvieron ciertos errores en las
variables ingresadas por teclado, donde hubo conflictos al ingresar limites en radianes y
valores de amplitud como constantes.

Ilustración 9 Ingreso de datos.

Ilustración 10 Dialogo de error en la programación.

Fue un error de convertir datos a diferentes valores, se solucionó a determinar diferentes

valores de conversión de datos.

am1=get(handles.amplitud,'String'); %Toma el valor ingresado de la

amplitud
p=get(handles.periodo,'String');%Toma el valor ingresado del periodo

X. BIBLIOGRAFÍA

[1] C. J. González y de Escola Técnica Superior Enxeñeiros Industriáis, «Fundamentos

del análisis de Fourier,» JUEGOSAL, 2003.
[2] H. P. Hsu, Señales y Sistemas, Segunda Edición ed., 2013.
[3] J. Saquimux, Series trigonométricas de Fourier, Universidad de San Carlos, 2011.
[4] C. J. C. González, Fundamentos del Análisis de Fourier, Universidad de Vigo, 2002.

XI. ANEXOS
 Ilustración 11 Interfaz gráfica.

Ilustración 12 Programación en Matlab.

PROGRAMACIÓN

function varargout = SERIE_TRIGONOMETRICA(varargin)

gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @SERIE_TRIGONOMETRICA_OpeningFcn, ...
'gui_OutputFcn', @SERIE_TRIGONOMETRICA_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 SERIE_TRIGONOMETRICA_OpeningFcn(hObject, eventdata, handles,
varargin)
% Choose default command line output for SERIE_TRIGONOMETRICA
handles.output = hObject;
% Update handles structure
guidata(hObject, handles);
% UIWAIT makes SERIE_TRIGONOMETRICA wait for user response (see UIRESUME)
% uiwait(handles.figure1);
axes(handles.axes9);
axis off;
axes(handles.axes10);
axis off;
% --- Outputs from this function are returned to the command line.
function varargout = SERIE_TRIGONOMETRICA_OutputFcn(hObject, eventdata,
handles)
% Get default command line output from handles structure
varargout{1} = handles.output;
% --- Executes on button press in pushbutton9.
function pushbutton9_Callback(hObject, eventdata, handles)
menu=get(handles.menu1,'Value'); %Obtener el valor del menu
switch menu %Opciones de señales
case 1%Si escogemos rectangular
%************************ RECTANGULAR GRÁFICO **************************%
fs_rec = 10000; %Frecuencia de muestreo
t_rec = -2:1/fs_rec:2; %Tiempos
x2 = square(2*pi*1*t_rec+84.8);%Funcion
am1=get(handles.amplitud,'String'); %Toma el valor ingresado de la
amplitud
p=get(handles.periodo,'String');%Toma el valor ingresado del periodo
set(handles.pi1,'String','ms')
set(handles.pi2,'String','ms')
set(handles.pi3,'String','ms')
axes(handles.axes7);%Lugar de graficación
plot(t_rec,x2,'r', 'LineWidth',1) %Grafica función
axis([-2 2 -1.2 1.2]) %Limita
set (gca, 'xtick', [-1 0 1], 'XTickLabel', {str2double(p)*-1; '0'; p},
'FontName','Times', 'Fontsize', 12);%Texto en eje horizontal
set (gca, 'ytick', [-1 0 1], 'YTickLabel', {str2double(am1)*-1; '0';
am1});%Texto en eje vertical
xlabel('Período') %Título eje horizontal
ylabel('Amplitud') %Título eje vertical
title('SEÑAL RECTANGULAR-DOMINIO TIEMPO')%Título principal
grid on; % Malla
%*************************************************************************%

case 2 %Si escogemos diente de sierra

%*********************** DIENTE DE SIERRA GRÁFICO
***********************%
fs_sierra = 10000; %Frecuencia de muestreo
t_sierra = -2:1/fs_sierra:2; %Tiempos
x1 = sawtooth(2*pi*1*t_sierra);%Funcion
am1=get(handles.amplitud,'String'); %Toma el valor ingresado de la
amplitud
set(handles.pi1,'String','ms')
p=get(handles.periodo,'String');%Toma el valor ingresado del periodo
set(handles.pi2,'String','ms')
set(handles.pi3,'String','ms')
axes(handles.axes7);%Lugar de graficación
plot(t_sierra,x1,'r', 'LineWidth', 1) %Grafica función
axis([-2 2 -1.2 1.2]) %Limita
set (gca, 'xtick', [-1 0 1], 'XTickLabel', {str2double(p)*-1; '0'; p},
'FontName','Times', 'Fontsize', 12);%Texto en eje horizontal
set (gca, 'ytick', [-1 0 1], 'YTickLabel', {'0';str2double(am1)/2;
am1});%Texto en eje vertical
xlabel('Período') %Título eje horizontal
ylabel('Amplitud') %Título eje vertical
title('SEÑAL DIENTE DE SIERRA-DOMINIO TIEMPO')%Título principal
grid on; % Malla
%*************************************************************************%

case 3 %Si escogemos otra funcion

%************************ FUNCION OTRA GRÁFICO
**************************%
syms t k P n;
assume(k,'Integer')
a = @(f,t,k,P) int(f*cos(k*pi*t/P),t,-P,P)/P;
b = @(f,t,k,P) int(f*sin(k*pi*t/P),t,-P,P)/P;
fs=@(f,t,n,P)
a(f,t,0,P)/2+symsum(a(f,t,k,P)*cos(k*pi*t/P)+b(f,t,k,P)*sin(k*pi*t/P),k,1,n
);
%definición de la fuerza y su semiperiodo P
f=t*(heaviside(t)-heaviside(t-pi/2))+(heaviside(t-pi/2)-heaviside(t-
pi))*pi/2;
P=pi;
N=6; %términos del desarrollo en serie
latex(fs(f,t,N,P))
axes(handles.axes7);%Lugar de graficación
cla
hold on
hg1=ezplot(f,[-P P]);
set(hg1,'color','r', 'LineWidth', 1)
set(gca,'XTick',-pi:pi/2:pi)
T=str2double(get(handles.periodo,'String'));
am1=str2double(get(handles.amplitud,'String')); %Toma el valor ingresado de
la amplitud
set(gca,'XTickLabel',{-T,-T/2,'0',T/2,T})
set(gca,'YTick',0:pi/2:pi)
set(gca,'YTickLabel',{'0',am1})
hold off
grid on
xlabel('t')
ylabel('f(t)')
title('FUNCION ORIGINAL')
%*************************************************************************%

end
guidata(hObject, handles);
function pushbutton10_Callback(hObject, eventdata, handles)
close(SERIE_TRIGONOMETRICA);
seleccion;
% --- Executes on button press in pushbutton11.
function pushbutton11_Callback(hObject, eventdata, handles)
close(SERIE_TRIGONOMETRICA);
cd materia_trig;
MATERIA_ST;
% --- Executes on button press in pushbutton12.
function pushbutton12_Callback(hObject, eventdata, handles)
menu=get(handles.menu1,'Value'); %Obtener el valor del menu
switch menu %Opciones de señales
case 1 %si escogemos rectangular
%*******************SERIE DE FOURIER - RECTANGULAR ******************%
axes(handles.axes8);%Lugar de graficación
arm=str2double(get(handles.armonico,'String')); %Toma el valor ingresado
del armonico
n=arm;
hold on
cla
am1=str2double(get(handles.amplitud,'String')); %Toma el valor ingresado de
la amplitud
p=str2double(get(handles.periodo,'String'));%Toma el valor ingresado del
periodo
x=[-p/2 -p/2 0 0 p/2 p/2]; %Grafica señal
y=[0 am1 am1 -am1 -am1 0]; %
plot(x,y,'m','linewidth',1)
x=linspace(-1,1,100);
y=zeros(length(x),1);
for i=1:length(x)
y(i)=0;
for k=1:2:n
y(i)=y(i)-4*am1*sin(k*pi*x(i))/(k*pi);
end
end
plot(x*(p/2),y, 'b','linewidth',1)
axis([-(p-(p/2)) p-(p/2) -am1-2 am1+2 ]) %Limita
title(sprintf('Aproximación de Fourier: %i términos',n))
xlabel('t');
ylabel('f(t)')
grid on
hold off
%**********************RESPUESTAS*******************%
syms t k n;%Declara las variables como símbolos
T=str2double(get(handles.periodo,'String'));
f= 1;%funciones
ao1 = (2/T)*(int(f,t,0,T/2)+int(-f,t,T/2,T));
a1 = (2/T)*(int(f*cos(k*pi*t),t,0,T/2)+int(-f*cos(k*pi*t),t,T/2,T))*0;
b1 = (2/T)*(int(f*sin(k*pi*t/T),t,0,T/2)+int(-f*sin(k*pi*t/T),t,T/2,T));
fsum= symsum(b1*sin(k*pi*t/T),k,1,n);
r=simplify(ao1);%Simplifica la función
u=simplify(a1);%Simplifica la función
v=simplify(b1);%Simplifica la función
fsu=simplify(fsum);%Simplifica la función
axes(handles.axes9);
cla
R = strcat('$$', 'A_0 = ', char(latex(r)),'$$');
text('Interpreter','latex',...
'String',R,...
'Position',[0 .9],...
'FontSize',12);
R = strcat('$$', 'A_k = ', char(latex(u)),'$$');
text('Interpreter','latex',...
'String',R,...
'Position',[0 .5],...
'FontSize',12);
R = strcat('$$', 'B_k = ', char(latex(v)),'$$');
text('Interpreter','latex',...
'String',R,...
'Position',[0 .2],...
'FontSize',12);
axis off;
axes(handles.axes10);
cla
R = strcat('$$', 'f(t) = ', char(latex(fsu)),'$$');
text('Interpreter','latex',...
'String',R,...
'Position',[0 .9],...
'FontSize',14);
axis off;
%**************************************************%
%*************************************************************************%

case 2 %Si escogemos diente de sierra

%*******************SERIE DE FOURIER - DIENTE DE SIERRA
******************%
%
syms t k P n;
assume(k,'Integer')
a2 = @(f,t,k,P) int(f*cos(k*pi*t/P),t,-P,P)/P;
b2 = @(f,t,k,P) int(f*sin(k*pi*t/P),t,-P,P)/P;
fs=@(f,t,n,P)
a2(f,t,0,P)/2+symsum(a2(f,t,k,P)*cos(k*pi*t/P)+b2(f,t,k,P)*sin(k*pi*t/P),k,
1,n);
%definición de la funcion y su periodo P
am1=get(handles.amplitud,'String'); %Toma el valor ingresado de la
amplitud
p=get(handles.periodo,'String');%Toma el valor ingresado del periodo
f=(str2double(am1)/str2double(p))*t;
P=str2double(p);
arm=get(handles.armonico,'String'); %Toma el valor ingresado del armonico
N=str2double(arm); %términos del desarrollo en serie
%pretty(fs(f,t,N,P)) %Respuesta de armonicos
axes(handles.axes8);%Lugar de graficación
cla
hold on
hg1=ezplot(f,[-P P]);
set(hg1,'color','m', 'LineWidth', 1)
hg=ezplot(fs(f,t,N,P),[0 P]);
set(hg,'color','b', 'LineWidth', 1)
axis([0 str2double(p) 0 str2double(am1)+1 ]) %Limita
hold off
xlabel('t')
ylabel('f(t)')
title('Serie de Fourier')
%**********************RESPUESTAS*******************%
syms t k n;%Declara las variables como símbolos
f= t;%funciones
T=str2double(get(handles.periodo,'String'));
ao2 = 2*int(f,t,0,T)/T;
a2 = (2/T)*int(f*cos(k*pi*t/T),t,-T,T);
b2 = (2/T)*int(f*sin(k*pi*t/T),t,-T,T);
fsum2= ao2+symsum(a2*cos(k*pi*t/T)+b2*sin(k*pi*t/T),k,1,n);
r2=simplify(ao2);%Simplifica la función
u2=simplify(a2);%Simplifica la función
v2=simplify(b2);%Simplifica la función
fsu2=simplify(fsum2);%Simplifica la función
axes(handles.axes9);
cla
T = strcat('$$', 'A_0 = ', char(latex(r2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .9],...
'FontSize',12);
T = strcat('$$', 'A_k = ', char(latex(u2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .5],...
'FontSize',12);
T = strcat('$$', 'B_k = ', char(latex(v2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .2],...
'FontSize',12);
axis off;
axes(handles.axes10);
cla
T = strcat('$$', 'f(t) = ', char(latex(fsu2)),'$$');
text('Interpreter','latex',...
'String',T,...
'Position',[0 .9],...
'FontSize',14);
axis off;
%**************************************************%
case 3 %Si escogemos otra funcion
%***************************** FUNCION GRÁFICO
**************************%
syms t k P n;
assume(k,'Integer')
a = @(f,t,k,P) int(f*cos(k*pi*t/P),t,-P,P)/P;
b = @(f,t,k,P) int(f*sin(k*pi*t/P),t,-P,P)/P;
fs=@(f,t,n,P)
a(f,t,0,P)/2+symsum(a(f,t,k,P)*cos(k*pi*t/P)+b(f,t,k,P)*sin(k*pi*t/P),k,1,n
);
%definición de la fuerza y su semiperiodo P
f=t*(heaviside(t)-heaviside(t-pi/2))+(heaviside(t-pi/2)-heaviside(t-
pi))*pi/2;
P=pi;
arm=get(handles.armonico,'String'); %Toma el valor ingresado del armonico
N=str2double(arm); %términos del desarrollo en serie
axes(handles.axes8);%Lugar de graficación
cla
hold on
hg1=ezplot(f,[-P P]);
set(hg1,'color','m', 'LineWidth', 1)
hg=ezplot(fs(f,t,N,P),[-P P]);
set(hg,'color','b','LineWidth', 1)
set(gca,'XTick',-pi:pi/2:pi)
T=str2double(get(handles.periodo,'String'));
am1=str2double(get(handles.amplitud,'String')); %Toma el valor ingresado de
la amplitud
set(gca,'XTickLabel',{-T,-T/2,'0',T/2,T})
set(gca,'YTick',0:pi/2:pi)
set(gca,'YTickLabel',{'0',am1})
hold off
grid on
xlabel('t')
ylabel('f(t)')
title('Serie de Fourier')
%***********************RESPUESTAS********************%
syms t k n;%Declara las variables como símbolos
f= t;%funciones
T=str2double(get(handles.periodo,'String'));
am1=str2double(get(handles.amplitud,'String')); %Toma el valor ingresado de
la amplitud
ao3 = 2*(int(f,t,0,T/2)+int(am1,t,T/2,T))/T;
a3 = (2/T)*(int(f*cos(k*pi*t/T),t,0,T/2)+int(am1*cos(k*pi*t/T),t,T/2,T));
b3 = (2/T)*(int(f*sin(k*pi*t/T),t,0,T/2)+int(am1*cos(k*pi*t/T),t,T/2,T));
fsum3= ao3+symsum(a3*cos(k*pi*t/T)+b3*sin(k*pi*t/T),k,1,n);
r3=simplify(ao3);%Simplifica la función
u3=simplify(a3);%Simplifica la función
v3=simplify(b3);%Simplifica la función
fsu3=simplify(fsum3);%Simplifica la función
axes(handles.axes9);
cla
R1 = strcat('$$', 'A_0 = ', char(latex(r3)),'$$');
text('Interpreter','latex',...
'String',R1,...
'Position',[0 .9],...
'FontSize',12);
R1 = strcat('$$', 'A_k = ', char(latex(u3)),'$$');
text('Interpreter','latex',...
'String',R1,...
'Position',[0 .6],...
'FontSize',12);
R1 = strcat('$$', 'B_k = ', char(latex(v3)),'$$');
text('Interpreter','latex',...
'String',R1,...
'Position',[0 .2],...
'FontSize',12);
axis off;
axes(handles.axes10);
axis off;
%*****************************************************%
%*************************************************************************%

end
guidata(hObject, handles);
% --- Executes on slider movement.
function slider3_Callback(hObject, eventdata, handles)
% --- Executes during object creation, after setting all properties.
function slider3_CreateFcn(hObject, eventdata, handles)
if isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor',[.9 .9 .9]);
end
% --- Executes on selection change in menu1.
function menu1_Callback(hObject, eventdata, handles)
menu=get(handles.menu1,'Value'); %Obtener el valor del menu
switch menu %Opciones de señales
case 1 %si escogemos rectangular
axes(handles.axes8);
cla reset
axes(handles.axes7);
cla reset
axes(handles.axes9);
cla reset
axes(handles.axes10);
cla reset
axes(handles.axes9);
axis off;
axes(handles.axes10);
axis off;
case 2 %si escogemos rectangular
axes(handles.axes8);
cla reset
axes(handles.axes7);
cla reset
axes(handles.axes9);
cla reset
axes(handles.axes10);
cla reset
axes(handles.axes9);
axis off;
axes(handles.axes10);
axis off;
case 3 %si escogemos rectangular
axes(handles.axes8);
cla reset
axes(handles.axes7);
cla reset
axes(handles.axes9);
cla reset
axes(handles.axes10);
cla reset
axes(handles.axes9);
axis off;
axes(handles.axes10);
axis off;
end
% Hints: contents = cellstr(get(hObject,'String')) returns menu1 contents
as cell array
% contents{get(hObject,'Value')} returns selected item from menu1
% --- Executes during object creation, after setting all properties.
function menu1_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function amplitud_Callback(hObject, eventdata, handles)
% --- Executes during object creation, after setting all properties.
function amplitud_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function periodo_Callback(hObject, eventdata, handles)
% --- Executes during object creation, after setting all properties.
function periodo_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
function pushbutton12_ButtonDownFcn(hObject, eventdata, handles)
function armonico_Callback(hObject, eventdata, handles)
% --- Executes during object creation, after setting all properties.
function armonico_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end