# Señales de tiempo continuo


## Señales estándar

Algunas [señales](https://en.wikipedia.org/wiki/Signal_%28electrical_engineering%29) desempeñan un rol importante en las aplicaciones del **procesamiento de señales**, **el control automático**, **las telecomunicaciones**, etc. y se usan para caracterizar las propiedades de los sistemas Lineales e Invariantes en el Tiempo (LTI). A continuación se introducen e ilustran estas señales estándar.

### Exponencial compleja


La señal exponencial compleja en el dominio del tiempo $t$ se define matemáticamente con la [función exponencial compleja](https://en.wikipedia.org/wiki/Exponential_function#Complex_plane)

\begin{equation}
x(t) = e^{s t} 
\end{equation}

donde $s = \sigma + j \omega$ describe una frecuencia compleja con $\sigma, \omega \in \mathbb{R}$ y $j$ tal que $(j^2=-1)$.


Esta señal se usa para representar señales armónicas. Usando la [formula de Euler](https://es.wikipedia.org/wiki/F%C3%B3rmula_de_Euler), la expresión anterior se puede reescribir como:

\begin{equation}
x(t) = e^{(\sigma + j \omega) t}  = e^{(\sigma) t} \cdot e^{(j \omega) t} = e^{\sigma t} \cos(\omega t) + j e^{\sigma t} \sin(\omega t)
\end{equation}


Ahora, las partes real e imaginaria de la señal son ponderados por funciones conseno y seno de frecuencia $\omega = 2 \pi f$. Para $t>0$, el peso en función del tiempo  $e^{\sigma t}$ es

* exponencialmente decreciente si $\sigma < 0$,
* constante (1) si $\sigma = 0$,
* exponencialmente creciente si  $\sigma > 0$,

Así, la señal exponencial compleja se usa para modelar señales armónicas con amplitudes constantes o exponencialmente crecientes o decrecientes.

**Ejemplo**

Las variables que se requieren son $t$, $\omega$ and $\sigma$ y se definen como variables simbólicas reales.


```python
import sympy as sym
import matplotlib.pyplot as plt
%matplotlib inline
sym.init_printing()


t, sigma, omega = sym.symbols('t sigma omega', real=True)
s = sigma + 1j*omega
x = sym.exp(s*t)
x
```

Ahora se definen valores para $s = \sigma + j \omega$.


```python
y = x.subs({omega: 0, sigma: 1})
plt.rcParams['figure.figsize'] = 9, 3
sym.plot(sym.re(y), (t, 0, 20), ylabel=r'Re{$e^{st}$}')
sym.plot(sym.im(y), (t, 0, 20), ylabel=r'Im{$e^{st}$}')
```

**Ejercicio**

* Defina valores para `omega` y `sigma` de manera que pueda crear señales decrecientes, constantes y crecientes con distinta frecuencia angular.


```python
## Escriba su código aquí
## creciente
y = x.subs({omega: 0.5, sigma: 0.1})
plt.rcParams['figure.figsize'] = 9, 3
sym.plot(sym.re(y), (t, 0, 20), ylabel=r'Re{$e^{st}$}')
sym.plot(sym.im(y), (t, 0, 20), ylabel=r'Im{$e^{st}$}')
```

### Impulso de Dirac

Esta es una de las señales más importantes. Se usa para caracterizar y modelar los sistemas LTI. Se define según la [función delta de Dirac](https://es.wikipedia.org/wiki/Delta_de_Dirac). Se denota como $\delta(t)$ y se describe completamente por el efecto en otra función. A continuación las propiedades más relevantes:

1.  \begin{equation}
    \int_{-\infty}^{\infty} \delta(t) \cdot x(t) \cdot dt = x(0)
    \end{equation} donde $x(t)$ debe ser diferenciable en $t=0$. Esto implica que $\int_{-\infty}^{\infty} \delta(t) \cdot dt= 1$.
    

2.  \begin{equation}
    x(t) \cdot \delta(t) = x(0) \cdot \delta(t)
    \end{equation}
    donde $x(t)$ debe ser diferenciable en $t=0$.
    
    
3.  \begin{equation}
    a \cdot \delta(t) + b \cdot \delta(t) = (a+b) \cdot \delta(t)
    \end{equation}
    
    
4. \begin{equation}
    \delta(a t) = \frac{1}{|a|} \delta(t)
    \end{equation}
    donde $a \in \mathbb{R} \setminus 0$. Esto implica que el impulso de Dirac tiene simetría par.
    
    
5. \begin{equation}
    \int_{-\infty}^{\infty} \frac{d \delta(t)}{dt} \cdot x(t) \; dt = - \frac{d x(t)}{dt} \bigg\vert_{t = 0}
    \end{equation}

6.  \begin{equation}
    \int_{-\infty}^{\infty} \delta(\tau) \cdot x(t - \tau)  \, d\tau = x(t)
    \end{equation}
    
La última función es la [convolución](https://es.wikipedia.org/wiki/Convoluci%C3%B3n) y se tratará después.


**Ejemplo**

Primero se define la señal delta de Dirac.


```python
delta = sym.DiracDelta(t)
delta
```

Observe la primera propiedad con una función arbitraria $f(t)$.


```python
f = sym.Function('f')(t)
sym.integrate(delta*f, (t, -sym.oo, sym.oo))
```

**Ejercicio**

* Configure la función $\delta(t-\tau)$ y verifique el ejemplo anterior.


```python
## Escriba su código aquí
tau = sym.symbols('tau', real=True)
deltaTau = sym.DiracDelta(t-tau)
deltaTau*f
```


```python
sym.integrate(deltaTau*f, (t, -sym.oo, sym.oo))
```

### Escalón

La señal escalón se define según la [función escalón](https://es.wikipedia.org/wiki/Funci%C3%B3n_escal%C3%B3n_de_Heaviside)

\begin{equation}
\epsilon(t) = \begin{cases} 0 & t<0 \\  1 & t > 0 \end{cases}
\end{equation}

El escalón y el impulso de dirac se relacionan mediante:

\begin{equation}
\epsilon(t) = \int_{-\infty}^{t} \delta(\tau) \; d\tau
\end{equation}

**Ejemplo**

Se define y grafica la función escalón. `Sympy` llama Heaviside a la función y la denota como $\theta(t)$.


```python
step = sym.Heaviside(t)
step
```


```python
plt.rcParams['figure.figsize'] = 9, 3
sym.plot(step, (t, -2, 2), ylim=[-0.2, 1.2], ylabel=r'$\epsilon(t)$');
```

**Ejercicio**

Construya una señal armónica $\cos(\omega t)$ con $\omega=2$ que se "enciende" en el instante $t=0$. 

\begin{equation}
x(t) = \cos(\omega t) \cdot \epsilon(t)
\end{equation}


```python
step = sym.Heaviside(t)
x = sym.cos(omega*t) * step
plt.rcParams['figure.figsize'] = 9, 3
sym.plot(x.subs(omega,2), (t, -10, 20), ylim=[-1.2, 1.2], ylabel=r'$x(t)$',xlabel=r'$t_{seg}$')
```

**Ejemplo**

Basado en la función escalón, se define un pulso rectangular de ancho $a$.


```python
a = sym.symbols('a', real=True)
t = sym.symbols('t', real=True)

def rect(t,a):
    Esc1 = sym.Heaviside(t+a)
    Esc2 = sym.Heaviside(t-a)
    return Esc1 - Esc2
r = rect(t,a)
plt.rcParams['figure.figsize'] = 9, 3
sym.plot(sym.Heaviside(t+a).subs(a,0.5), (t, -2, 2), ylim=[-1.2, 1.2], ylabel=r'$Esc1(t)$')
sym.plot(sym.Heaviside(t-a).subs(a,0.5), (t, -2, 2), ylim=[-1.2, 1.2], ylabel=r'$Esc2(t)$')
sym.plot(r.subs(a,0.5), (t, -2, 2), ylim=[-1.2, 1.2], ylabel=r'$rect(t)$')

```

**Ejercicio**

Defina y grafique una función armónica $\cos(\omega t)$ with $\omega=5$ que se "encienda" en $t=-1$ y se "apague" en $t=1$.


```python
## Escriba su código aquí
x = sym.cos(omega*t) * rect(t,1)
y = x.subs({omega: 5})
plt.rcParams['figure.figsize'] = 9, 3
sym.plot(sym.re(y), (t, -10, 10), ylabel=r'Re{$e^{st}$}')
sym.plot(sym.im(y), (t, -10, 10), ylabel=r'Im{$e^{st}$}')
```

## Operaciones con señales


Las señales estándar permiten formar señales de estructuras más complejas mediante operaciones como la superposición, el desplazamiento temporal, el escalamiento, etc.

### Superposición

Considere que $x(t)$ es la superposición ponderada de las señales $x_\text{A}(t)$ y $x_\text{B}(t)$, es decir, la relación está dada por:

\begin{equation}
x(t) = A \cdot x_\text{A}(t) + B \cdot x_\text{B}(t)
\end{equation}

donde $A, B \in \mathbb{C}$.

**Ejercicio**

Suponga que $x(t) = A \cdot cos(\omega_{A}t) + B \cdot cos(\omega_{B}t)$. Puede observarse que se superponen dos señales coseno con distintas amplitudes y frecuencias.


```python
t = sym.symbols('t', real=True)

A = 0.25
omA = 13
B = .75
omB = 3.5

xA = sym.cos(omA*t)
xB = sym.cos(omB*t)
x = A*xA + B*xB

plt.rcParams['figure.figsize'] = 9, 3
pA=sym.plot(A*xA, (t, -5, 5), ylim=[-1.2, 1.2], xlabel=r't', show=True, line_color='red')
pB=sym.plot(B*xB, (t, -5, 5), ylim=[-1.2, 1.2], show=True, line_color='green')
pA.extend(pB)
pA.show()
sym.plot(x,(t, -5, 5), ylim=[-1.2, 1.2], show=True, line_color='blue')
```

### Desplazamiento temporal

Considere que $y(t)$ es una señal con la misma forma y valores de la señal $x_(t)$ pero están corridas en el tiempo.

\begin{equation}
y(t) = x(t-\tau)
\end{equation}
donde $\tau \in \mathbb{R}$.

En este caso, se dice que la señal $x(t)$ se ha:

* desplazado a la derecha (*retardo*) si $\tau > 0$
* desplazado a la izquierda (*adelanto*) si $\tau < 0$

**Ejercicio**

Suponga que se combinan 3 pulsos rectangulares para formar una "escalera" de pocos nivele.

\begin{equation}
x(t) = \text{rect}\left(t - \frac{1}{2} \right) + \frac{2}{3} \cdot \text{rect}\left(t-\frac{3}{2} \right) + \frac{1}{3} \cdot \text{rect} \left(t-\frac{5}{2} \right)
\end{equation}


```python
rect = sym.Heaviside(t + 1/2) - sym.Heaviside(t - 1/2)

xA = rect.subs(t, t-1/2)
xB = 2/3*rect.subs(t, t-3/2)
xC = 1/3*rect.subs(t, t-5/2)
x = xA + xB + xC

plt.rcParams['figure.figsize'] = 9, 3

sym.plot(rect, (t, -1, 5), ylim=[-0.2, 1.2], ylabel='$x(t)$');
sym.plot(xA, (t, -1, 5), ylim=[-0.2, 1.2], ylabel='$x(t)$');
sym.plot(xB, (t, -1, 5), ylim=[-0.2, 1.2], ylabel='$x(t)$');
sym.plot(xC, (t, -1, 5), ylim=[-0.2, 1.2], ylabel='$x(t)$');
sym.plot(x, (t, -1, 5), ylim=[-0.2, 1.2], ylabel='$x(t)$');
```

### Escalamiento temporal

Esta operación permite alterar la rapidez aparente del tiempo dada la forma de una señal. Se define como:

\begin{equation}
y(t) = x(a \cdot t)
\end{equation}

donde $a \in \mathbb{R}$.

En este caso, se dice que la señal $x(t)$ se ha:

* estirado si $ 0 < a < 1$
* comprimido si $ 1 < a $
* invertido si $ a < 0$

**Ejercicio**

Tome la señal anterior y aplique una escala temporal $a$ tal que $y(t) = x(a \cdot t)$.



```python

```

**Ejercicio**

Modifique el ejemplo anterior para que la señal tenga:
- Compresión temporal y retardo
- Inversión temporal y adelanto

Realice distintas pruebas con otras formas de señal.

86028bac281b7b0d43b3957386d715109cb88136
ipynb
Jupyter Notebook
SenalesEstandar.ipynb
edwinjperezg/Control
eacc370a4bf345fa1da6e52f802e6525cad30ec1
MIT
SenalesEstandar.ipynb
edwinjperezg/Control
eacc370a4bf345fa1da6e52f802e6525cad30ec1
MIT
SenalesEstandar.ipynb
edwinjperezg/Control
eacc370a4bf345fa1da6e52f802e6525cad30ec1
MIT
2021-11-18T13:08:36.000Z
2021-11-18T13:08:36.000Z
Qwen/Qwen-72B
1. YES
2. YES