Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 62 vistas

    Senales y Sistemas Practica 1.10

    Cargado por

    Andres Urgilez
    En este documento se presenta un programa desarrollado en Matlab que implementa operaciones y transformaciones en diferentes señales, como la rampa unitaria, señal signo, pulso rectangular y triangular, señal sinc y seno. El código genera gráficas que muestran el comportamiento de las señales originales, transformadas y su suma para analizar los efectos de las operaciones en diferentes entornos.

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd

    Senales y Sistemas Practica 1.10

    Cargado por

    Andres Urgilez
    62 vistas10 páginas
    En este documento se presenta un programa desarrollado en Matlab que implementa operaciones y transformaciones en diferentes señales, como la rampa unitaria, señal signo, pulso rectangular y triangular, señal sinc y seno. El código genera gráficas que muestran el comportamiento de las señales originales, transformadas y su suma para analizar los efectos de las operaciones en diferentes entornos.

    Título original

    senales y sistemas practica 1.10

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    DOCX, PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    En este documento se presenta un programa desarrollado en Matlab que implementa operaciones y transformaciones en diferentes señales, como la rampa unitaria, señal signo, pulso rectangular y triangular, señal sinc y seno. El código genera gráficas que muestran el comportamiento de las señales originales, transformadas y su suma para analizar los efectos de las operaciones en diferentes entornos.

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd
    Descargar como docx, pdf o txt
    62 vistas10 páginas

    Senales y Sistemas Practica 1.10

    Cargado por

    Andres Urgilez
    En este documento se presenta un programa desarrollado en Matlab que implementa operaciones y transformaciones en diferentes señales, como la rampa unitaria, señal signo, pulso rectangular y triangular, señal sinc y seno. El código genera gráficas que muestran el comportamiento de las señales originales, transformadas y su suma para analizar los efectos de las operaciones en diferentes entornos.

    Copyright:

    © All Rights Reserved
    Descargue como DOCX, PDF, TXT o lea en línea desde Scribd
    Descargar como docx, pdf o txt
    Está en la página 1de 10

    Universidad Politecnica Salesiana

    PRÁCTICA 1 – SEÑALES Y SISTEMAS - GENERACIÓN Y TRANSFORMACIÓN DE SEÑALES

    Integrantes:

    Luis Andres Urgilez

    Paolo Javier Romero

    Jean Pierre Andrede

    Cristopher Elias Lopez

    OBJETIVO GENERAL
    Implementar una aplicación de señales con diferentes variaciones y operaciones en la interfaz gráfica de
    Matlab (guide) dando como resultado graficas mostrando sus comportamientos.

    RESUMEN
    En la siguiente practica se puso a consideración los conocimientos adquiridos en las clases de señales y
    sistemas para realizar un programa donde se coteje, se resuelva y se realicen operaciones múltiples de
    señales distintas, mostrando su comportamiento mediante un grupo de graficas realizadas por el
    programa en cuestión, para lograr analizar el comportamiento de sus señales en diferentes ambientes.

    MARCO TEÓRICO
    Software Matlab

    Un programa computacional para el análisis interactivo y procesos de diseños matemáticos con un


    lenguaje de programación especifico, una herramienta para la ingeniería capaz de reducir el tiempo de
    calculo de un sin numero de problemas, basado en un algoritmo matemático matricial y arrays
    directamente. Con un uso en especifico de apps que permiten ver diferentes datos con sus algoritmos
    establecidos.

    Escalón unitario.

    Es usado en señales y sistemas ya que este puede ser ocupado para representar matemáticamente
    hablando a una acción muy común en sistemas físicos reales, con un rápido cambien de un estado a
    otro.

    Señal signo

    Esta muy relacionada con la función anterior, para valores distintos a cero, el resultado de esta función
    tiene una magnitud de uno o un signo que sea igual a su relación.

    Rampa unitaria.

    Un tipo de señal que funciona y varia en un tiempo lineal, y a partir de aquel instante de tiempo variado
    su linealidad para desactivarse al instante.
    Pulso rectangular unitario

    Un tipo de señal de las mas identificadas, ocurre en un sistema en el que una señal X(t) se activa en un
    momento en el tiempo y se desactiva casi inmediatamente. Todas las dimensiones de la señal son
    iguales a 1.

    Pulso triangular unitario.

    Se le nombra de esta manera ya que sus dimensiones son iguales es decir su área y su altura variando
    únicamente su base.

    Señal Sinc

    Esta función también está relacionada con la función triangulo. Ya que viene siendo una transformada
    de Fourier de la señal inicial en cuestión. Y es llamada de esta manera ya que sus dimensiones como su
    altura y su área son equivalentes a 1

    DESARROLLO DEL CÓDIGO EN EL SOFTWARE MATLAB


    Código para la Rampa unitaria
    elseif Seleccion =="Rampa unitaria"

    Mo= (A*(t.*((heaviside(Et*(t-(Dt))))))) + off;

    valorpar= (Mo-(A*(t.*((heaviside(-Et*(t-(Dt)))))))+ off)/2;

    valorimpar= (Mo+(A*(t.*((heaviside(-Et*(t-(Dt)))))))+ off)/2;


    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_ori,t.*heaviside(t));
    plot(app.UIAxes_tras,t,Mo);
    plot(app.UIAxes_par,t,valorpar);

    p=0;
    app.PFT.Value=num2str(p);

    Codigo para la señal Sing


    elseif Seleccion =="Señal signo"

    Mo=(2*A*(heaviside(Et*(t-Dt))))-1 + off;

    valorpar= (Mo+ (2*A*(heaviside(-Et*(t-Dt))))-1 + off)/2;


    valorimpar= (Mo- (2*A*(heaviside(-Et*(t-Dt))))-1 + off)/2;
    plot(app.UIAxes_ori,2.*(heaviside(t))-1);
    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_tras,t,Mo);
    plot(app.UIAxes_par,t,valorpar);

    syms t
    syms T
    p=0;
    app.PFT.Value=num2str(p);
    e=limit((int(Mo.^2,-T,T)),T,inf);
    e=e(1);
    app.EFT.Value=sprintf('%2.f',e);

    código para la señal rectangular


    elseif Seleccion =="Rectangular unitario"

    rec=(A*rectangularPulse(Et*(t-Dt)))+ off;

    valorpar= (rec+ (A*rectangularPulse(-Et*(t-Dt))+ off))/2;

    valorimpar= (rec- (A*rectangularPulse(-Et*(t-Dt)))+ off)/2;

    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_ori,rectangularPulse(t));
    plot(app.UIAxes_par,t,valorpar);
    plot(app.UIAxes_tras,t,rec);

    syms t
    Npinf=(-1/2+Dt)*1/abs(Et);
    Npsup=(1/2+Dt)*1/abs(Et);

    Amplitudd=A+off;

    p=0;
    app.PFT.Value=num2str(p);
    e= int((Amplitudd)^2,t,Npinf,Npsup);
    e=e(1);
    app.EFT.Value=sprintf('%2.f',e);
    código para la señal triangular
    elseif Seleccion =="Triangular Unitario"

    Mo=(A*triangularPulse(Et*(t-Dt)))+ off;

    valorpar= (Mo+ ((A*triangularPulse(-Et*(t-Dt))))+ off)/2;

    valorimpar= (Mo- ((A*triangularPulse(-Et*(t-Dt))))+ off)/2;


    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_ori,triangularPulse(t));
    plot(app.UIAxes_par,t,valorpar);
    plot(app.UIAxes_tras,t,Mo);

    syms t
    Npinf=(-1+Dt)*1/abs(Et);
    Npsup=(1+Dt)*1/abs(Et);

    % Amplitud y-y1=((y2-y1)/(x2-x1))*(x-x1);
    E2=((((A+off)-off)/(((Npsup+Npinf)/2)-Npinf))*(t-Npinf))+off;
    E3=((((A+off)-off)/(((Npsup+Npinf)/2)-Npsup))*(t-Npsup))+off;

    Energia1= int(E2.^2,t,Npinf,(Npsup+Npinf)/2);
    Energia2= int(E3.^2,t,(Npsup+Npinf)/2,Npsup);
    e=Energia1+Energia2;
    e=e(1);
    app.EFT.Value=sprintf('%2.f',e);

    p=0;
    app.PFT.Value=num2str(p);
    código para la señal sinc
    %Sinc
    elseif Seleccion =="Sinc"

    Mo=(A*(sin(Et*pi*(t-Dt))./(Et*pi*(t-Dt))))+off;

    valorpar= (Mo+
    ((A*(sin(-Et*pi*(t-Dt)))./(-Et*pi*(t-Dt))))+off)/2;

    valorimpar= (Mo-
    (A*(sin(-Et*pi*(t-Dt))./(-Et*pi*(t-Dt))))+off)/2;
    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_par,t,valorpar);
    plot(app.UIAxes_ori,sin(pi*t)./(pi*t));
    plot(app.UIAxes_tras,t,Mo);
    e='inf';
    app.EFT.Value=e;

    syms t;
    syms T;
    p=limit((1/(2*T))*(int(Mo.^2,-T,T)),T,inf);
    p=p(1);
    app.PFT.Value=num2str(double(p));

    código para la señal seno


    elseif Seleccion =="Seno"

    Mo=(A*sin(Et*(t-Dt)))+off;

    valorpar= (Mo+ (A*sin(-Et*(t-Dt)))+off)/2;

    valorimpar= (Mo- (A*sin(-Et*(t-Dt)))+off)/2;


    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_ori,sin(t));
    plot(app.UIAxes_tras,t,Mo);
    plot(app.UIAxes_par,t,valorpar);
    e='inf';
    app.EFT.Value=e;
    syms t;
    syms T;
    p=limit((1/(2*T))*(int(Mo.^2,-T,T)),T,inf);
    p=p(1);
    app.PFT.Value=num2str(double(p));

    código para la señal coseno


    elseif Seleccion =="Coseno"

    Mo=(A*cos(Et*(t-Dt)))+off;

    valorpar= (Mo + (A*cos(-Et*(t-Dt)))+off)/2;

    valorimpar=(Mo- (A*cos(-Et*(t-Dt)))+off)/2;
    plot(app.UIAxes_sum,t,valorimpar);
    plot(app.UIAxes_ori,cos(t));
    plot(app.UIAxes_tras,t,Mo);
    plot(app.UIAxes_par,t,valorpar);
    e='inf';
    app.EFT.Value=e;

    syms t;
    syms T;
    p=limit((1/(2*T))*(int(Mo.^2,-T,T)),T,inf);
    p=p(1);
    app.PFT.Value=num2str(double(p));

    codigo para la suma de funciones


    function SumadeFuncionesButtonPushed(app, event)
    Seleccion = app.SealesDropDown.Value
    ti=app.ti.Value;
    tf=app.tf.Value;
    t=ti:0.01:tf;
    A=app.Amplitud.Value;
    Et=app.Escalamientot.Value;
    Dt=-1*app.Desplazamientoti.Value;
    off=app.offset.Value;
    if Seleccion =="Seleccione la señal"
    elseif Seleccion =="Escalon unitario"
    Esc= heaviside(t);
    Mo= ((A)*(heaviside(Et*(t-(Dt)))))+ off;
    Suma= Esc+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Rampa unitaria"
    Ramp=t.*heaviside(t);
    Mo= ((A)*(heaviside(Et*(t-(Dt)))))+ off;
    Suma= Ramp+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Señal signo"
    Sig=2.*(heaviside(t))-1;
    Mo= (2*A*(heaviside(Et*(t-Dt))))-1 + off;
    Suma= Sig+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Rectangular unitario"
    Rec=rectangularPulse(t);
    Mo= (A*rectangularPulse(Et*(t-Dt)))+ off;
    Suma= Rec+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Triangular Unitario"
    Tri=triangularPulse(t);
    Mo= (A*triangularPulse(Et*(t-Dt)))+ off;
    Suma= Tri+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Sinc"
    Mo=(A*(sin(Et*pi*(t-Dt))./(Et*pi*(t-Dt))))+off;
    Sinc=sin(pi*t)./(pi*t);
    Suma= Sinc+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Seno"
    Mo=(A*sin(Et*(t-Dt)))+off;
    Sen=sin(t);
    Suma= Sen+Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Coseno"
    Mo=(A*cos(Et*(t-Dt)))+off;
    Co=cos(t);
    Suma= Co+Mo;
    plot(app.UIAxes_impar,Suma);

    Codigo para el product de funciones


    function ProductodeFuncionesButtonPushed(app, event)
    Seleccion = app.SealesDropDown.Value
    ti=app.ti.Value;
    tf=app.tf.Value;
    t=ti:0.01:tf;
    A=app.Amplitud.Value;
    Et=app.Escalamientot.Value;
    Dt=-1*app.Desplazamientoti.Value;
    off=app.offset.Value;
    if Seleccion =="Seleccione la señal"
    elseif Seleccion =="Escalon unitario"
    Esc= heaviside(t);
    Mo= ((A).*(heaviside(Et.*(t-(Dt)))))+ off;
    Suma= Esc.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Rampa unitaria"
    Ramp=t.*heaviside(t);
    Mo= ((A)*(heaviside(Et*(t-(Dt)))))+ off;
    Suma= Ramp.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Señal signo"
    Sig=2.*(heaviside(t))-1;
    Mo= (2.*A.*(heaviside(Et.*(t-Dt))))-1 + off;
    Suma= Sig.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Rectangular unitario"
    Rec=rectangularPulse(t);
    Mo= (A.*rectangularPulse(Et*(t-Dt)))+ off;
    Suma= Rec.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Triangular Unitario"
    Tri=triangularPulse(t);
    Mo= (A.*triangularPulse(Et.*(t-Dt)))+ off;
    Suma= Tri.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Sinc"
    Mo=(A.*(sin(Et.*pi.*(t-Dt))./(Et.*pi.*(t-Dt))))+off;
    Sinc=sin(pi*t)./(pi*t);
    Suma= Sinc.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Seno"
    Mo=(A.*sin(Et.*(t-Dt)))+off;
    Sen=sin(t);
    Suma= Sen.*Mo;
    plot(app.UIAxes_impar,Suma);
    elseif Seleccion =="Coseno"
    Mo=(A.*cos(Et.*(t-Dt)))+off;
    Co=cos(t);
    Suma= Co.*Mo;
    plot(app.UIAxes_impar,Suma);
    Grafica de la aplicación

    Conclusiones
    Para terminar con el siguiente informe, al momento de realizar la programación y ver el resultado final
    nos dimos cuente que la aplicación realizada nos reduce considerablemente el tiempo de análisis y de
    cálculo para todo tipo de señales, maximizando el resultado y agilitando el tiempo de respuesta para
    una señal, dándonos así un ahorro de tiempo considerable al momento de descubrir el comportamiento
    de diversas señales que se nos puedan presentar. Tenemos que tomar en consideración los conceptos
    estudiados para que el uso del programa sea lo mas aceptable posible, ya que esto es una herramienta
    mas en nuestra materia.

    Referencias.
    file:///C:/Users/Asus/Desktop/programas/programa/Universidad/senales%20y
    %20sistemas/Cap1_1_Signals__Systems_Tiempo_Continuo.pdf.

    También podría gustarte