FACULTAD DE EDUCACIÓN TÉCNICA PARA EL DESARROLLO

MAESTRÍA EN TELECOMUNICACIONES

PROCESAMIENTO DIGITAL DE SEÑALES

TEMA:
ENCONTRAR LA FRECUENCIA DE NYQUIS, PARA UNA SEÑAL
PROPUESTA, Y HALLAR EL PSD MEDIANTE EL USO DEL MÉTODO AR
YULE-WALKER Y ENCONTRAR LOS PICOS ESPECTRALES.

AUTORES:
Ing. David Hernán Paucar Naranjo
Ing. Jhon Jairo Cargua Quishpi

TUTOR:
Dr.C. Maikel Noriega Alemán

Guayaquil, Ecuador
16 de marzo del 2019
 ÍNDICE
1. Introducción 3

2. Desarrollo de la práctica 4

3. Conclusiones 8

4. Bibliografía 9

5. Anexo 1
 1. Introducción

Desde hace tiempo el hombre ha buscado la posibilidad de automatizar los

procesos en sus empresas, investigaciones sobre todo el llegar a tratar una señal
analógica, variar sus componentes, y mas aun el lograr recuperar esta señal
luego de ser convertida de analógica ha digital, hoy en día tener mas señales
digitalizadas es fácil con la ayuda de métodos matemáticos y procesos
computacionales que integran microprocesadores dedicados para la
manipulación de dichas señales.

Este documento trata de resolver y explicar el tratamiento de señales continuar

y discretas. Antes se va a definir señal como aquella cantidad física que varía
con el tiempo, espacio o cualquier otra variable o variables independientes.” [1]
una señal Continua está en dominio del tiempo su variable independiente y real.
mientras que una señal discreta está en el dominio de número de muestras y la
variable independiente es entera.
Se debe de tener en cuenta que la frecuencia mínima de muestreo es la (FS =
2FM ) que sería la frecuencia de Nyquis.
Para hallar las componentes espectrales se deberá descomponer la señal y sus
componentes espectrales para encontrar las frecuencias fundamentales y
representarlas en el dominio de la frecuencia.
 2. Desarrollo de la práctica

Para empezar, procedemos a detallar los datos propuestos para el caso.

Teniendo como datos:
Datos:
A1 = A2 = 1 V;
B1=50
B=90
Tiempo de Observación = 100segundos.
Para la señal discreta:
𝑥(𝑛)=𝐴1cos(𝐵1𝜋𝑛) + 𝐴2cos(𝐵2𝜋𝑛)
a) Si la señal fuera continua, especifique la frecuencia de muestreo igual a la
frecuencia de Nyquist adecuada para realizar el muestreo.
Apoyándose en el material brindado se procede a hacer la analogía para el caso de que la
señal sea continua.

𝑥(𝑛)=𝐴1cos(𝐵1𝜋𝑛)+𝐴2cos(𝐵2𝜋𝑛)
𝑥(𝑛)=1cos(50𝜋𝑛)+1cos(90𝜋𝑛)
(2𝜋f)n=Wn
f=w/2𝜋
f=Bmayor*𝜋/2𝜋
f=Bmayor/2
f=90/2
f=45
Fs=2(90)
Fs=2F
Fs=2*45.
Fs=90.
 La frecuencia Mínima para evitar el Aliasing es 90.

b) Grafique la señal en Matlab

function pushbutton1_Callback(hObject, eventdata, handles)

global A1;
global B1;
global A2;
global B2;
global A12;
global B12;
global A22;
global B22;
global tob;
global fs;
Tobs=tob;
Fs=fs;
F1=B1/2;
F2=B2/2;
%F1 = 25; % Frecuencia de la sinusoide 1 en Hz
%F2 = 45; % Frecuencia de la sinusoide 2 en Hz
%Fs = 180; % Frecuencia de muestreo en Hz
%Tobs = 100 % Tiempo de observación en segundos

%Calculo Fs Naquis
%x = A1*cos(2*pi*F1/Fs*i) + A2*cos(2*pi*F2/Fs*i);
%2*pi*f=Wn == 2*pi*f=B1*pi*n
%f=B1*pi*n / 2*pi*f
%f=b1/2

if B1>B2
bm=B1
else
bm=B2
end
pyq=(bm/2);
nyy=(pyq*2);

set(handles.text15,'string',pyq);
set(handles.text16,'string',nyy);

N = Tobs*Fs;
i = [0:N-1];
x = A1*cos(2*pi*F1/Fs*i) + A2*cos(2*pi*F2/Fs*i);
%x = A1*cos(2*pi*F1/Fs*i) + A2*cos(2*pi*F2/Fs*i)+ normrnd(0,1,1,N);
t = i/Fs; % Vector de tiempo
axes(handles.axes2);
plot(t, x); xlabel('t en en segundos');
title('Señal x(t)');

Grafica en una Fs igual a la de Nyquis.

Grafica en una Fs Menor a la de Nyquis.

Grafica en una Fs Mayor a la de Nyquis.

c) Hallar la PSD mediante por el Método de Obtención Modelo AR (Yule-

Walker)
N = length(x);
nfft = N;
p = 40; %Orden del modelo
[PS3, F] = pyulear(x, p, N, Fs);% Fourth-order estimate
PS3dB = 20*log10(PS3);
subplot 212; plot(F, PS3); title('PS por Yule Walker')
Grafica en una Fs Mayor a la de Nyquis.

d) En que frecuencias en Hz están los picos espectrales

𝑥(𝑛)=𝐴1cos(𝐵1𝜋𝑛)+𝐴2cos(𝐵2𝜋𝑛)
𝑥(𝑛)=1cos(50𝜋𝑛)+1cos(90𝜋𝑛)
(2𝜋f)n=Wn
f=w/2𝜋
f=B1*𝜋/2𝜋
f=B1/2
f=50/2
f=25
f=B2*𝜋/2𝜋
f=B2/2
f=90/2
f=45
%Se calcula Sxx como el módulo al cuadrado de la FT de x(t):
%La muestra N de X corresponde a fs Hz ó 2*pi rad/muestra
X = fft(x);

%Se calcula el espectro de potencia mediante la fft:

PS = abs(X).^2;
N = length(X);
freq = Fs*(1:N)/N; %Vector de frecuencia para plotear

%Tomando sólo la mitad de los puntos, que corresponde a las frecuencias hasta
fs/2 (para obtener el espectro unilateral):
PS = PS(1:N/2);
freq = freq(1:N/2); % nuevo vector de frecuencias

axes(handles.axes4); plot(freq, PS);

xlabel('f en Hz');
title('Picos de Frecuencia');
3. Conclusiones

1. Llegando a la conclusión, se puede observar que una función la se la

puede mirar como señal discreta como continua, según la necesidad.
Haciendo el análisis de la función.
2. Como describe la regla de muestreo de la señal que deberá ser el doble
de la Frecuencia, de igual manera se deberá tener el doble de la
frecuencia para de esta manera evitar el Aliasing de la Señal, y con esto
evitar señales adyacentes a la señal real.
3. Se pudo comprobar que el orden del Modelo Yule influye mucho sobre el
espectro resultante ya que si el orden es mayor la resolución espectral.
4. Finalmente se puede observar que los Picos espectrales se encuentran
en las frecuencias fundamentales con la ayuda de las herramientas que
brinda Matlab.
 4. Bibliografía

1. E. Soria Olivas, M. Mart´ınez Sober, J. V. Franc´es Villora, and G. Camps

Valls. Tratamiento Digital de Se˜nales. Problemas y ejercicios resueltos.
Prentice Hall, Madrid, 2003. 1, 233
2. Ed. Vijay K. Madisetti and Douglas B. Williams. Digital Signal Processing
Handbook. 1999
 Fs=fs;
5. Anexo %A1 = 1; % Amplitud en voltios
%A2 = 1; % Amplitud en voltios
F1=B1/2;
F2=B2/2;
Código: %F1 = 25; % Frecuencia de la sinusoide 1 en Hz
%F2 = 45; % Frecuencia de la sinusoide 2 en Hz
function varargout = TAREA_1(varargin) %Fs = 180; % Frecuencia de muestreo en Hz
gui_Singleton = 1; %Tobs = 100 % Tiempo de observación en
gui_State = struct('gui_Name', segundos
mfilename, ...
'gui_Singleton', %Calculo Fs Naquis
gui_Singleton, ... %x = A1*cos(2*pi*F1/Fs*i) +
'gui_OpeningFcn', A2*cos(2*pi*F2/Fs*i);
@TAREA_1_OpeningFcn, ... %2*pi*f=Wn == 2*pi*f=B1*pi*n
'gui_OutputFcn', %f=B1*pi*n / 2*pi*f
@TAREA_1_OutputFcn, ... %f=b1/2
'gui_LayoutFcn', [] , ...
'gui_Callback', []); if B1>B2
if nargin && ischar(varargin{1}) bm=B1
gui_State.gui_Callback = else
str2func(varargin{1}); bm=B2
end end
pyq=(bm/2);
if nargout nyy=(pyq*2);
[varargout{1:nargout}] =
gui_mainfcn(gui_State, varargin{:}); set(handles.text15,'string',pyq);
else set(handles.text16,'string',nyy);
gui_mainfcn(gui_State, varargin{:});
end N = Tobs*Fs;
i = [0:N-1];
% --- Executes just before TAREA_1 is made x = A1*cos(2*pi*F1/Fs*i) +
visible. A2*cos(2*pi*F2/Fs*i);
function TAREA_1_OpeningFcn(hObject, %x = A1*cos(2*pi*F1/Fs*i) +
eventdata, handles, varargin) A2*cos(2*pi*F2/Fs*i)+ normrnd(0,1,1,N);
ruta_img='C:\Users\t_hej\Desktop\Proyecto t = i/Fs; % Vector de tiempo
PDS\GUIDE'; axes(handles.axes2);
axes(handles.LogoU) plot(t, x); xlabel('t en en segundos');
background=imread([ruta_img,'\U.jpg']); title('Señal x(t)');
image(background);
axis off; %Se estima el espectro de potencia de x
mediante el método de Yule Walker:
axes(handles.fx) N = length(x);
background=imread([ruta_img,'\fxx.jpg']); nfft = N;
image(background); p = 30; %Orden del modelo
axis off; [PS3, F] = pyulear(x, p, N, Fs);% Fourth-order
estimate
axes(handles.axes9) PS3dB = 20*log10(PS3);
background=imread([ruta_img,'\ftx.jpg']); axes(handles.axes3); plot(F, PS3); title('PS
image(background); por Yule Walker')
axis off;
%Hallar el espectro de potencia como el módulo
axes(handles.fq) al %cuadrado de la FT de x(t) y a parir del
background=imread([ruta_img,'\nyq.jpg']); Periodograma no modificado.
image(background); %Se calcula Sxx como el módulo al cuadrado de
axis off; la FT de x(t):
%La muestra N de X corresponde a fs Hz ó 2*pi
handles.output = hObject; rad/muestra
guiadata(hObject,handles); X = fft(x);
% Choose default command line output for %Se calcula el espectro de potencia mediante
TAREA_1 la fft:
handles.output = hObject; PS = abs(X).^2;
N = length(X);
% Update handles structure freq = Fs*(1:N)/N; %Vector de frecuencia para
guidata(hObject, handles); plotear
% --- Outputs from this function are returned %Tomando sólo la mitad de los puntos, que
to the command line. corresponde a las frecuencias hasta fs/2 (para
function varargout = obtener el espectro unilateral):
TAREA_1_OutputFcn(hObject, eventdata, handles) PS = PS(1:N/2);
% Get default command line output from handles freq = freq(1:N/2); % nuevo vector de
structure frecuencias
varargout{1} = handles.output;
axes(handles.axes4); plot(freq, PS);
xlabel('f en Hz');
% --- Executes on button press in pushbutton1.
title('Espectro de potencia por la DFT de la
function pushbutton1_Callback(hObject,
señal');
eventdata, handles)
%Senial discreta
global A1;
B12=B12;
global B1;
B22=B22;
global A2;
A12=A12;
global B2;
A22=A22;
global A12;
%B12=25;
global B12;
%B22=45;
global A22;
global B22; %A12=1;
%A22=1;
global tob;
n=[0:1:99];
global fs;
x2=A12*cos(B12*pi*n)+A22*cos(B22*pi*n);
Tobs=tob;
axes(handles.axes8); end
stem(n,x2); % --------------------------------------------
title('signal x(n), 0 <= n <= 99'); ------------------------
xlabel('n') function Untitled_1_Callback(hObject,
axis([0,100,-2.5,2.5]) eventdata, handles)
X=fft(x2); magX=abs(X(1:1:51)); % para obtener
el espectro unilateral function fs_Callback(hObject, eventdata,
k=0:1:50; w=2*pi/100*k; %w va de 0 a pi, k va handles)
de 0 a 50. global fs;
axes(handles.axes5); fs=str2double(get(hObject, 'String'));
plot(w/pi,magX); % --- Executes during object creation, after
title('|X(w)| alta res. basado en 100 muestras setting all properties.
de x(n)'); function fs_CreateFcn(hObject, eventdata,
xlabel('frec in pi units') handles)
axis([0,2,0,60]) if ispc &&
isequal(get(hObject,'BackgroundColor'),
function a1_Callback(hObject, eventdata, get(0,'defaultUicontrolBackgroundColor'))
handles) set(hObject,'BackgroundColor','white');
global A1; end
A1=str2double(get(hObject, 'String'));
function A12_Callback(hObject, eventdata,
% --- Executes during object creation, after handles)
setting all properties. global A12;
function a1_CreateFcn(hObject, eventdata, A12=str2double(get(hObject, 'String'));
handles)
if ispc && % --- Executes during object creation, after
isequal(get(hObject,'BackgroundColor'), setting all properties.
get(0,'defaultUicontrolBackgroundColor')) function A12_CreateFcn(hObject, eventdata,
set(hObject,'BackgroundColor','white'); handles)
end if ispc &&
isequal(get(hObject,'BackgroundColor'),
function A2_Callback(hObject, eventdata, get(0,'defaultUicontrolBackgroundColor'))
handles) set(hObject,'BackgroundColor','white');
global A2; end
A2=str2double(get(hObject, 'String'));
% --- Executes during object creation, after function A22_Callback(hObject, eventdata,
setting all properties. handles)
function A2_CreateFcn(hObject, eventdata, global A22;
handles) A22=str2double(get(hObject, 'String'));
if ispc && % --- Executes during object creation, after
isequal(get(hObject,'BackgroundColor'), setting all properties.
get(0,'defaultUicontrolBackgroundColor')) function A22_CreateFcn(hObject, eventdata,
set(hObject,'BackgroundColor','white'); handles)
end if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
function B1_Callback(hObject, eventdata, end
handles) function B12_Callback(hObject, eventdata,
global B1; handles)
B1=str2double(get(hObject, 'String')); global B12;
B12=str2double(get(hObject, 'String'));
% --- Executes during object creation, after
setting all properties. % --- Executes during object creation, after
function B1_CreateFcn(hObject, eventdata, setting all properties.
handles) function B12_CreateFcn(hObject, eventdata,
if ispc && handles)
isequal(get(hObject,'BackgroundColor'), if ispc &&
get(0,'defaultUicontrolBackgroundColor')) isequal(get(hObject,'BackgroundColor'),
set(hObject,'BackgroundColor','white'); get(0,'defaultUicontrolBackgroundColor'))
end set(hObject,'BackgroundColor','white');
end
function B2_Callback(hObject, eventdata,
function B22_Callback(hObject, eventdata,
handles) handles)
global B2;
global B22;
B2=str2double(get(hObject, 'String')); B22=str2double(get(hObject, 'String'));
% --- Executes during object creation, after
setting all properties. % --- Executes during object creation, after
function B2_CreateFcn(hObject, eventdata, setting all properties.
handles) function B22_CreateFcn(hObject, eventdata,
if ispc && handles)
isequal(get(hObject,'BackgroundColor'), if ispc &&
get(0,'defaultUicontrolBackgroundColor')) isequal(get(hObject,'BackgroundColor'),
set(hObject,'BackgroundColor','white'); get(0,'defaultUicontrolBackgroundColor'))
end set(hObject,'BackgroundColor','white');
end
function tob_Callback(hObject, eventdata,
handles)
global tob;
tob=str2double(get(hObject, 'String'));

% --- Executes during object creation, after

setting all properties.
function tob_CreateFcn(hObject, eventdata,
handles)
if ispc &&
isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');