Tuần 5

import numpy as np
from scipy import signal
import matplotlib.pyplot as plt

# Dạng trực tiếp I

b1 = [0, 0, 1]
a1 = [1, -np.sqrt(2), 1]

# Dạng trực tiếp II

b2 = [0, 1, 0]
a2 = [1, -np.sqrt(2), 1]

# Tạo tín hiệu đầu vào x(n-1)

t = np.linspace(0, 1, 1000, endpoint=False)
x = np.sin(2 * np.pi * t)

# Áp dụng mạch tạo dao động để tính toán tín hiệu y theo cả hai dạng
y1 = signal.lfilter(b1, a1, x) # Dạng trực tiếp I
y2 = signal.lfilter(b2, a2, x) # Dạng trực tiếp II

# Vẽ đồ thị tín hiệu đầu vào và đầu ra cho cả hai dạng

plt.figure(figsize=(10, 6))
plt.plot(t, x, label='Đầu vào x(n-1)')
plt.plot(t, y1, label='Đầu ra y(n) - Dạng trực tiếp I')
plt.plot(t, y2, label='Đầu ra y(n) - Dạng trực tiếp II')
plt.xlabel('Thời gian')
plt.ylabel('Biên độ')
plt.title('Tín hiệu hình sin sau khi áp dụng mạch tạo dao động')
plt.legend()
plt.show()
Tuần 6
import numpy as np

# Định nghĩa hàm X(Z) và các hằng số

def X(Z, a, b, c, d):
return (a * Z**2 + b * Z) / (Z**2 - c*Z + c*d)

# Hằng số
a=3
b=2
c=4
d=3

# Tính biến đổi Z ngược của X(Z)

def inverse_Z_transform(a, b, c, d, n):
# Định nghĩa X(Z) theo hàm số z^-1
def X_z_inverse(z_inv):
return (a * z_inv**2 + b * z_inv) / (z_inv**2 - c * z_inv + c * d)

# Biến đổi Z ngược

inverse_values = []
for k in range(n):
sum_value = 0
for i in range(k+1):
sum_value += X_z_inverse(np.exp(2 * np.pi * 1j / n * i)) * np.exp(2 * np.pi * 1j / n * i * k)
inverse_values.append((1 / n) * sum_value)

return inverse_values
# Số lượng mẫu
n = 100

# Tính biến đổi Z ngược

result = inverse_Z_transform(a, b, c, d, n)

# Kết quả
print("Biến đổi Z ngược của X(Z):", result)
Tuần 7
# Định nghĩa hàm X(Z) và các hằng số
def X(Z, a, b):
return Z / ((Z - a)**2 * (Z - b))

# Phương pháp phân tích thành các biểu thức hữu tỷ đơn giản

# Sử dụng cân bằng hệ số và giải hệ phương trình

def inverse_Z_transform_method1(a, b, num_samples=10):
a1 = (b - 2 * a) / (b - a) ** 2
a2 = (a - b) / (b - a) ** 2
inverse_values = []
for n in range(num_samples):
value = a1 * a ** n + a2 * b ** n
inverse_values.append(value)
return inverse_values

# Sử dụng công thức tính trực tiếp các hệ số

def inverse_Z_transform_method2(a, b, num_samples=10):
a1 = b / (b - a) ** 2
a2 = -a / (b - a) ** 2
inverse_values = []
for n in range(num_samples):
value = a1 * a ** n + a2 * b ** n
inverse_values.append(value)
return inverse_values

# Phương pháp phân tích thành chuỗi lũy thừa

def inverse_Z_transform_method3(a, b, num_samples=10):
 inverse_values = []
for n in range(num_samples):
value = (a ** n + b ** n - a ** n * b ** n) / (a - b)
inverse_values.append(value)
return inverse_values

# Thực hiện tính toán cho a=0.5, b=0.3

a = 0.5
b = 0.3
num_samples = 10

# Tính biến đổi Z ngược cho từng phương pháp

result_method1 = inverse_Z_transform_method1(a, b, num_samples)
result_method2 = inverse_Z_transform_method2(a, b, num_samples)
result_method3 = inverse_Z_transform_method3(a, b, num_samples)

# Kết quả
print("Kết quả phương pháp 1:", result_method1)
print("Kết quả phương pháp 2:", result_method2)
print("Kết quả phương pháp 3:", result_method3)
Tuần 8
import numpy as np
import matplotlib.pyplot as plt

# Thông số đầu vào

A0 = 1.0 # Biên độ của tín hiệu
w0 = 0.2 # Tần số góc của tín hiệu
P0 = 0.0 # Pha ban đầu của tín hiệu

# Tạo tín hiệu s(n)

def generate_signal(A0, w0, P0, n):
return A0 * np.sin(w0 * n + P0)

# Tạo dãy thời gian n từ 0 đến 19

n = np.arange(20)

# Sinh tín hiệu s(n)

signal = generate_signal(A0, w0, P0, n)

# Vẽ đồ thị tín hiệu s(n)

plt.stem(n, signal, use_line_collection=True)
plt.xlabel('n')
plt.ylabel('s(n)')
plt.title('Biểu đồ tín hiệu s(n)')
plt.show()
Tuần 9
import numpy as np
import matplotlib.pyplot as plt

def is_system_stable(a_coeffs):
# Tính toán nghiệm của phương trình đặc trưng
roots = np.roots(np.flip(a_coeffs))

# Kiểm tra tính ổn định dựa trên vị trí của nghiệm trên mặt phức
if np.all(np.abs(roots) < 1):
return True
else:
return False

# Nhập các hệ số a1, a2, ..., aN

a_coeffs = [2, -3, 2.5]

# Kiểm tra tính ổn định của hệ thống

stable = is_system_stable(a_coeffs)

if stable:
print("Hệ thống ổn định")
else:
print("Hệ thống không ổn định")
Tuần 10

import numpy as np
import matplotlib.pyplot as plt

# Các tham số đầu vào

Tp = 0.25 # Chu kỳ
tau = 0.2 * Tp # Độ rộng
A = 1 # Biên độ
N_values = [5, 10, 20] # Các giá trị N khác nhau

# Tính toán tín hiệu x(t)

def square_wave(t, Tp, tau, A, N):
x=0
for k in range(-N, N+1):
x += (np.sin(2 * np.pi * (2*k+1) * t / Tp) / (2*k+1)) * np.sinc((t - k * Tp) / tau)
return A * (4 / np.pi) * x

# Tạo dãy thời gian t từ 0 đến 2Tp

t = np.linspace(0, 2*Tp, 1000) # Tạo 1000 điểm dữ liệu từ 0 đến 2Tp

# Vẽ đồ thị x(t) cho từng giá trị N

plt.figure(figsize=(12, 8))
for n in range(len(N_values)):
N = N_values[n]
signal = square_wave(t, Tp, tau, A, N)
plt.subplot(len(N_values), 1, n+1)
plt.plot(t, signal)
plt.title('Đồ thị x(t) với N = {}'.format(N))
 plt.xlabel('t')
plt.ylabel('x(t)')

plt.tight_layout()
plt.show()
Tuần 11
import numpy as np
import matplotlib.pyplot as plt

def dtft_signal(N):
n = np.arange(0, N)
w = np.linspace(0, np.pi, N)
x = np.zeros(N, dtype=complex)
for k in range(1, N + 1):
wk = k * np.pi / N
if k == 1:
x += np.exp(1j * wk * (n - 1))
else:
Ak = 1
phi_k = -wk
x += 2 * Ak * np.cos(wk * n + phi_k)

return w, x

N = 100 # Tham số N
w, x = dtft_signal(N)

plt.plot(w, np.abs(x)) # Đồ thị phổ biên độ

plt.title('Phổ biên độ của tín hiệu')
plt.xlabel('Tần số w')
plt.ylabel('Phổ biên độ')
plt.show()
Tuần 14
import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt

# Hàm đáp ứng xung h(n)

h = np.array([1, 2, 3, 2, 1])

# Xác định loại bộ lọc FIR pha tuyến tính

if np.sum((-1)**np.arange(len(h)) * h) == 0:
linear_phase_filter = True
print("Loại bộ lọc FIR: Pha tuyến tính")
else:
linear_phase_filter = False
print("Loại bộ lọc FIR: Không phải pha tuyến tính")

# Tính toán và vẽ đáp ứng pha

w, phase = signal.freqz(h, worN=8000)
normalized_frequency = w / np.pi
plt.plot(normalized_frequency, np.angle(phase))
plt.title('Đáp ứng pha của bộ lọc FIR')
plt.xlabel('Tần số (Hz)')
plt.ylabel('Góc pha (radians)')
plt.grid(True)
plt.show()

# Xác định trễ nhóm α

if linear_phase_filter:
alpha = (len(h) - 1) / 2
 print("Trễ nhóm α: ", alpha)
else:
print("Không thể xác định trễ nhóm α vì bộ lọc không phải pha tuyến tính")