Digital modulation (ASK, FSK, PSK) in Signal Processing

Introduction

Digital modulation changes digital data into signals that can travel over wires or air. It helps send information like voice or text clearly and efficiently.

Sending data over radio waves like Wi-Fi or Bluetooth

Transmitting information in mobile phone networks

Communicating between satellites and ground stations

Sending digital TV or radio signals

Connecting devices in wired networks like Ethernet

Syntax

Signal Processing

ModulatedSignal = CarrierSignal * DataSignal (for ASK)
ModulatedSignal = sin(2πf_c t + DataPhase) (for PSK)
ModulatedSignal = sin(2πf(t) t) (for FSK)

ASK changes the amplitude (height) of the carrier wave based on data.

FSK changes the frequency (speed of wave cycles) based on data.

PSK changes the phase (shift in wave start) based on data.

Examples

Amplitude changes between zero and full based on data bit (0 or 1).

Signal Processing

ASK: ModulatedSignal = DataBit * CarrierAmplitude * sin(2πf_c t)

Frequency switches between two values depending on data bit.

Signal Processing

FSK: ModulatedSignal = sin(2πf_0 t) if bit=0 else sin(2πf_1 t) if bit=1

Phase shifts by 0 or 180 degrees depending on data bit.

Signal Processing

PSK: ModulatedSignal = sin(2πf_c t + π * bit)

Sample Program

This code creates simple ASK, FSK, and PSK signals for a short sequence of bits and plots them. You can see how the wave changes shape for each modulation type.

Signal Processing

import numpy as np
import matplotlib.pyplot as plt

# Parameters
fs = 1000  # Sampling frequency
f_c = 5    # Carrier frequency
T = 1      # Signal duration in seconds
t = np.linspace(0, T, fs, endpoint=False)

# Data bits to send
bits = [0, 1, 0, 1]

# Repeat each bit for equal time segments
bit_duration = T / len(bits)

# Create ASK signal
ask_signal = np.array([])
for bit in bits:
    carrier = np.sin(2 * np.pi * f_c * np.linspace(0, bit_duration, int(fs * bit_duration), endpoint=False))
    ask_signal = np.concatenate((ask_signal, bit * carrier))

# Create FSK signal
f0, f1 = 3, 8  # Frequencies for 0 and 1
fsk_signal = np.array([])
for bit in bits:
    freq = f0 if bit == 0 else f1
    signal = np.sin(2 * np.pi * freq * np.linspace(0, bit_duration, int(fs * bit_duration), endpoint=False))
    fsk_signal = np.concatenate((fsk_signal, signal))

# Create PSK signal
psk_signal = np.array([])
for bit in bits:
    phase = 0 if bit == 0 else np.pi
    signal = np.sin(2 * np.pi * f_c * np.linspace(0, bit_duration, int(fs * bit_duration), endpoint=False) + phase)
    psk_signal = np.concatenate((psk_signal, signal))

# Plot all signals
plt.figure(figsize=(12, 8))
plt.subplot(3,1,1)
plt.title('ASK Signal')
plt.plot(np.linspace(0, T, fs), ask_signal)
plt.ylim(-1.5, 1.5)

plt.subplot(3,1,2)
plt.title('FSK Signal')
plt.plot(np.linspace(0, T, fs), fsk_signal)
plt.ylim(-1.5, 1.5)

plt.subplot(3,1,3)
plt.title('PSK Signal')
plt.plot(np.linspace(0, T, fs), psk_signal)
plt.ylim(-1.5, 1.5)

plt.tight_layout()
plt.show()

Important Notes

Digital modulation helps send data over noisy channels by changing wave properties.

ASK is simple but less resistant to noise than FSK or PSK.

PSK is widely used in modern communication for its efficiency and noise resistance.

Summary

Digital modulation changes carrier waves to represent data bits.

ASK changes amplitude, FSK changes frequency, PSK changes phase.

These methods help send digital data over different communication channels.

Practice

1. Which digital modulation technique changes the amplitude of the carrier wave to represent data bits?

easy

A. Phase Shift Keying (PSK)

B. Amplitude Shift Keying (ASK)

C. Frequency Shift Keying (FSK)

D. Pulse Code Modulation (PCM)

Solution

1. Step 1: Understand modulation types

   ASK changes the amplitude of the carrier wave to represent data bits, while FSK changes frequency and PSK changes phase.

2. Step 2: Match modulation to description

   The question asks for the technique that changes amplitude, which is ASK.

3. Final Answer:

   Amplitude Shift Keying (ASK) -> Option B

4. Quick Check:

   Amplitude change = ASK [OK]

Hint: ASK changes amplitude, FSK frequency, PSK phase [OK]

Common Mistakes:

• Confusing ASK with FSK or PSK
• Choosing PCM which is not a modulation technique
• Mixing phase and amplitude changes

2. Which of the following is the correct Python syntax to generate a Frequency Shift Keying (FSK) signal using numpy arrays for two frequencies f1 and f2?

easy

A. signal = np.sin(2 * np.pi * f1 * t) + np.sin(2 * np.pi * f2 * t)

B. signal = np.cos(2 * np.pi * f1 * t) + np.cos(2 * np.pi * f2 * t)

C. signal = np.sin(2 * np.pi * f1 * t) * np.sin(2 * np.pi * f2 * t)

D. signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t)

Solution

1. Step 1: Understand FSK signal generation

   FSK uses one frequency for bit 0 and another for bit 1, so the signal switches frequency based on the bit.

2. Step 2: Check syntax for conditional frequency

   signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t) uses a conditional expression to select frequency based on bit, which is correct for FSK.

3. Final Answer:

   signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t) -> Option D

4. Quick Check:

   Conditional frequency selection = signal = np.sin(2 * np.pi * (f1 if bit == 0 else f2) * t) [OK]

Hint: FSK switches frequency based on bit using conditional [OK]

Common Mistakes:

• Adding two sine waves instead of switching frequency
• Multiplying sine waves which is incorrect
• Using cosine instead of sine without reason

3. Given the following Python code snippet for Phase Shift Keying (PSK), what will be the output signal array for bits = [0, 1] and phase0 = 0, phase1 = pi?

import numpy as np
t = np.linspace(0, 1, 5)
bits = [0, 1]
phase0 = 0
phase1 = np.pi
signal = np.array([np.cos(2 * np.pi * 1 * t + (phase0 if bit == 0 else phase1)) for bit in bits])
print(signal)

medium

A. [[ 1. 0. -1. 0. 1.]
[-1. 0. 1. 0. -1.]]

B. [[ 0. 0. 0. 0. 0.]
[ 1. 1. 1. 1. 1.]]

C. [[ 1. 0. -1. 0. 1.]
[ 1. 0. -1. 0. 1.]]

D. [[ 1. 1. 1. 1. 1.]
[ 1. 1. 1. 1. 1.]]

Solution

1. Step 1: Calculate cosine values for bit 0

   For bit 0, phase = 0, t = np.linspace(0,1,5) = [0, 0.25, 0.5, 0.75, 1], angles = 2πt = [0, π/2, π, 3π/2, 2π], cos = [1, 0, -1, 0, 1].

2. Step 2: Calculate cosine values for bit 1

   For bit 1, phase = π, angles = 2πt + π, cos(θ + π) = -cos(θ) = [-1, 0, 1, 0, -1].

3. Final Answer:

   [[ 1. 0. -1. 0. 1.] [-1. 0. 1. 0. -1.]] -> Option A

4. Quick Check:

   PSK phase shift: cos(θ + π) = -cos(θ) [OK]

Hint: PSK phase π: cos(θ + π) = -cos(θ) [OK]

Common Mistakes:

• Confusing phase shift effect on cosine
• Misinterpreting array shape or values
• Ignoring phase addition in cosine

4. The following code attempts to generate an ASK signal but produces an error. What is the error and how to fix it?

import numpy as np
bit = 0
t = np.linspace(0, 1, 100)
f = 5
signal = np.sin(2 * np.pi * f * t) if bit == 1 else 0
print(signal)

medium

A. Error: signal is assigned a scalar 0 instead of an array; fix by replacing 0 with np.zeros_like(t)

B. Error: np.sin requires integer input; fix by casting t to int

C. Error: Missing parentheses in np.sin; fix by adding parentheses

D. No error; code runs correctly

Solution

1. Step 1: Identify the error in conditional assignment

   If bit == 1, signal is an array from np.sin, else signal is scalar 0, causing inconsistent types.

2. Step 2: Fix by using array of zeros

   Replace 0 with np.zeros_like(t) to keep signal as an array in both cases.

3. Final Answer:

   Error: signal is assigned a scalar 0 instead of an array; fix by replacing 0 with np.zeros_like(t) -> Option A

4. Quick Check:

   Consistent array types needed = Error: signal is assigned a scalar 0 instead of an array; fix by replacing 0 with np.zeros_like(t) [OK]

Hint: Use np.zeros_like(t) for zero arrays, not scalar 0 [OK]

Common Mistakes:

• Using scalar 0 causing type mismatch
• Casting t to int which is unnecessary
• Ignoring conditional expression structure

5. You want to design a digital communication system that must be robust to amplitude noise but can tolerate frequency variations. Which modulation technique should you choose and why?

hard

A. ASK, because it changes amplitude which is sensitive to noise

B. ASK, because it changes phase which is robust to amplitude noise

C. FSK, because it changes frequency which is less affected by amplitude noise

D. PSK, because it changes phase which is sensitive to frequency noise

Solution

1. Step 1: Analyze noise tolerance requirements

   The system must be robust to amplitude noise, so modulation should not rely on amplitude changes.

2. Step 2: Match modulation to noise tolerance

   FSK changes frequency, which is less affected by amplitude noise, making it suitable. ASK changes amplitude and is sensitive to amplitude noise. PSK changes phase and can be sensitive to frequency noise.

3. Final Answer:

   FSK, because it changes frequency which is less affected by amplitude noise -> Option C

4. Quick Check:

   Amplitude noise robustness = FSK [OK]

Hint: Choose FSK to avoid amplitude noise sensitivity [OK]

Common Mistakes:

• Choosing ASK despite amplitude noise sensitivity
• Confusing phase noise sensitivity with frequency noise
• Misunderstanding modulation noise robustness