La curs am discutat despre semnale de bază și sisteme. În continuare vom face câteva exerciții legate de aceste noțiuni.

[2p]

Pentru a transmite simboluri (ex: litere din alfabet) modemurile folosesc diferite frecvențe și mai multe niveluri de amplitudine. O transmisie se face într-o perioadă de timp T (interval de transmisie) și poate conține o suprapunere de mai multe semnale, e.g. suma a două semnale de amplitudini și frecvențe diferite:

$x(t) = A_{1} \cdot sin(2\cdot \pi\cdot f_{1}\cdot t) + A_{2} \cdot sin(2\cdot \pi\cdot f_{2}\cdot t)$

1. Care este cel mai mic interval de transmisie care are sens să fie folosit, dacă $f_1 = 1600$ Hz și $f_2 = 1800$ Hz? Cu alte cuvinte, cât ar trebui să fie $T$ astfel încât semnalul să aibă un număr întreg de cicluri? [1p]
2. Afişaţi semnalul produs de modem pe parcursul a trei intervale de transmisie. Pentru primul interval de transmisie puteți folosi $A_1 = 0$ și $A_2 = 1$, pentru al doilea interval $A_1 = 1$ și $A_2 = 1$, iar pentru al treilea interval $A_1 = 1$ și $A_2 = 0$. Aşa cum am învăţat în laboratorul trecut adăugaţi titlu şi etichete plot-ului. [1p]

Ar trebui să obțineți ceva similar:

[2.5p]

La curs am văzut că putem descompune semnalele într-o sumă de mai multe semnale de bază (ramp, step etc.). Pentru acest exerciţiu veţi încerca să folosiţi semnalele 'step' şi 'ramp' pentru a crea semnalul reprezentat cu negru în acest slide: building_signals.pdf

Pentru a face asta în Python va trebui să lucrăm cu semnale discrete, nu continue (vom discuta despre acest aspect în cursurile viitoare). În loc să lucrăm cu semnale reprezentate în intervalul [0,1] ca în slide vom folosi semnale ce se întind peste 100 de puncte.

Puteţi folosi următoarea funcţie pentru a crea un semnal 'ramp' peste N puncte:

ramp.py

import numpy as np
 
 
def ramp(N):
    y = np.zeros(N, dtype=int)
    for t in range(0, N):
        y[t] = t
    return y

Pentru a apela funcția 'ramp' din ramp.py într-un alt fișier .py (care se află în același director) puteți folosi următorul cod:

ex2.py

from ramp import ramp

Task-ul vostru este să creaţi un semnal combinat, ca cel din slide, dar folosind secvenţe discrete, cu o formulă ca cea de mai jos:

$s(i) = r(i) - r(i-T) - T \cdot u(i-T)$

unde $i$ este un index de la 0 la N (în loc de un număr real de la 0 la 1), $T$ este întârzierea, $s$ este semnalul rezultat, $r$ este semnalul 'ramp' (eventual întârziat cu $T$) și $u$ este semnalul 'unit step' (întârziat aici cu $T$).

Pentru asta ar trebui să:

1. creaţi un semnal 'unit step' numit ustep.py, care practic întoarce o secvenţă de N valori de 1 [0.5p]
2. să setaţi numărul de puncte la $N = 200$ şi delay-ul la $T = 100$
3. să creaţi cele 3 semnale (care urmează să fie combinate) folosind 'ramp' şi 'ustep' cu $N$ şi $T$ de mai sus. [1p]
   • Puteţi crea secvenţa de input ca:

      x = np.arange(0, N) 

   • Puteţi crea primul semnal ca:

      s1 = ramp(N) 

   • Puteţi întârzia un semnal cu $T$ în felul următor (o posibilă soluție):

      s_delayed = np.pad(s[:N - T], (T, 0)) 

     Documentație np.pad. Mai puteți concatena zerouri folosind np.concatenate, np.hstack, etc.

4. combinaţi cele 3 semnale
5. afişaţi toate cele 4 semnale (cele 3 individuale şi combinaţia lor) [1p]
   • folosiţi culori diferite (eventual grosimi de linie diferite) pentru fiecare semnal şi afişaţi legenda pentru a diferenţia semnalele.

 plt.plot(x, s1, 'g-', linewidth=2)

 plt.show() 

figure1 = plt.figure('Figura 1')
plt.plot(x, s1, 'g-', linewidth=2)
plt.plot(...)
plt.show()

Ar trebui să obțineţi ceva similar imaginii de mai jos:

[2p]

La curs am văzut că datorită egalității lui Euler putem scrie o exponenţială complexă ca o sumă de sin şi cos:

$e^{j\cdot t} = \cos(t) + j\cdot \sin(t)$

De asemenea:

$e^{-j \cdot t} = \cos(t) - j \cdot \sin(t)$

Adunând aceste 2 ecuaţii şi împărţind la 2 obţinem:

$\cos(t) = \frac{e^{j \cdot t} + e^{-j \cdot t}}{2}$

Încercaţi să arătaţi asta în Python, făcând următoarele:

• Folosiţi secvenţa de input

   t = np.array([0, np.pi / 6, np.pi / 4, np.pi / 3, np.pi / 2]) 

• Afişaţi exponenţiala complexă $s_1 = e^{j\cdot t}$, e.g.

    complex_exp1 = np.exp(1j * t)
    x_complex_exp1 = np.real(complex_exp1)
    y_complex_exp1 = np.imag(complex_exp1)
    plt.plot(x_complex_exp1, y_complex_exp1, 'ro')
 

• Afişaţi exponenţiala complexă $s_2 = e^{-j \cdot t}$ cu o altă culoare
• Calculaţi media celor 2 exponenţiale $s_s = \frac{s_1 + s_2}{2}$, i.e. cos(t)
• Afișaţi secvenţa rezultată în planul complex folosind np.real(ss) ca valori x şi np.imag(ss) ca valori y
• Verificaţi dacă s1, s2 şi ss arată cum v-aţi fi aşteptat!
• Opțional, calculați și afișați și sin(t)

import numpy as np
import matplotlib.pyplot as plt
 
tt = np.arange(0, 2 * np.pi, 0.1)
figure1 = plt.figure('Figura 1', figsize=(10, 10))
complex_tt = np.exp(1j * tt)
x = np.real(complex_tt)
y = np.imag(complex_tt)
plt.plot(x, y, 'k.')
plt.plot(0, 0, 'kx')

[3.5p]

Avem un sistem de feedback precum cel din imaginea următoare:

Să presupunem că folosim acest sistem pentru sistemul de pilot automat al maşinii, unde x(t) este o constantă ce reprezintă viteza dorită, iar y(t) este viteza maşinii măsurată de vitezometru. În această aplicaţie, sistemul 2 este sistemul identitate (intrare = ieşire).

Să construim acest sistem având în vedere următoarele constrângeri:

• viteza initială a maşinii este 7
• valoarea iniţială a secvenţei de feedback (output-ul lui S2), f, este 0
• valoarea iniţială pentru secvenţa de diferenţă, e, este 0
• valoarea de input a sistemului de pilot automat, x, este o secvenţă de tipul [60, 60, …, 60]
• primul sistem, S1, cunoaște viteza curentă y(i) şi primește ca parametru diferenţa e(i). Bazându-se pe acestea, actualizează viteza curentă după cum urmează:
  • Dacă e(i) > 10, atunci y(i+1) = y(i) + 5
  • altfel dacă e(i) > 0, atunci y(i+1) = y(i) + 1
  • altfel dacă e(i) == 0, atunci y(i+1) = y(i)

Construiţi sistemul S1 ca o funcţie cu 2 parametrii (viteza_curentă, e), care afişează următoarea viteză curentă ca mai sus. În Python puteţi folosi o instrucţiune for pentru asta:

N = 20;
y = np.zeros(N, dtype=int)
y[0] = 7;
for i in range(0, N - 1):
  ...
  y[i+1] = S1(y[i], e[i])
end

Rulaţi sistemul de N = 20 ori şi afişaţi outputul sistemului.