Digital modulation (ASK, FSK, PSK) in Signal Processing - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to generate an ASK modulated signal.

Signal Processing

import numpy as np

bit = 1
carrier_freq = 5
sampling_rate = 100

time = np.linspace(0, 1, sampling_rate)
carrier = np.sin(2 * np.pi * carrier_freq * time)

ask_signal = carrier * [1]

Drag options to blanks, or click blank then click option'

Asampling_rate

Btime

Cbit

Dcarrier_freq

Attempts:

3 left

💡 Hint

Common Mistakes

Using time or frequency instead of the bit value to modulate amplitude.

Forgetting to multiply the carrier by the bit.

The ASK signal is the carrier multiplied by the bit value (0 or 1).

2fill in blank

medium

Complete the code to generate an FSK modulated signal for bit 0 or 1.

Signal Processing

import numpy as np

bit = 0
freq0 = 5
freq1 = 10
sampling_rate = 100

time = np.linspace(0, 1, sampling_rate)
freq = [1]
fsk_signal = np.sin(2 * np.pi * freq * time)

Drag options to blanks, or click blank then click option'

Afreq0 if bit == 0 else freq1

Bfreq1 if bit == 0 else freq0

Cfreq0 + freq1

Dfreq0 - freq1

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping freq0 and freq1 conditions.

Adding or subtracting frequencies instead of selecting one.

FSK uses different frequencies for bit 0 and bit 1. We select freq0 if bit is 0, else freq1.

3fill in blank

hard

Fix the error in the PSK signal generation code by filling the blank.

Signal Processing

import numpy as np

bit = 1
carrier_freq = 5
sampling_rate = 100

time = np.linspace(0, 1, sampling_rate)
phase = [1]
psk_signal = np.sin(2 * np.pi * carrier_freq * time + phase)

Drag options to blanks, or click blank then click option'

Anp.pi if bit == 1 else 0

B0 if bit == 1 else np.pi

Cnp.pi / 2

Dbit * np.pi / 2

Attempts:

3 left

💡 Hint

Common Mistakes

Reversing the phase values for bits.

Using fixed phase without condition.

PSK changes the phase by π when bit is 1, else phase is 0.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension mapping bits to their ASK signals.

Signal Processing

bits = [0, 1]
carrier_freq = 5
sampling_rate = 100
import numpy as np

time = np.linspace(0, 1, sampling_rate)
ask_signals = {bit: np.sin(2 * np.pi * carrier_freq * time) * [1] for bit in bits if bit [2] 1}

Drag options to blanks, or click blank then click option'

Abit

B==

C!=

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' in the condition.

Multiplying by time or frequency instead of bit.

The dictionary comprehension creates ASK signals for bits equal to 1 by multiplying the carrier by the bit value.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension mapping bits to their PSK signals with phase shifts.

Signal Processing

bits = [0, 1]
carrier_freq = 5
sampling_rate = 100
import numpy as np

time = np.linspace(0, 1, sampling_rate)
psk_signals = { [1]: np.sin(2 * np.pi * carrier_freq * time + [2]) for [3] in bits }

Drag options to blanks, or click blank then click option'

Abit

Bnp.pi if bit == 1 else 0

Dbits

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'bits' instead of 'bit' as the loop variable.

Not using conditional phase shift.

The dictionary comprehension maps each bit to a PSK signal with phase π if bit is 1, else 0.

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