Conceptos Fundamentales de Procesamiento Digital de Señales en MATLAB

Escrito el 5 de Junio de 2025 en español con un tamaño de 6,87 KB

Respuesta Impulsional

Definición y visualización de la respuesta impulsional de un sistema.

n=-10:1:30;
b=[-1 2 3 6 ...];
A=1;
x=zeros(1,41);
x(11)=1;
y1=filter(B,A,x); % Nota: La variable 'b' está definida, pero se usa 'B' en la función filter. Se mantiene el original.
stem(n,y1);
grid;

Función zerpol(B,A)

Función para calcular y visualizar los ceros y polos de un sistema.

function [ceros,polos]=zerpol(B,A);
bs =roots(B);
as=roots(A);
ceros=bs;
polos=as;
polar(angle(bs),abs(as),'x'); % Nota: Se grafica abs(as) (polos) en lugar de abs(bs) (ceros). Se mantiene el original.
hold off;

Función respfrec(B,A,nfrec)

Función para calcular la respuesta en frecuencia de un sistema, incluyendo módulo y fase.

function [modulo,fase,frecuencia]=respfrec(B,A,nfrec);
frecuencia=linspace(0,0.5,nfrec);
b=B(length(B):-1:1);
a=A(length(A):-1:1);
numerador=polyval(b,exp(-j*2*pi*frecuencia));
denominador=polyval(a,exp(-j*2*pi*frecuencia));
sol=numerador./denominador;
modulo=abs(sol);
fase=angle(sol);
subplot(211);
plot(frecuencia,modulo);
grid;
xlabel('Frecuencia');
ylabel('Módulo');
subplot(212);
plot(frecuencia,unwrap(fase));
grid;
xlabel('Frecuencia');
ylabel('Fase (radianes)');

FFT Diezmado en Tiempo (fftdt)

Implementación de la Transformada Rápida de Fourier (FFT) utilizando el algoritmo de diezmado en tiempo.

function [X,t,f]=fftdt(x);
N=length(x);
n=0:N-1;
c=clock;
flops(0);
fasores=exp(-j*2*pi*n/N);
if(round(log2(N))==log2(N))
    X=mfft(x,fasores);
    disp('Tiempo');
    t=etime(clock,c);
    disp('Nro Operaciones');
    f=flop % Nota: 'flop' parece incompleto, se mantiene el original.
else
    error('No es potencia de 2');
end;

function X=mfft(x,fasores);
N=length(x);
if(N==2)
    X(1)=x(1)+x(2);
    X(2)=x(1)-x(2);
else
    G=mfft(x(1:2:N),fasores(1:2:N));
    H=mfft(x(2:2:N),fasores(1:2:N));
    X(1:N/2)=G+fasores(1:N/2).*H;
    X((N/2)+1:N)=G+fasores((N/2)+1:N).*H; % Nota: Típicamente es G - W_N^k H para la segunda mitad. Se mantiene el original.
end

Función mdft(x)

Implementación de la Transformada Discreta de Fourier (DFT).

function X=mdft(x);
x=x(:);
N=length(x);
n=[0:1:N-1];
for k=0:N-1
    Vk=[exp(-j*2*pi*k*n/N)];
    X(k+1)=Vk*x;
    FR=[exp(-j*2*pi*n/M)]; % Nota: La variable 'M' no está definida. Se mantiene el original.
    Vk1=FR.*Vk;
    Vk=Vk1;
end

IDFT por Conjugados (midft)

Implementación de la Transformada Inversa Discreta de Fourier (IDFT) utilizando la propiedad de conjugación.

function sol=midft(X);
X=conj(X);
X=mdft(X);
X=conj(X);
sol=X/(length(X));

Comparación de Funciones de Muestreo

Insertaceros vs. Interp

Función para insertar ceros en una señal, y una nota sobre la función interp.

function xout=insertaceros(xin,L);
xout=zeros(1,length(xin)*L); % Corrección de 'lenght(xin,L)' a 'length(xin)*L'.
xout=zeros(1,length(xin)*L); % Línea duplicada, se mantiene según la instrucción.
ind=(1:length(xin))*L-(L-1);
xout(ind)=xin;

La función interp, después de insertar ceros, inserta un filtro paso bajo con frecuencia de corte fc=0.5/L, según el caso.

Quitamuestras vs. Decimate

Función para quitar muestras de una señal, y una nota sobre la función decimate.

function xout=quitamuestras(xin,M);
xout=xin(1:M:end);

Decimate además introduce un filtro, que atenúa el par de tonos, previo a la función quitamuestras. Condición de solapamiento: fs >= 2wM.

Filter vs. Conv

Comparación entre las funciones filter y conv para el filtrado digital.

Filter: Implementa un filtro digital unidireccional. y=filter(b,a,x) filtra los datos almacenados en el vector x con el filtro formado por los vectores a y b, creando y. Si x es un impulso unidad, y=h[n].
Conv: Implementa filtrado de secuencias. y=conv(x,h) convoluciona los vectores x y h. El vector resultado tiene una longitud de longitud(x) + longitud(h) - 1. Si x y h son vectores de coeficientes polinómicos, se convolucionarán multiplicándolos.

Conv solo es para filtros FIR, mientras que filter es para filtros FIR e IIR.

Funciones de Generación de Señales

Función sinusoide

Generación de una señal sinusoidal.

function sol=sinusoide(a,fo,fs,fi,t0,tf);
ts=1/fs;
t=t=t0:ts:tf; % Nota: 't=t=' es redundante, se mantiene el original.
n=1:length(t);
sol=A*sin((2*pi*n*fo/fs)+fi); % Nota: 'A' no está definido en los parámetros de entrada. Se asume una variable global o typo. Se mantiene el original.

Función delta

Generación de un impulso unitario (función delta de Kronecker).

function sol=delta(n);
sol=(n==0);

Función complejo

Generación de una señal compleja.

function sol = complejo(fg,fz,A,r);
A=2;
R=0.9; % Nota: La variable 'R' no se usa en la definición de 'sol'. Se mantiene el original.
n=0:20;
fg=90;
fz=45;
G=A*exp(j*fg*pi/180);
z=r*exp(j*fz*pi/180);
sol=G*z.^n;

Configuraciones de Sistemas LTI

Ejemplos de sistemas en cascada y en paralelo.

Cascada 1

x=0.9*u(n); % Corrección de u[n] a u(n)
a=[1];
b1=[1/10*ones(1,10)];
b2=[1 -1];
x1=filter(b1,a,x);
y=filter(b2,a,x1);

Cascada 2

x=0.9*u(n);
x1=filter(b2,a,x);
y=filter(b1,a,x1);

Paralelo

x=0.9*u(n);
x1=filter(b1,a,x);
x2=filter(b2,a,x);
y=x1+x2;

Se observa la Propiedad Conmutativa en sistemas LTI.

Equivalente Cascada 2

x=0.9*u(n); % Corrección de u[n] a u(n)
n=-10:1:100;
a=[1];
b1=[1/10*ones(1,10)];
h2=delta(n)-delta(n-1);
hc2=filter(b1,a,h2);
b=[0.1 0 0 0 ... -0.1]; % Corrección de '....' a '...'
y=filter(n,y) % Nota: Esta línea parece incompleta o incorrecta para una llamada a filter. Se mantiene el original.

Equivalente Paralelo

(No se proporciona código para esta sección en el documento original.)