In [8]:

import radarsimpy

print("`RadarSimPy` used in this example is version: " + str(radarsimpy.__version__))

`RadarSimPy` used in this example is version: 15.2.0

PMCW Radar: Phase-Modulated Continuous Wave¶

Introduction¶

PMCW (Phase-Modulated Continuous Wave) radar modulates the phase of a constant-frequency carrier using binary code sequences (BPSK) instead of sweeping the frequency like FMCW.

The transmitted signal is:

$$s(t) = A \cos(2\pi f_c t + \phi(t)), \qquad \phi(t) \in \{0°, 180°\}$$

Range is extracted from code correlation delay $\tau$:

$$\Delta R = \frac{c \cdot T_{chip}}{2}$$

Maximum unambiguous velocity is chip-duration limited:

$$v_{max} = \frac{c}{2 f_c T_{chip}}$$

For 24.125 GHz with $T_{chip} = 4$ ns: $v_{max} \approx 1550$ m/s — far beyond FMCW's typical 30–100 m/s.

PMCW vs. FMCW¶

Feature	FMCW	PMCW
Modulation	Frequency chirp	Phase code (BPSK)
Range	Beat frequency	Code correlation
Max velocity	~30–100 m/s	~1550 m/s (chip-limited)
Interference	Sensitive	Orthogonal code rejection
MIMO	Limited	Code-division multiplexing
Sampling rate	~MHz (beat freq)	~250 MHz (chip rate)

This Example¶

Uses RadarSimPy to simulate a 2-channel MIMO PMCW radar:

Carrier: 24.125 GHz, 255-chip binary codes at 4 ns/chip (1.02 μs)
MIMO: TX1 at (0, 0, 0) m and TX2 at (1, 0, 0) m with orthogonal codes
256 pulses for Doppler processing
3 targets: −200 m/s at 20 m, 0 m/s at 70 m, +100 m/s at ~34 m
Processing: matched filtering → MIMO channel separation → range-Doppler maps

Phase Code Definition¶

Define binary BPSK phase code sequences for both MIMO channels.

In [9]:

import numpy as np
import plotly.graph_objs as go
from IPython.display import Image, display
from radarsimpy import Radar, Transmitter, Receiver
from radarsimpy.simulator import sim_radar
from scipy import signal

INTERACTIVE = False

def show(fig):
    if INTERACTIVE:
        fig.show()
    else:
        display(Image(fig.to_image(format="jpg", scale=2)))

In [10]:

### Phase Code Sequences ###

# Define binary phase code 1 (255 chips)
# Values: +1 or -1 (will be converted to 0° or 180° phase)
code1 = np.array(
    [
        1,  -1, 1,  1,  -1, -1, -1, 1,  -1, 1,  -1, 1,  1,  1,  -1, 1,  1,
        -1, -1, 1,  1,  1,  -1, -1, -1, -1, 1,  -1, -1, 1,  -1, -1, 1,  1,
        1,  1,  1,  -1, 1,  1,  1,  -1, -1, 1,  -1, 1,  1,  -1, 1,  -1, -1,
        -1, -1, -1, 1,  1,  -1, 1,  -1, 1,  -1, -1, 1,  -1, -1, -1, 1,  1,
        -1, -1, 1,  -1, 1,  -1, 1,  1,  -1, -1, -1, -1, 1,  1,  1,  1,  -1,
        -1, 1,  1,  -1, 1,  1,  1,  1,  -1, -1, -1, 1,  -1, -1, -1, -1, -1,
        -1, 1,  -1, 1,  1,  1,  1,  1,  1,  -1, -1, 1,  -1, -1, 1,  1,  -1,
        -1, -1, -1, 1,  -1, -1, -1, -1, 1,  -1, 1,  -1, -1, 1,  1,  -1, -1,
        1,  1,  1,  -1, 1,  -1, 1,  1,  1,  -1, 1,  1,  1,  1,  1,  1,  1,
        -1, 1,  -1, -1, -1, 1,  -1, 1,  1,  -1, -1, 1,  1,  -1, 1,  -1, -1,
        1,  -1, 1,  1,  -1, 1,  1,  -1, -1, -1, 1,  -1, -1, 1,  -1, 1,  1,
        1,  -1, -1, -1, 1,  1,  1,  1,  1,  -1, 1,  -1, 1,  -1, 1,  -1, -1,
        -1, -1, 1,  1,  -1, 1,  1,  1,  -1, 1,  1,  -1, 1,  -1, -1, -1, 1,
        1,  1,  -1, -1, 1,  -1, -1, -1, 1,  -1, 1,  -1, 1,  -1, 1,  1,  1,
        1,  -1, 1,  1,  -1, 1,  -1, 1,  -1, -1, -1, -1, -1, 1,  -1, -1, 1,
    ]
)

# Define binary phase code 2 (255 chips, orthogonal to code1)
code2 = np.array(
    [
        1,  1,  1,  -1, -1, -1, -1, 1,  1,  -1, -1, 1,  -1, 1,  1,  -1, -1,
        1,  -1, 1,  -1, -1, 1,  -1, -1, 1,  1,  -1, 1,  1,  -1, 1,  -1, -1,
        -1, 1,  -1, 1,  1,  1,  1,  1,  -1, 1,  1,  1,  -1, -1, 1,  1,  -1,
        1,  1,  -1, -1, -1, -1, -1, -1, 1,  -1, 1,  1,  1,  1,  1,  1,  -1,
        -1, 1,  -1, -1, 1,  1,  -1, -1, -1, -1, 1,  -1, -1, -1, -1, 1,  -1,
        1,  -1, -1, 1,  1,  -1, -1, 1,  1,  1,  -1, 1,  -1, 1,  1,  1,  -1,
        1,  1,  1,  1,  1,  1,  1,  -1, 1,  -1, -1, -1, 1,  -1, 1,  1,  -1,
        1,  -1, -1, -1, 1,  1,  -1, -1, 1,  -1, 1,  -1, 1,  1,  -1, -1, -1,
        -1, 1,  1,  1,  1,  -1, -1, 1,  1,  -1, 1,  1,  1,  -1, 1,  -1, -1,
        1,  -1, 1,  1,  -1, 1,  1,  -1, -1, -1, 1,  -1, -1, 1,  -1, 1,  1,
        1,  -1, 1,  -1, 1,  -1, -1, -1, -1, 1,  1,  -1, 1,  1,  1,  -1, 1,
        1,  -1, 1,  -1, -1, -1, 1,  1,  1,  -1, -1, 1,  -1, -1, -1, 1,  -1,
        1,  1,  -1, -1, 1,  1,  -1, 1,  -1, -1, 1,  -1, -1, -1, -1, -1, 1,
        1,  -1, 1,  -1, 1,  -1, -1, 1,  -1, -1, -1, 1,  1,  -1, -1, 1,  -1,
        1,  -1, 1,  1,  1,  -1, 1,  1,  1,  1,  -1, -1, -1, 1,  -1, -1, 1,
    ]
)

# Convert ±1 binary codes to phase (degrees): +1 → 0°, -1 → 180°
phase_code1 = np.where(code1 > 0, 0, 180)   # TX channel 1 phase sequence
phase_code2 = np.where(code2 > 0, 0, 180)   # TX channel 2 phase sequence

# Define chip duration and timing
chip_duration = 4e-9  # 4 ns per chip

# Create time arrays for phase modulation (one entry per chip transition)
t_mod1 = np.arange(0, 255) * chip_duration  # 255 chip times for TX1
t_mod2 = np.arange(0, 255) * chip_duration  # 255 chip times for TX2

Visualize Phase Code Sequences¶

Display phase modulation sequences for both MIMO channels showing BPSK modulation pattern.

In [11]:

# Create figure for phase code visualization
fig = go.Figure()

# Plot phase code sequence 1 (TX channel 1)
fig.add_trace(
    go.Scatter(
        x=t_mod1 * 1e9,           # Convert to nanoseconds
        y=phase_code1,            # Phase in degrees
        name="Phase code 1 (TX1)",
        line=dict(color='blue', width=1),
        mode='lines',
    )
)

# Plot phase code sequence 2 (TX channel 2)
fig.add_trace(
    go.Scatter(
        x=t_mod2 * 1e9,           # Convert to nanoseconds
        y=phase_code2,            # Phase in degrees
        name="Phase code 2 (TX2)",
        line=dict(color='red', width=1),
        mode='lines',
    )
)

# Configure plot layout
fig.update_layout(
    title="Binary Phase Code Sequences: 255 Chips @ 4 ns/chip (BPSK)",
    yaxis=dict(
        title="Phase (degrees)",
        gridcolor='lightgray',
        tickvals=[0, 180],  # Only show 0° and 180°
    ),
    xaxis=dict(title="Time (ns)", gridcolor='lightgray'),
    height=500,
    legend=dict(x=0.02, y=0.98),
)

show(fig)

No description has been provided for this image

Radar System Configuration¶

Transmitter Configuration¶

Parameter	Value	Notes
Carrier frequency	24.125 GHz	Constant — no frequency modulation
Pulse duration	2.1 μs	Code (1.02 μs) + guard time
Transmit power	20 dBm	~100 mW
Pulses	256	For Doppler processing
TX1 location	(0, 0, 0) m	Phase code 1
TX2 location	(1, 0, 0) m	Phase code 2 (orthogonal), 1 m spacing

Both channels transmit simultaneously at the same carrier frequency; orthogonal codes enable receiver-side separation via matched filtering.

In [12]:

### Define TX Channel 1 with Phase Code 1 ###
tx_channel_1 = dict(
    location=(0, 0, 0),     # TX1 antenna position at origin
    mod_t=t_mod1,           # Phase modulation timing (255 points × 4 ns)
    phs=phase_code1,        # Phase sequence for channel 1 (0° or 180°)
)

### Define TX Channel 2 with Phase Code 2 ###
tx_channel_2 = dict(
    location=(1, 0, 0),     # TX2 antenna position 1m offset in X
    mod_t=t_mod2,           # Phase modulation timing (same as TX1)
    phs=phase_code2,        # Phase sequence for channel 2 (orthogonal code)
)

### Create PMCW Transmitter ###
tx = Transmitter(
    f=24.125e9,             # Carrier frequency: 24.125 GHz (constant, no chirp)
    t=2.1e-6,               # Pulse duration: 2.1 μs (includes code + guard time)
    tx_power=20,            # Transmit power: 20 dBm (~100 mW)
    pulses=256,             # Number of pulses: 256 (for Doppler processing)
    channels=[tx_channel_1, tx_channel_2],  # 2-channel MIMO configuration
)

Receiver Configuration¶

Parameter	Value	Notes
Sampling rate	250 MHz	4 ns/sample — matches chip duration
Noise figure	10 dB	—
RF gain	20 dB	—
Baseband gain	30 dB	Total: 50 dB
Load resistor	1000 Ω	—
Location	(0, 0, 0) m	Monostatic with TX1

PMCW requires a much higher sampling rate than FMCW because phase transitions (4 ns chips) must be captured directly, unlike FMCW which samples only the beat frequency (~MHz).

In [13]:

# Configure PMCW radar receiver
rx = Receiver(
    fs=250e6,            # Sampling rate: 250 MHz (4 ns per sample, matches chip rate)
    noise_figure=10,     # Noise figure: 10 dB
    rf_gain=20,          # RF gain: 20 dB
    baseband_gain=30,    # Baseband gain: 30 dB (total: 50 dB)
    load_resistor=1000,  # Load resistance: 1000 Ω
    channels=[dict(location=(0, 0, 0))],  # Single RX at origin
)

Create Radar System¶

Combine transmitter and receiver to form the complete PMCW MIMO radar.

In [14]:

# Create complete PMCW MIMO radar system
radar = Radar(transmitter=tx, receiver=rx)

Target Configuration¶

Three targets with velocities that exceed typical FMCW capability ($v_{max,FMCW} \approx 30$–100 m/s):

Target	Range	Velocity	RCS	Notes
1	20 m	−200 m/s	10 dBsm	Approaching at 720 km/h
2	70 m	0 m/s	35 dBsm	Stationary (large)
3	~34 m	+100 m/s	20 dBsm	Receding at 360 km/h

All targets are within PMCW's $v_{max} \approx 1550$ m/s without Doppler ambiguity.

In [15]:

# Configure Target 1: Very high closing speed (beyond FMCW capability)
target_1 = dict(
    location=(20, 0, 0),    # Position: 20m range
    speed=(-200, 0, 0),     # Velocity: -200 m/s (720 km/h approaching!)
    rcs=10,                 # Radar cross section: 10 dBsm
    phase=0,                # Initial phase: 0 degrees
)

# Configure Target 2: Stationary, large RCS (reference)
target_2 = dict(
    location=(70, 0, 0),    # Position: 70m range
    speed=(0, 0, 0),        # Velocity: 0 m/s (stationary)
    rcs=35,                 # Radar cross section: 35 dBsm (very large)
    phase=0,                # Initial phase: 0 degrees
)

# Configure Target 3: High receding speed
target_3 = dict(
    location=(33, 10, 0),   # Position: ~34m range, 10m Y-offset
    speed=(100, 0, 0),      # Velocity: +100 m/s (360 km/h receding)
    rcs=20,                 # Radar cross section: 20 dBsm
    phase=0,                # Initial phase: 0 degrees
)

# Combine targets for simulation
targets = [target_1, target_2, target_3]

Simulate Baseband Signals¶

Simulate PMCW baseband I/Q from both MIMO TX channels. Output shape: [2 TX channels, 256 pulses, ~525 samples/pulse].

In [16]:

# Simulate PMCW radar with 2-channel MIMO and three high-velocity targets
data = sim_radar(radar, targets)

# Extract timestamp and baseband signals
timestamp = data["timestamp"]                       # Time axis [2, 256, 525]
data_matrix = data["baseband"] + data["noise"]     # Complex I/Q + noise [2, 256, 525]

Combine Simultaneous TX Channels¶

In hardware, TX1 and TX2 transmit simultaneously — the RX receives their superposition. Sum both channel contributions to form the combined baseband [256 pulses, ~525 samples] before matched filtering.

In [17]:

# Combine baseband from both TX channels (simultaneous transmission)
# TX1 and TX2 signals are received together at RX
baseband = data_matrix[0, :, :] + data_matrix[1, :, :]  # [256 pulses, 525 samples]

Visualize Combined Baseband¶

Display time-domain I/Q signals showing superposition of both phase-coded TX channels.

In [24]:

# Create figure for combined baseband visualization
fig = go.Figure()

# Plot In-phase (I) component of first pulse
fig.add_trace(
    go.Scatter(
        x=timestamp[0, 0, :] * 1e6,     # Convert to microseconds
        y=np.real(baseband[0, :]),      # Real part (I channel)
        name="I (In-phase)",
    )
)

# Plot Quadrature (Q) component of first pulse
fig.add_trace(
    go.Scatter(
        x=timestamp[0, 0, :] * 1e6,     # Convert to microseconds
        y=np.imag(baseband[0, :]),      # Imaginary part (Q channel)
        name="Q (Quadrature)",
    )
)

# Configure plot layout
fig.update_layout(
    title="Combined Baseband I/Q: Superposition of Both MIMO Channels",
    yaxis=dict(title="Amplitude (V)", gridcolor='lightgray'),
    xaxis=dict(title="Time (μs)", gridcolor='lightgray'),
    height=500,
    legend=dict(x=0.02, y=0.98),
)

show(fig)

Radar Signal Processing¶

Matched Filtering (Code Correlation)¶

Range is extracted by correlating the received signal with each code:

$$R[n] = \sum_{k=0}^{N-1} s[k] \cdot c^*[k-n]$$

Due to low cross-correlation between orthogonal codes, correlating with code1 extracts TX1's contribution and code2 extracts TX2's — separating the two MIMO channels. Result: range profile matrix [2 channels, 256 pulses, 255 range bins].

Demodulate Channel 1¶

In [19]:

# Initialize range profile storage
# Dimensions: [2 MIMO channels, 256 pulses, 255 range bins]
range_profile = np.zeros(
    (
        radar.array_prop["size"],  # 2 TX channels (MIMO)
        radar.radar_prop["transmitter"].waveform_prop["pulses"],  # 256 pulses
        255,  # 255 range bins (one per chip offset)
    ),
    dtype=complex,  # Complex I/Q data
)

### Matched Filtering for Channel 1 (TX1 with code1) ###

# Loop over all pulses
for pulse_idx in range(0, radar.radar_prop["transmitter"].waveform_prop["pulses"]):
    # Loop over all range bins (delay offsets)
    for bin_idx in range(0, 255):
        # Correlate received signal with code1
        # Extract 255 samples starting at bin_idx
        # Multiply element-wise with code1 and sum (correlation)
        range_profile[0, pulse_idx, bin_idx] = np.sum(
            code1 * baseband[pulse_idx, bin_idx : (bin_idx + 255)]
        )

Demodulate Channel 2¶

Correlate with code2 to extract TX channel 2 contribution.

In [20]:

### Matched Filtering for Channel 2 (TX2 with code2) ###

# Loop over all pulses
for pulse_idx in range(0, radar.radar_prop["transmitter"].waveform_prop["pulses"]):
    # Loop over all range bins (delay offsets)
    for bin_idx in range(0, 255):
        # Correlate received signal with code2
        # Orthogonal code extracts TX2 contribution
        range_profile[1, pulse_idx, bin_idx] = np.sum(
            code2 * baseband[pulse_idx, bin_idx : (bin_idx + 255)]
        )

Visualize Range Profiles¶

Display averaged range profiles for both MIMO channels showing target detection.

In [21]:

# Calculate range bin size
# Range resolution = c / 2 × chip_duration
bin_size = 3e8 / 2 * 4e-9  # Speed of light / 2 × 4 ns = 0.6 m per bin

# Create range axis
range_bin = np.arange(0, 255, 1) * bin_size  # 255 bins × 0.6 m

# Create comparison figure
fig = go.Figure()

# Plot Channel 1 range profile (averaged over all pulses)
fig.add_trace(
    go.Scatter(
        x=range_bin,
        y=20 * np.log10(np.mean(np.abs(range_profile[0, :, :]), axis=0)),
        name="Channel 1 (TX1, code1)",
    )
)

# Plot Channel 2 range profile (averaged over all pulses)
fig.add_trace(
    go.Scatter(
        x=range_bin,
        y=20 * np.log10(np.mean(np.abs(range_profile[1, :, :]), axis=0)),
        name="Channel 2 (TX2, code2)",
    )
)

# Configure plot layout
fig.update_layout(
    title="Range Profiles: Both MIMO Channels Detect All Three Targets",
    yaxis=dict(title="Amplitude (dB)", gridcolor='lightgray'),
    xaxis=dict(title="Range (m)", gridcolor='lightgray'),
    height=500,
    legend=dict(x=0.02, y=0.98),
)

show(fig)

Doppler Processing¶

Apply Chebyshev-windowed FFT across pulses for each range bin:

$$v_{max} = \frac{c}{2 f_c \cdot PRP}$$

A 50-dB Chebyshev window suppresses sidelobes before the 256-point FFT. Result: range-Doppler map [2 channels, 256 Doppler bins, 255 range bins].

In [22]:

# Create Chebyshev window for Doppler FFT (50 dB sidelobe suppression)
doppler_window = signal.windows.chebwin(
    radar.radar_prop["transmitter"].waveform_prop["pulses"], at=50
)

# Initialize range-Doppler map storage
# Dimensions: [2 MIMO channels, 256 Doppler bins, 255 range bins]
range_doppler = np.zeros(np.shape(range_profile), dtype=complex)

# Perform Doppler FFT for each channel and range bin
for ii in range(0, radar.array_prop["size"]):  # Loop over MIMO channels (2)
    for jj in range(0, 255):  # Loop over range bins (255)
        # Apply window, FFT, and shift for each range bin
        range_doppler[ii, :, jj] = np.fft.fftshift(
            np.fft.fft(
                range_profile[ii, :, jj] * doppler_window,  # Window across pulses
                n=radar.radar_prop["transmitter"].waveform_prop["pulses"],  # 256-point FFT
            )
        )

# Calculate maximum unambiguous velocity
# v_max = c / (2 * f_c * PRP)
unambiguous_speed = (
    3e8  # Speed of light
    / radar.radar_prop["transmitter"].waveform_prop["prp"]  # Pulse repetition period
    / 24.125e9  # Carrier frequency
    / 2  # Two-way Doppler
)

Visualize Range-Doppler Map¶

Display 3D range-Doppler map for Channel 1 showing high-velocity targets.

Interpretation:

X-axis: Range (m) → Target distance
Y-axis: Velocity (m/s) → Radial velocity (negative = approaching, positive = receding)
Z-axis: Amplitude (dB) → Detection strength
Peaks: Three targets at their (range, velocity) coordinates

Expected Targets:

Target 1: ~20m, -200 m/s (very high closing speed)
Target 2: ~70m, 0 m/s (stationary)
Target 3: ~33m, +100 m/s (high receding speed)

PMCW Advantage:

All three targets are clearly resolved despite extreme velocities (±200 m/s) that would cause severe Doppler ambiguity in typical FMCW radar.

In [23]:

# Create range axis (same as before)
range_axis = np.arange(0, 255, 1) * bin_size  # 0 to ~153 m

# Create velocity axis (centered around zero)
doppler_axis = np.linspace(
    -unambiguous_speed / 2,  # Maximum approaching velocity
    unambiguous_speed / 2,   # Maximum receding velocity
    radar.radar_prop["transmitter"].waveform_prop["pulses"],  # 256 bins
    endpoint=False,
)

# Create 3D surface plot of range-Doppler map (Channel 1)
fig = go.Figure()
fig.add_trace(
    go.Surface(
        x=range_axis,                                  # Range axis (m)
        y=doppler_axis,                                # Velocity axis (m/s)
        z=20 * np.log10(np.abs(range_doppler[0, :, :])),  # Amplitude (dB) for channel 1
        colorscale="Rainbow",                          # Color scheme
        colorbar=dict(title="Amplitude (dB)"),
    )
)

# Configure 3D plot layout
fig.update_layout(
    title="Range-Doppler Map: PMCW Channel 1 (High-Velocity Targets)",
    height=800,
    scene=dict(
        xaxis=dict(title="Range (m)"),
        yaxis=dict(title="Velocity (m/s)"),
        zaxis=dict(title="Amplitude (dB)"),
        aspectmode="cube",
    ),
    margin=dict(l=0, r=0, b=0, t=40),
)

show(fig)

Summary¶

This example demonstrated a 2-channel MIMO PMCW radar with high-velocity target detection:

BPSK phase coding on a constant carrier enables range via code correlation, not beat frequency
$v_{max} \approx 1550$ m/s (chip-limited) far exceeds FMCW's typical 30–100 m/s range
Orthogonal codes allow simultaneous MIMO transmission and receiver-side channel separation
250 MHz sampling required to capture 4 ns chip transitions (much higher than FMCW)
Matched filtering provides range compression with processing gain equal to code length (255)
Doppler FFT across 256 pulses resolves all three targets from −200 m/s to +100 m/s

Things to Try¶

Experiment	What to Change	What to Observe
Code length	127 or 511 chips	Range resolution and processing gain
Chip duration	2, 8, 16 ns	Resolution vs. sampling rate
Number of pulses	128, 512	Velocity resolution vs. update rate
Carrier frequency	77 GHz	Doppler sensitivity ($f_d \propto f_c$)
Target velocity	±500 m/s	$v_{max}$ limits and ambiguity
MIMO scaling	3–4 TX channels	Virtual array size and angular resolution
Code selection	Gold, Kasami codes	Cross-correlation and interference rejection
Window functions	Hamming, Taylor	Sidelobe vs. resolution trade-off

1 comment

Hubert says:

March 19, 2025 at 8:59 am

Hi,
Excellent resource, thanks.
When plotting the range profile, we should first average the complex values and then take the absolute. This way we filter out complex noise better.
This becomes
y=20 * np.log10(np.abs(np.mean(range_profile[1, :, :], axis=0))),
Just a suggestion 🙂