Skip to content

Reuse a synthetic OFDM frame for range evidence

Transform a known OFDM frame into a synthetic delay profile and justify one sensing-airtime and payload operating point.

Radio Remi, your practice guide

Radio Remi
Radio Remi: predict first, inspect every intermediate value, and keep the claim inside the evidence.
Predict the reading, then compare it with the measurement.

Python 3 in your browser (JupyterLite)

Python · no install

Tier 2 · Web · paste-in setup · No account

Last tested September 2026.

Open the notebook in your browser and run each Python cell; no install or account is needed.

Three ways to run: use JupyterLite here with no install; run main.py locally from the downloadable lab folder; or open the same notebook in Google Colab.

Open in your browser (new tab)

Steps

The tool may have moved on since the screenshots were taken — the text steps are the contract.

  1. 1 Step 1

    Do
    In the JupyterLite notebook, run the Step 1 cell to predict what narrower occupied bandwidth will do to two echoes.
    You will see

    Run the cell. You should see:

    • known OFDM subcarriers=64; spacing=1 MHz
    • two synthetic echoes at delay bins 5 and 14
    • No spectrum, antenna, access network, or real target is measured.
    Why it matters
    Expected: wider occupied bandwidth separates the two synthetic delay paths. The fixture has 64 tones at 1 MHz spacing and echoes at bins 5 and 14. That prediction sets the comparison for the later 16-tone run. Limit: this is generated baseband data, not a radio observation.
    Code for step 1
    import platform
    import pyodide
    print(f"Runtime: Python {platform.python_version()} / Pyodide {pyodide.__version__}")
    
    """Deterministic baseband OFDM channel exercise; not a 5G or Wi-Fi field test."""
    
    import argparse
    
    import cmath
    
    import math
    
    N = 64
    
    SPACING_HZ = 1_000_000
    
    C = 299_792_458
    
    PATHS = ((5, 1.0), (14, 0.55))
    
    def frame(active=N, sensing_symbols=2):
        symbols = [complex(1 if k % 2 else -1, 1 if k % 3 else -1) for k in range(N)]
        channel = [sum(amp * cmath.exp(-2j * math.pi * k * delay / N) for delay, amp in PATHS) for k in range(N)]
        received = [symbols[k] * channel[k] for k in range(N)]
        estimate = [received[k] / symbols[k] if k < active else 0j for k in range(N)]
        profile = [abs(sum(estimate[k] * cmath.exp(2j * math.pi * k * delay / N) for k in range(N))) / N for delay in range(N)]
        payload_fraction = (8 - sensing_symbols) / 8
        return symbols, received, estimate, profile, payload_fraction
    
    def peaks(profile):
        return sorted(range(N // 2), key=lambda i: profile[i], reverse=True)[:2]
    
    def step_1():
        return ['STEP 1 | pre-lab prediction', 'Predict: wider occupied bandwidth separates closer delay paths.', f'known OFDM subcarriers={N}; spacing={SPACING_HZ/1e6:.0f} MHz', 'two synthetic echoes at delay bins 5 and 14', 'No spectrum, antenna, access network, or real target is measured.']
    
    lines = step_1()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 1: its executed cell and printed evidence.
    Step 1 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.
  2. 2 Step 2

    Do
    In the JupyterLite notebook, run the Step 2 cell to generate the known OFDM symbols and received values.
    You will see

    Run the cell. You should see:

    • X[0]=(-1-1j); X[1]=(1+1j)
    • Y[0]=-1.550-1.550j; Y[1]=2.000-0.022j
    • active subcarriers=64
    Why it matters
    Expected: received symbols equal each known symbol multiplied by its channel value. The printed complex X and Y values are the locally executed fixture output. Comparing known inputs with received values makes the channel effect inspectable. Limit: no access network, RF chain, or measured channel is present.
    Code for step 2
    def step_2():
        symbols, received, _, _, _ = frame()
        return ['STEP 2 | known transmitted frame', f'X[0]={symbols[0]}; X[1]={symbols[1]}', f'Y[0]={received[0]:.3f}; Y[1]={received[1]:.3f}', 'Channel multiplies each known non-zero subcarrier symbol.', f'active subcarriers={len(symbols)}']
    
    lines = step_2()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 2: its executed cell and printed evidence.
    Step 2 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.
  3. 3 Step 3

    Do
    In the JupyterLite notebook, run the Step 3 cell to divide received values by known non-zero symbols.
    You will see

    Run the cell. You should see:

    • H[k]=Y[k]/X[k] when X[k] is known and non-zero
    • H[0]=1.550-0.000j; H[1]=0.989-1.011j
    • reconstruction residual=2.22e-16
    Why it matters
    Expected: estimated channel values reconstruct the synthetic received frame with near-zero residual. The measured-in-run residual is 2.22e-16 for this deterministic calculation. The estimate is consistent with the known synthetic channel. Limit: the calculation excludes clock, geometry, and hardware errors.
    Code for step 3
    def step_3():
        symbols, received, estimate, _, _ = frame()
        return ['STEP 3 | estimate the channel', 'H[k]=Y[k]/X[k] when X[k] is known and non-zero', f'H[0]={estimate[0]:.3f}; H[1]={estimate[1]:.3f}', f'reconstruction residual={max(abs(received[k]-symbols[k]*estimate[k]) for k in range(N)):.2e}', 'Clock and geometry errors are absent from this fixture.']
    
    lines = step_3()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 3: its executed cell and printed evidence.
    Step 3 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.
  4. 4 Step 4

    Do
    In the JupyterLite notebook, run the Step 4 cell to transform the channel estimate into a delay profile.
    You will see

    Run the cell. You should see:

    • strongest bins=[5, 14]
    • bin 5 strength=1.000; bin 14 strength=0.550
    • range spacing=c/(2NΔf)=2.34 m
    Why it matters
    Expected: the strongest delay bins identify the two inserted echo paths. The run recovered bins 5 and 14 with strengths 1.000 and 0.550. The assumed monostatic mapping assigns 2.34 m per range bin. Limit: range is a model conversion, not target ranging.
    Code for step 4
    def step_4():
        _, _, _, profile, _ = frame()
        found = peaks(profile)
        return ['STEP 4 | inverse transform to delay', f'strongest bins={found}', f'bin 5 strength={profile[5]:.3f}; bin 14 strength={profile[14]:.3f}', f'range spacing=c/(2NΔf)={C/(2*N*SPACING_HZ):.2f} m', 'Monostatic round-trip geometry is assumed only for this exercise.']
    
    lines = step_4()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 4: its executed cell and printed evidence.
    Step 4 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.
  5. 5 Step 5

    Do
    In the JupyterLite notebook, run the Step 5 cell to compare full and narrow occupied bandwidth.
    You will see

    Run the cell. You should see:

    • 64-tone spacing=2.34 m
    • 16-tone spacing=9.37 m
    • narrow-profile peak ratio=1.2
    Why it matters
    Expected: reducing occupied tones to 16 makes range-bin spacing four times wider. The run prints 2.34 m for 64 tones and 9.37 m for 16. The narrower synthetic profile also has a 1.2 peak ratio. Limit: profile behavior is simulated and has no clutter or RF effects.
    Code for step 5
    def step_5():
        full = frame()[3]
        narrow = frame(active=16)[3]
        return ['STEP 5 | change occupied bandwidth', f'64-tone spacing={C/(2*64*SPACING_HZ):.2f} m', f'16-tone spacing={C/(2*16*SPACING_HZ):.2f} m', f'full-profile peak ratio={full[5]/max(full[6],1e-9):.1f}', f'narrow-profile peak ratio={narrow[5]/max(narrow[6],1e-9):.1f}', 'Narrow bandwidth broadens the delay response.']
    
    lines = step_5()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 5: its executed cell and printed evidence.
    Step 5 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.
  6. 6 Step 6

    Do
    In the JupyterLite notebook, run the Step 6 cell to vary sensing slots inside an eight-symbol schedule.
    You will see

    Run the cell. You should see:

    • 1 | 88%
    • 2 | 75%
    • 6 | 25%
    Why it matters
    Expected: reserving more of eight symbol slots for sensing reduces nominal payload share. The executed schedule gives 75% payload for two sensing slots and 25% for six. The table exposes a sensing-versus-payload allocation trade-off. Limit: these fractions are not measured throughput.
    Code for step 6
    def step_6():
        return ['STEP 6 | spend eight symbol slots', 'sensing slots | nominal payload fraction', *[f'{slots:>5} | {frame(sensing_symbols=slots)[4]:.0%}' for slots in (1, 2, 4, 6)], 'Fractions are a schedule model, not measured link throughput.']
    
    lines = step_6()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 6: its executed cell and printed evidence.
    Step 6 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.
  7. 7 Step 7

    Do
    In the JupyterLite notebook, run the Step 7 cell to write a bounded operating-point result card.
    You will see

    Run the cell. You should see:

    • selected=64 known tones, 2 of 8 slots reserved for sensing
    • range-bin spacing=2.34 m; nominal payload=75%
    • decision=field-test both communication and sensing metrics
    Why it matters
    Expected: the chosen fixture uses 64 tones and reserves two of eight slots. The local result card reports 2.34 m bins and 75% nominal payload. The next evidence step is a field test of both metric families. Limit: clutter, timing, Doppler, RF hardware, and packet effects are absent.
    Code for step 7
    def step_7():
        return ['STEP 7 | RESULT CARD', 'selected=64 known tones, 2 of 8 slots reserved for sensing', f'range-bin spacing={C/(2*N*SPACING_HZ):.2f} m; nominal payload=75%', 'rejected=16 tones because its range bins are four times wider', 'missing=clutter, timing offset, Doppler, RF hardware, packet delay/loss', 'decision=field-test both communication and sensing metrics']
    
    lines = step_7()
    assert 4 <= len(lines) <= 15
    print("\n".join(lines))
    JupyterLite isac-ofdm-range-profile step 7: its executed cell and printed evidence.
    Step 7 · Python 3 in your browser (JupyterLite); numbered callout added to a real capture.

Chapter checks

These questions refer to the chapter’s examples. Use the return links to review their answers.

  1. Why must the receiver know or decode an OFDM symbol before using Y[k]/X[k] as a channel estimate?

    Return to the chapter’s knowledge check
  2. What proves a chosen ISAC schedule?

    Return to the chapter’s knowledge check

Caution

Before you start

Read this before you start.

These generated fixtures prove calculations only. Reopen the prepared notebook if screens change; measured hardware, consent, and site evidence are required for a deployment claim.

Technical details
Version tested
Version tested: Python 3.12.7 / Pyodide 0.27.6 in JupyterLite 0.6.4; captureSource playwright:jupyterlite. Date: 2026-09-22.
Fixture and seed
  • Each notebook step runs with its stated deterministic fixture.
QR code that opens the Reuse a synthetic OFDM frame for range evidence lab page
Open this lab online: https://iotclass.org/labs/isac-ofdm-range-profile.html

Return to Integrated Sensing and Communication for IoT · Browse Labs