%pip install numpy matplotlib scikit-learn seaborn scipy schemdraw --quiet

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import schemdraw
import schemdraw.elements as elm
from typing import Tuple, List

Note: you may need to restart the kernel to use updated packages.

def string2bitstream(s: str) -> np.ndarray:
    """
    Converts a string into a bitstream represented as a NumPy array of 0s and 1s.

    Each character in the input string is encoded using its 8-bit ASCII binary representation.
    The result is a flat array containing the entire bitstream.

    Parameters
    ----------
    s : str
        Input string to be converted.

    Returns
    -------
    np.ndarray
        1D NumPy array of integers (0s and 1s), representing the bitstream of the input string.
    """
    return np.array([int(bit) for char in s for bit in f"{ord(char):08b}"])

def bitstream2string(b: np.ndarray) -> str:
    """
    Converts a bitstream represented as a NumPy array of 0s and 1s back into a string.

    The input bitstream is expected to be a flat array where each group of 8 bits corresponds
    to the ASCII binary representation of a character.

    Parameters
    ----------
    b : np.ndarray
        1D NumPy array of integers (0s and 1s), representing the bitstream.

    Returns
    -------
    str
        The decoded string from the input bitstream.
    """
    chars = [chr(int("".join(map(str, b[i:i+8])), 2)) for i in range(0, len(b), 8)]
    return "".join(chars)

def plot_waveform(
    signal: np.ndarray,
    bit_rate: float,
    sampling_freq: float,
    title: str = "Baseband BPSK Modulated Signal",
    figsize=(15, 4),
):
    """
    Plots a baseband BPSK signal using seaborn/matplotlib.

    Parameters
    ----------
    signal : np.ndarray
        The modulated baseband signal (1D array).
    bit_rate : float
        Bit rate in bits per second.
    sampling_freq : float
        Sampling frequency in Hz.
    title : str
        Plot title.
    figsize : tuple
        Size of the figure.
    """
    sns.set_theme(style="whitegrid")
    
    bit_duration = 1 / bit_rate
    total_time = len(signal) / sampling_freq
    t = np.linspace(0, total_time, len(signal))

    fig, ax = plt.subplots(figsize=figsize)
    ax.plot(t, signal, color=sns.color_palette("muted")[0], lw=2, label="BPSK signal")

    ax.set_title(title, fontsize=14)
    ax.set_xlabel("Time [s]")
    ax.set_ylabel("Amplitude")
    ax.set_xlim(0, total_time)
    sns.despine()
    plt.tight_layout()
    plt.show()

def plot_fft(
    signals: list,
    sampling_freq: float,
    labels: list = None,
    normalize: bool = True,
    xlim: tuple = None,
    title: str = "FFT Spectrum",
    figsize: tuple = (16, 8)
):
    """
    Plot the FFT magnitude spectrum of one or more signals.

    Parameters
    ----------
    signals : list of np.ndarray
        List of 1D signals (same length preferred).
    sampling_freq : float
        Sampling frequency in Hz.
    labels : list of str, optional
        Labels for each signal in the legend.
    window : str, optional
        Window function name (e.g., 'hamming', 'hann').
    normalize : bool
        If True, normalize magnitude to [0, 1].
    xlim : tuple, optional
        Limits for x-axis (e.g., (0, 5000)).
    title : str
        Title of the plot.
    figsize : tuple
        Size of the figure.
    """
    sns.set_theme(style="whitegrid")

    plt.figure(figsize=figsize)

    for i, sig in enumerate(signals):
        N = len(sig)

        fft_vals = np.fft.fft(sig)
        fft_freqs = np.fft.fftfreq(N, d=1/sampling_freq)

        # Keep only positive frequencies
        mask = fft_freqs >= 0
        fft_freqs = fft_freqs[mask]
        fft_mags = np.abs(fft_vals[mask])

        if normalize:
            fft_mags /= np.max(fft_mags)

        label = labels[i] if labels and i < len(labels) else f"Signal {i+1}"
        plt.plot(fft_freqs, fft_mags, label=label)

    plt.title(title, fontsize=14)
    plt.xlabel("Frequency [Hz]")
    plt.ylabel("Normalized Magnitude" if normalize else "Magnitude")
    if xlim:
        plt.xlim(xlim)
    plt.legend()
    plt.grid(True, linestyle='--', alpha=0.5)
    plt.tight_layout()
    plt.show()

from scipy.signal import convolve

class BPSKModulator:
    def __init__(self, bit_rate: float, carrier_freq: float, sample_rate: float):
        """
        Initializes the BPSKModulator with specified parameters.
        
        Parameters
        ----------
        bit_rate : float
            Bit rate of the input signal in bits per second.
        carrier_freq : float
            Frequency of the carrier signal in Hz.
        sample_rate : float
            Sampling rate for the modulation process in Hz.
        """
        self.bit_rate = bit_rate
        self.carrier_freq = carrier_freq
        self.sample_rate = sample_rate

    def _generate_baseband_waveform(self, bitstream: np.ndarray) -> np.ndarray:
        """
        Generates the baseband waveform for BPSK modulation.

        Each bit in the input bitstream is represented as a rectangular pulse:
        - A '1' bit is represented by a pulse of +1.
        - A '0' bit is represented by a pulse of -1.

        Parameters
        ----------
        bitstream : np.ndarray
            1D NumPy array of integers (0s and 1s), representing the bitstream.

        Returns
        -------
        np.ndarray
            Array containing the generated baseband waveform samples.
        """
        samples_per_bit = int(self.sample_rate / self.bit_rate)             # Hidden from students
        baseband_waveform = np.repeat(2 * bitstream - 1, samples_per_bit)   # Hidden from students
        return baseband_waveform

    def _generate_carrier(self, nb_samples: int) -> np.ndarray:
        """
        Generates a carrier wave for BPSK modulation.

        The carrier wave is a cosine wave with a frequency defined by carrier frequency (class variable).

        Parameters
        ----------
        nb_samples : int
            Number of samples to generate for the carrier wave.
        Returns
        -------
        np.ndarray
            Array containing the generated carrier wave samples.
        """
        t = np.arange(nb_samples) / self.sample_rate                        # Hidden from students
        carrier = np.cos(2 * np.pi * self.carrier_freq * t)                 # Hidden from students
        return carrier

    def _rrc_filter(
        self,
        signal: np.ndarray,
        alpha: float = 0.35,
        span: int = 6,
        sps: int = None
    ) -> np.ndarray:
        """
        Applies a Root Raised Cosine (RRC) filter to the input signal.
        
        Parameters
        ----------
        signal : np.ndarray
            The input signal to filter.
        alpha : float, optional
            Roll-off factor (0 < alpha ≤ 1). Default is 0.35.
        span : int, optional
            The number of symbols the filter spans. Default is 6.
        sps : int, optional
            Samples per symbol (default inferred from sample_rate and bit_rate).

        Returns
        -------
        np.ndarray
            The filtered signal.
        """
        if sps is None:
            sps = int(self.sample_rate / self.bit_rate)

        # Time vector for the filter taps
        t = np.arange(-span / 2, span / 2 + 1/sps, 1/sps)

        # Avoid division by zero
        t = np.where(t == 0, 1e-8, t)

        pi_t = np.pi * t
        four_alpha_t = 4 * alpha * t

        numerator = np.sin(pi_t * (1 - alpha)) + 4 * alpha * t * np.cos(pi_t * (1 + alpha))
        denominator = pi_t * (1 - (four_alpha_t) ** 2)
        h = numerator / denominator

        # Handle NaNs or division artifacts
        h = np.nan_to_num(h)

        # Normalize filter energy
        h /= np.sqrt(np.sum(h ** 2))

        # Filter the signal via convolution
        filtered_signal = convolve(signal, h, mode='same')

        return filtered_signal


    def modulate(self, bitstream: np.ndarray) -> np.ndarray:
        """
        Modulates the input bitstream using BPSK modulation.

        The modulation process involves generating a baseband waveform from the bitstream,
        creating a carrier wave, and then multiplying the baseband waveform with the carrier wave.
        A low-pass filter is applied to the modulated signal to smooth it.

        Parameters
        ----------
        bitstream : np.ndarray
            1D NumPy array of integers (0s and 1s), representing the bitstream to be modulated.

        Returns
        -------
        np.ndarray
            1D NumPy array representing the modulated BPSK signal.
        """        
        baseband_waveform = self._generate_baseband_waveform(bitstream)                         # Hidden from students
        filtered_baseband = self._rrc_filter(baseband_waveform)                                 # Hidden from students

        carrier = self._generate_carrier(len(filtered_baseband))                                # Hidden from students

        modulated_signal = filtered_baseband * carrier                                          # Hidden from students

        return modulated_signal
    
    def demodulate(self, received_signal: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
        """
        Demodulates the received BPSK signal to recover the original bitstream.

        The demodulation process involves multiplying the received signal with the carrier wave,
        applying a low-pass filter to extract the baseband signal, and then sampling the baseband
        signal to determine the transmitted bits.

        Parameters
        ----------
        received_signal : np.ndarray
            1D NumPy array representing the received BPSK signal.

        Returns
        -------
        Tuple[np.ndarray, np.ndarray]
            A tuple containing:
            - 1D NumPy array representing the recovered bitstream (0s and 1s).
            - 1D NumPy array representing the mixed signal before filtering.
        """
        
        carrier = self._generate_carrier(len(received_signal))              # Hidden from students

        mixed_signal = received_signal * carrier                            # Hidden from students
        filtered_signal = self._rrc_filter(mixed_signal)                    # Hidden from students

        samples_per_bit = int(self.sample_rate / self.bit_rate)             # Hidden from students
        nb_samples = len(received_signal)                                   # Hidden from students
        recovered_bitstream = np.zeros(nb_samples // samples_per_bit)       # Hidden from students
        
        # Hidden from students
        for i in range(nb_samples // samples_per_bit):
            bit_chunk = filtered_signal[i * samples_per_bit : (i + 1) * samples_per_bit]
            recovered_bitstream[i] = 1 if np.sum(bit_chunk) > 0 else 0
        
        return recovered_bitstream.astype(int), mixed_signal

bpsk_mod = BPSKModulator(bit_rate=1000, carrier_freq=10000, sample_rate=100000)

# Generate the bitstream
bitstream = string2bitstream("This Lab is amazing!")

# Create the BPSK Baseband Waveform
baseband_waveform = bpsk_mod._generate_baseband_waveform(bitstream)

# Visualize the Baseband Waveform
plot_waveform(
    signal=baseband_waveform,
    bit_rate=bpsk_mod.bit_rate,
    sampling_freq=bpsk_mod.sample_rate,
    title="Baseband BPSK Signal",
)

plot_fft(
    signals=[baseband_waveform],
    sampling_freq=bpsk_mod.sample_rate,
    labels=["Baseband BPSK"],
    xlim=(0, 15000),
    title="FFT of Baseband BPSK Signal",
    normalize=False
)

# Filter the baseband signal to limit its bandwidth
filtered_baseband = bpsk_mod._rrc_filter(baseband_waveform)

# Visualize the FFT comparison between original and filtered baseband signals
plot_fft(
    signals=[baseband_waveform, filtered_baseband],
    sampling_freq=bpsk_mod.sample_rate,
    labels=["Original Baseband BPSK", "Filtered Baseband BPSK"],
    xlim=(0, 15000),
    title="FFT of Filtered and Original Baseband BPSK Signal"
)

# Visualize the Filtered Baseband Waveform
plot_waveform(
    signal=filtered_baseband,
    bit_rate=bpsk_mod.bit_rate,
    sampling_freq=bpsk_mod.sample_rate,
    title="Filtered Baseband BPSK Signal",
)

modulated_signal = bpsk_mod.modulate(bitstream)

plot_waveform(
    signal=modulated_signal[:2000],
    bit_rate=bpsk_mod.bit_rate,
    sampling_freq=bpsk_mod.sample_rate,
    title="BPSK Modulated Signal",
)

plot_fft(
    signals=[baseband_waveform, modulated_signal],
    sampling_freq=bpsk_mod.sample_rate,
    labels=["Original Baseband BPSK", "Modulated BPSK"],
    xlim=(0, 15000),
    title="FFT of Modulated and Original Baseband BPSK Signal",
)

restored_bitstream, mixed_signal = bpsk_mod.demodulate(modulated_signal)

restored_message = bitstream2string(restored_bitstream)
print("Restored Message:", restored_message)

plot_fft(
    signals=[mixed_signal],
    sampling_freq=bpsk_mod.sample_rate,
    labels=["Mixed Signal"],
    xlim=(0, 25000),
    title="FFT of Mixed Signal Before Filtering",
)

Restored Message: This Lab is amazing!

with schemdraw.Drawing() as d:
    d.config(unit=3)
    d.push()
    elm.Inductor2().left().flip().label('L')
    elm.SourceSin().down()
    elm.Ground().right()
    d.pop()
    C = elm.Capacitor2().down().label('C')
    elm.Line().left()
    d.pop()
    elm.Line().right(1.5).at(C.start)
    R = elm.Resistor().down().label('R')
    elm.Line().left(1.5)
    d.pop()
    elm.Line().right(1).at(R.start)
    elm.Line().right(1).at(R.end)
    elm.Gap().toy(R.start).label(['-', '$V_{out}$', '+'])

def size_lp_filter(zeta: float, f_c: float, L: float = 10e-6) -> Tuple[float, float, float]:
    """
    Computes the values of R and C for a second-order low-pass RLC filter given the damping factor (zeta),
    cutoff frequency (f_c), and inductance (L).

    Parameters
    ----------
    zeta : float
        Damping factor of the filter.
    f_c : float
        Cutoff frequency in Hz.
    L : float
        Inductance in Henry.

    Returns
    -------
    Tuple[float, float, float]
        A tuple containing:
        - R : Resistance in Ohms.
        - C : Capacitance in Farads.
        - L : Inductance in Henry (same as input).
    """
    omega_c = 2 * np.pi * f_c                   # Hidden from students
    C = 1 / (L * (omega_c ** 2))                # Hidden from students
    R = 1 / (2 * zeta) * np.sqrt(L / C)         # Hidden from students
    print(f"Zeta = {zeta:.2f} => R: {R:.2f} Ohms, C: {C*1e9:.2f} nF, L: {L*1e6:.2f} uH")
    return R, C, L

def plot_bode(
    RLC: List[Tuple[float, float, float]],
    dB=True,
    deg=True,
    freq_range=None,
    title='Bode Diagram',
    figsize=(10, 6)
) -> None:
    """
    Plots the Bode diagram (magnitude and phase) for one or more RLC low-pass filters.

    Parameters
    ----------
    RLC : List[Tuple[float, float, float]]
        List of tuples, each containing (R, C, L) values for the filters.
    dB : bool
        If True, plot magnitude in dB. Default is True.
    deg : bool
        If True, plot phase in degrees. Default is True.
    freq_range : tuple, optional
        Frequency range for the x-axis (min_freq, max_freq). Default is None (auto).
    title : str
        Title of the plot.
    figsize : tuple
        Size of the figure.
    """
    sns.set_theme(style="whitegrid")
    
    plt.figure(figsize=figsize)

    for rlc in RLC:
        r, c, l = rlc
        zeta = 1/(2*r) * np.sqrt(l/c)       # Hidden from students
        omega_0 = 1/np.sqrt(l*c)            # Hidden from students
        num = [1]
        den = [1/(omega_0**2), 2*zeta/omega_0, 1]

        # Frequency response
        w = np.logspace(1, 8, 1000) if freq_range is None else np.logspace(np.log10(freq_range[0]), np.log10(freq_range[1]), 1000)
        s = 1j * w
        H = np.polyval(num, s) / np.polyval(den, s)

        magnitude = 20 * np.log10(np.abs(H)) if dB else np.abs(H)
        phase = np.angle(H, deg=deg)

        label = f'$\\zeta$={zeta:.2f}'
        plt.subplot(2, 1, 1)
        plt.semilogx(w/(2*np.pi), magnitude, label=label)
        plt.title(title)
        plt.ylabel('Magnitude (dB)' if dB else 'Magnitude')
        plt.grid(True, which='both', linestyle='--', alpha=0.5)

        plt.subplot(2, 1, 2)
        plt.semilogx(w/(2*np.pi), phase, label=label)
        plt.xlabel('Frequency (Hz)')
        plt.ylabel('Phase (degrees)' if deg else 'Phase (radians)')
        plt.grid(True, which='both', linestyle='--', alpha=0.5)

    plt.subplot(2, 1, 1)
    plt.legend()
    plt.tight_layout()
    plt.show()

zeta_values = [0.01, 0.1, np.sqrt(2), 1]
RLC = [size_lp_filter(zeta=zeta, f_c=100e3) for zeta in zeta_values]

plot_bode(
    RLC=RLC,
    freq_range=(1e3, 10e8),
    title='Bode Diagram of RLC Low-Pass Filters'
)

Zeta = 0.01 => R: 314.16 Ohms, C: 253.30 nF, L: 10.00 uH
Zeta = 0.10 => R: 31.42 Ohms, C: 253.30 nF, L: 10.00 uH
Zeta = 1.41 => R: 2.22 Ohms, C: 253.30 nF, L: 10.00 uH
Zeta = 1.00 => R: 3.14 Ohms, C: 253.30 nF, L: 10.00 uH

Lab 1: BPSK Modulation and RLC Filterings
¶

Welcome to the first lab of the EE-426 course!¶

Lab Outline¶

Part 1: BPSK Modulation System¶

Part 2: RLC Low-Pass Filter¶

Part 1: BPSK Modulation System¶

Digital Communication Basics¶

Why Do We Use a Carrier?¶

What is BPSK?¶

Why Use BPSK?¶

Code¶

Step 1: Generate the Baseband Waveform¶

Step 2: Generate the Carrier Wave¶

Step 3: Generate the modulated signal¶

Step 4: Restore the Signal¶

Part 2: RLC Filtering¶

Theoretical Analysis¶

Lab 1: BPSK Modulation and RLC Filterings¶

Welcome to the first lab of the EE-426 course!¶

Lab Outline¶

Part 1: BPSK Modulation System¶

Part 2: RLC Low-Pass Filter¶

Part 1: BPSK Modulation System¶

Digital Communication Basics¶

Why Do We Use a Carrier?¶

What is BPSK?¶

Why Use BPSK?¶

Code¶

Step 1: Generate the Baseband Waveform¶

Step 2: Generate the Carrier Wave¶

Step 3: Generate the modulated signal¶

Step 4: Restore the Signal¶

Part 2: RLC Filtering¶

Theoretical Analysis¶

Lab 1: BPSK Modulation and RLC Filterings
¶