---

name: matlab-design-radar-waveform description: > Design, select, and analyze waveforms for radar, sonar, and active sensing using the Phased Array System Toolbox. Covers LFM, NLFM, FMCW, phase-coded, CW, stepped FM, custom IQ, ambiguity functions, sidelobe reduction, and Doppler tolerance. Key objects: phased.LinearFMWaveform, phased.NonlinearFMWaveform, phased.CustomFMWaveform, phased.PhaseCodedWaveform, phased.FMCWWaveform, phased.SteppedFMWaveform, phased.MFSKWaveform, phased.RectangularWaveform, nlfmspec2freq, shapespectrum, ambgfun, pambgfun, sidelobelevel, legendreseq, mlseq, radarWaveformGenerator. keywords:

• waveform, signal, chirp, LFM, NLFM, FMCW, PMCW, pulse compression
• transmit signal, sidelobe, Doppler, range resolution, matched filter
• ambiguity, pulse, PRF, sweep, radar, sonar license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md metadata: author: MathWorks version: "1.1"

---

Radar Waveform Design

Design and select radar waveforms using the Phased Array System Toolbox. Use the decision tree to select the correct waveform object based on requirements, follow correct function-to-object pairings, and avoid common mistakes.

When to Use

Primary keywords (any of these alone can trigger the skill): waveform, signal, chirp, LFM, NLFM, FMCW, PMCW, pulse compression, transmit signal, M-sequence, MLS, PN code, spread spectrum, phase code, joint radar-communication, dual-function waveform

Sensing-context words (confirm sensing domain when paired with primary keywords): target, jammer, jamming, pulse, pulses, spectrum, sidelobe, Doppler, range resolution, detection, clutter, matched filter, ambiguity, sweep, PRF, PRI

Trigger logic:

• Primary keyword + sensing-context word → use this skill directly
• Primary keyword alone → ask: sensing or communications? (communications → skill does not apply)
• Sensing-context words + vague language ("a signal that changes each time") → use this skill

After triggering, clarify purpose and scope:

1. Purpose — application-driven or exploration/learning?

   • Exploration/learning (student, paper reproduction, comparing properties): proceed with given parameters, suggest radarWaveformGenerator. Do not push for application context.
   • Application-driven → clarify dimensions below.

2. Application dimensions (ask what's unknown — applies to any sensing application): Range scale | Target motion and velocity | Resolution need | Environment (clutter, jamming, interference) | Hardware limits (ADC, duty cycle) | Primary metric (detection, resolution, accuracy, or ambiguity-free)

3. Requirements — Derive waveform parameters from the answers above (see table below)

When NOT to Use

• Full radar system simulation (transmitter → channel → receiver chain)
• Beamforming or array design (use phased array skills)
• Target detection / CFAR processing
• Simulink waveform generation blocks
• Communications waveforms (OFDM, QAM, etc.)

Escalation / Boundary Conditions

Do not answer as if waveform choice alone solves:

• Range/velocity ambiguity resolution strategy (staggered PRF scheduling, medium-PRF processing)
• Tracker-level Doppler/range association
• Detailed receiver chain design (noise figure, dynamic range budgets)
• Clutter suppression design (MTI, STAP)
• Antenna/array pattern issues
• CFAR or detector performance questions

Instead, explain that the issue is system-level and identify what waveform-related part can still be addressed.

Workflow

1. Clarify requirements — Gather what the user hasn't specified (see table below)
2. Select waveform object — Use the decision tree below
3. Configure the waveform — Set properties based on requirements
4. Analyze — Use appropriate analysis function (ambgfun, pambgfun, sidelobelevel)
5. Suggest interactive exploration — Recommend radarWaveformGenerator app

Construction Rule (non-negotiable)

Always generate signals using toolbox System objects and functions — never manually construct exp(1j*...) or write custom LFSR/sequence generators. If mlseq, legendreseq, phased.LinearFMWaveform, or another toolbox function can produce what you need, use it. Manual construction is only acceptable when no toolbox equivalent exists for the specific operation (e.g., applying element-wise phase modulation to an existing waveform vector). For hybrid waveforms (e.g., LFM + communication encoding), generate the base with the appropriate object, apply the modification, then wrap the result with PhaseCodedWaveform using Code='Custom'. If no built-in object fits (e.g., exact DFT-bin nulls, non-contiguous bands), escalate to custom IQ synthesis but keep toolbox functions for parameter derivation, wrapping, and analysis. Always state which parts are toolbox-based and which are custom.

Analysis Rule (non-negotiable)

Never use xcorr for radar waveform autocorrelation or matched filter response visualization. Instead:

• Matched filter response / autocorrelation: Use ambgfun with 'Cut','Doppler' (zero-Doppler cut = response vs delay).
• PSL measurement: Use sidelobelevel on the dB-converted cut.
• Doppler tolerance: Use ambgfun with 'Cut','Delay' (zero-delay cut = response vs Doppler).
• Downstream signal processing: Use phased.MatchedFilter when you need the actual filtered signal (range processing, bit recovery, etc.).

Agent Reasoning Policy

• Follow the clarification flow above — do not skip to code without sufficient context.
• User names a waveform family → treat as a constraint; configure and analyze it. Only override if requirements are impossible with that family.
• User gives only performance constraints → choose the simplest family that satisfies them and explain why.
• Performance requirements given → derive parameters before selecting objects.
• Waveform family given (e.g., "NLFM") → ask about the goal (sidelobes, spectral shaping, Doppler tolerance, hardware).
• Exploration/learning → help directly with given parameters. Still use toolbox objects — generate base waveforms via System objects, use mlseq/legendreseq/apaseq for sequences, wrap custom results in PhaseCodedWaveform with Custom code. Do not write manual signal construction. Suggest radarWaveformGenerator for interactive exploration.
• Application context only (no numeric requirements) → recommend the waveform family/object and explain why. If the domain has well-known defaults (e.g., automotive radar at 77 GHz), state assumptions and proceed. Otherwise ask the application dimensions. Do NOT silently invent parameters without stating them.
• Conflicting requirements → surface the conflict before proposing a waveform.
• "Best waveform" → explain it depends on resolution, ambiguity, sidelobes, Doppler, hardware, and processing.
• User states MATLAB release → check function availability; note radarWaveformGenerator requires R2026a.
• No debugging loops. If code errors or results don't match expectations, retry at most once with a targeted fix. If the second attempt fails, stop and report what went wrong, what you tried, and ask the user whether to adjust requirements, relax constraints, or provide additional information. Do not iterate beyond 2 attempts.
• Write complete scripts, not incremental snippets. Do not develop code through many small evaluate_matlab_code calls. Instead, design the full script, save it to a .m file, and run it once with run_matlab_file. To save the file: use the Write tool if available, otherwise use evaluate_matlab_code with MATLAB's writelines or fopen/fprintf/fclose. Never use Bash heredocs for MATLAB code — single quotes and format strings (%d, \n) break shell quoting. If you are uncertain about an API or parameter and find yourself wanting to "try things" in MATLAB, that is a signal to stop and ask the user for clarification rather than exploring interactively. Reserve evaluate_matlab_code for at most: (1) one setup/cleanup call, (2) saving and running the script, and (3) one retry if needed.
• PSL trade-off checkpoint. When PSL target is between -30 and -45 dB: calculate TBP. If TBP < 500, present the trade-off BEFORE generating code: (a) NLFM — no SNR loss but PSL limited by stationary-phase approximation at this TBP; (b) LFM + time-domain windowed matched filter — guarantees target PSL at any TBP but costs ~3-4 dB SNR; (c) increase TBP to enable NLFM. Let the user choose before proceeding.

Requirements to Clarify

Once the application dimensions are known, check for these specific gaps:

| If the user hasn't specified... | Ask about... | Impacts... | |---|---|---| | Modulation type | Pulsed vs CW; FM vs phase-coded | Object selection (decision tree) | | Range resolution | Required resolution (m) | Bandwidth via rangeres2bw | | Sidelobe requirement | Acceptable PSL (dB) | NLFM vs windowed matched filter vs phase code choice | | Range and velocity together | Max unambiguous range AND velocity | PRF conflict check (see Parameter Derivation) | | Doppler tolerance | Max target velocity during dwell | LFM (tolerant) vs phase-coded (sensitive) tradeoff | | Hardware constraints | ADC bandwidth, instantaneous BW limit | Stretch processing or stepped FM instead of wideband LFM |

Requirement-to-Recommendation Heuristics

• Doppler tolerance priority → LFM-style solutions
• Low sidelobes without SNR loss → NLFM (sufficient TBP required)
• Spectral notching → amplitude-only bandstop for structured waveforms; shapespectrum only for PRO-FM. See references/spectral-notching.md
• Custom frequency profile for sidelobes → nlfmspec2freq + CustomFMWaveform
• Hardware BW limited → stretch processing or stepped FM
• External IQ → Custom IQ pattern (PhaseCodedWaveform with Code='Custom')
• CW/periodic analysis → pambgfun (not ambgfun)

See references/waveform-objects.md for the family summary table (strengths/tradeoffs).

Waveform Selection Decision Tree

Is the waveform continuous (CW)?
├── Yes: Does the user need linear FM sweep?
│   ├── Yes: Multiple targets where ghost targets are a concern?
│   │   ├── Yes → phased.MFSKWaveform (resolves range+speed without ghosts)
│   │   └── No → phased.FMCWWaveform (triangle sweep for range+speed)
│   └── No: Does the user need multiple frequency steps?
│       ├── Yes → phased.MFSKWaveform
│       └── No: No dedicated CW object for desired modulation?
│           └── Use pulsed object with PRF = 1/PulseWidth (see CW Pattern below)
│               ├── Nonlinear FM → phased.NonlinearFMWaveform or phased.CustomFMWaveform
│               └── Phase-coded → phased.PhaseCodedWaveform
│
└── No (pulsed): What modulation?
    ├── None (simple pulse) → phased.RectangularWaveform
    ├── Linear FM → phased.LinearFMWaveform
    ├── Nonlinear FM (built-in type) → phased.NonlinearFMWaveform
    │   (4 types: Polynomial, Hyperbolic, Hybrid Linear-Tangent, Stepped Price)
    ├── Nonlinear FM (custom shape) → phased.CustomFMWaveform
    │   (use with nlfmspec2freq for stationary-phase design)
    ├── Phase-coded → phased.PhaseCodedWaveform
    ├── Stepped frequency → phased.SteppedFMWaveform
    └── Hybrid (base waveform + additional modulation)
        → Generate base with appropriate FM/pulse object
        → Apply secondary modulation to the IQ vector
        → Wrap result with PhaseCodedWaveform (Code='Custom')

Key Functions

| Function | Purpose | Available From | |----------|---------|----------------| | rangeres2bw | Convert range resolution (m) to bandwidth (Hz) | — | | speed2dop | Convert speed to Doppler shift (one-way only; multiply by 2 for radar) | — | | freq2wavelen | Convert carrier frequency to wavelength | — | | nlfmspec2freq | Compute instantaneous frequency from desired spectrum shape | R2023a | | shapespectrum | Generate waveform with desired spectrum shape (notching, masks) | R2024b |