diff --git a/.github/workflows/build-and-deploy.yml b/.github/workflows/build-and-deploy.yml
index 3905aed5..ab23b5e7 100644
--- a/.github/workflows/build-and-deploy.yml
+++ b/.github/workflows/build-and-deploy.yml
@@ -38,11 +38,11 @@ jobs:
uses: actions/checkout@v4.1.7
- name: apt installs
- run: sudo apt update && sudo apt install -y texlive-latex-extra texlive-lang-cyrillic ghostscript
+ run: sudo apt update && sudo apt install -y texlive-latex-extra texlive-lang-cyrillic ghostscript libenchant-2-dev
- - uses: actions/setup-python@v5.1.0
+ - uses: actions/setup-python@v6.2.0
with:
- python-version: '3.10'
+ python-version: '3.12'
- name: pip installs
run: pip install -r requirements.txt
@@ -97,6 +97,16 @@ jobs:
env:
CREATOR_ID: ${{ secrets.CREATOR_ID }}
+ # Build a self-hosted JupyterLite environment into _build/jupyterlite so the
+ # interactive "run this code" links in the book point at our own deployment
+ # rather than a third-party demo site. Done last so its pip installs can't
+ # disturb the Sphinx builds above.
+ - name: Build JupyterLite
+ run: |
+ pip install -r requirements-jupyterlite.txt
+ jupyter lite build --contents jupyterlite --output-dir _build/jupyterlite
+ python jupyterlite/inject_branding.py _build/jupyterlite
+
- name: Upload artifact
uses: actions/upload-pages-artifact@v3.0.1
with:
@@ -104,7 +114,7 @@ jobs:
- name: Deploy to GitHub Pages
id: deployment
- uses: actions/deploy-pages@v4.0.5
+ uses: actions/deploy-pages@v5.0.0
- name: Get current date
id: date
diff --git a/.github/workflows/build-and-spell-check.yml b/.github/workflows/build-and-spell-check.yml
index 7cecf2d5..c15fb450 100644
--- a/.github/workflows/build-and-spell-check.yml
+++ b/.github/workflows/build-and-spell-check.yml
@@ -10,11 +10,11 @@ jobs:
uses: actions/checkout@v4.1.7
- name: apt installs
- run: sudo apt update && sudo apt install -y texlive-latex-extra texlive-lang-cyrillic ghostscript
+ run: sudo apt update && sudo apt install -y texlive-latex-extra texlive-lang-cyrillic ghostscript libenchant-2-dev
- - uses: actions/setup-python@v5.1.0
+ - uses: actions/setup-python@v6.2.0
with:
- python-version: '3.10'
+ python-version: '3.12'
- name: pip installs
run: pip install -r requirements.txt
diff --git a/.vscode/settings.json b/.vscode/settings.json
index c79ae069..b8fc1609 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,80 +1,9 @@
{
"esbonio.sphinx.confDir": "",
- "cSpell.words": [
- "arange",
- "argmax",
- "argsort",
- "asarray",
- "asmatrix",
- "astype",
- "AWGN",
- "baseband",
- "beamformer",
- "beamformers",
- "beamforming",
- "boresight",
- "bpsk",
- "bytearray",
- "CDMA",
- "checkword",
- "convolutional",
- "Costas",
- "datacast",
- "dataword",
- "demod",
- "downconversion",
- "dtype",
- "endfire",
- "Ettus",
- "figsize",
- "fillmein",
- "firwin",
- "fontsize",
- "fromfile",
- "Gbps",
- "imag",
- "lastseen",
- "leftrightarrow",
- "lfilter",
- "linalg",
- "linspace",
- "mathrm",
- "matplotlib",
- "Mbps",
- "mlen",
- "multipath",
- "MVDR",
- "numpy",
- "numtaps",
- "Nyquist",
- "OFDM",
- "pinv",
- "plen",
- "postcostas",
- "presync",
- "pyplot",
- "QPSK",
- "radiotext",
- "randint",
- "randn",
- "rgrids",
- "Rinv",
- "rlabel",
- "savefig",
- "scipy",
- "thetamax",
- "thetamin",
- "Uplif",
- "USRP",
- "webp",
- "wirelessly",
- "xdata",
- "xlabel",
- "ydata",
- "ylabel"
- ],
"githubPullRequests.ignoredPullRequestBranches": [
"master"
],
- "python.analysis.typeCheckingMode": "basic"
+ "python.analysis.typeCheckingMode": "basic",
+ "editor.formatOnSave": false,
+ "editor.wordWrap": "on"
}
\ No newline at end of file
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..a661808c
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,66 @@
+# Repository Guidance for AI Contributors
+
+This repo is the source for the PySDR textbook, created using Sphinx.
+
+## Human Notes
+
+This section is for human reference only. It is not an instruction for agents and should not change behavior.
+
+Marc uses AI to help create the JavaScript mini-apps and solve issues like when certain things are not rendered correctly, he doesn't use it to write the actual content, other than spelling/grammar edits and scanning for bugs/incorrectness.
+
+## What to edit
+
+- Edit the `.rst` files under `content/` and the Sphinx config/templates under the repo root.
+- Treat `_build/` as generated output. Do not edit it directly.
+- Images (primarily in SVG format) referenced by the RST live in _images/
+- Python code used to produce images (primarily in SVG format) lives in figure-generating-scripts/
+- If you change a page, also check whether image assets, scripts, or config in `_static/`, `_images/`, `conf.py`, or `Makefile` need matching updates.
+
+## How to build locally
+
+If the prompt does not ask to build it, then don't build it.
+
+- Activate the project virtual environment which should be in the root of this repo under .venv
+
+- Build the site using:
+
+```bash
+make fast-html
+```
+
+- The rendered HTML site will be in `_build/`.
+- Open `_build/index.html` for the main site, or the relevant page under `_build/content/`.
+
+## Practical workflow
+
+- Make the source change.
+- Run `make fast-html`.
+- Inspect the generated HTML in `_build/` to verify the result.
+- Keep changes minimal and aligned with the existing textbook style.
+
+## Writing Style
+
+Note to humans- This guidance is provided to AI to help edit, not actually write material, Marc's writes everything himself then uses AI for catching grammar issues and such.
+
+PySDR's prose is intentionally instructional, conversational, and example-driven. When editing chapter text, match these patterns:
+
+- Start with intuition before formalism. Explain the idea in plain language first, then introduce equations or code.
+- Prefer short, direct paragraphs. Long sections are acceptable, but they should be broken up with transitions, examples, or figures.
+- Use first-person plural sparingly but naturally (`we`, `let's`) to guide the reader through the material.
+- Keep the tone approachable and lightly informal, but not casual or chatty.
+- Use rhetorical questions and plain-English restatements when they help clarify a concept.
+- Explain why a step matters, not just what the step is.
+- Preserve the textbook’s teaching rhythm: concept, example, code, result, takeaway.
+- Keep technical terminology precise, but avoid sounding overly academic or formal.
+- When a section already has figures or code, make the surrounding prose point the reader to them and explain what they should notice.
+- Avoid hype, filler, and motivational fluff.
+- Lead with a concrete scenario before any equation. Pose a small "what if" with real numbers (e.g. "the emitter is 100 m closer to one sensor"), then generalize. Introduce the named concept (hyperbola, foci) in plain words before showing the formula.
+- Read the equation back in plain English. Right after a .. math:: block, add a sentence translating it ("which reads: distance to one sensor minus distance to the other equals...").
+- Explain why, not just what. For each fact, give the intuition behind it (why a range difference can't exceed the baseline) rather than stating it as a rule.
+- Define jargon inline the moment it appears ("the baseline," "ill-conditioned, meaning small errors move the estimate a lot") instead of assuming the reader knows it.
+- Use second person and rhetorical questions to walk the reader through the reasoning as if thinking aloud.
+
+## Notes
+
+- This project uses Sphinx and a custom `conf.py`.
+- The repository already contains scripts and generated assets for many figures, so prefer reusing existing conventions instead of introducing new build patterns.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 00000000..47dc3e3d
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/Makefile b/Makefile
index ed288b6e..cb639aa2 100644
--- a/Makefile
+++ b/Makefile
@@ -16,7 +16,7 @@ endif
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-EXTENSIONS = -D extensions=sphinx.ext.mathjax,sphinx.ext.autosectionlabel,sphinxcontrib.tikz -D tikz_includegraphics_path=_images -D tikz_tikzlibraries=positioning,shapes,arrows,snakes
+EXTENSIONS = -D extensions=sphinx.ext.mathjax,sphinx.ext.autosectionlabel,sphinxcontrib.tikz,sphinxcontrib.mermaid -D tikz_includegraphics_path=_images -D tikz_tikzlibraries=positioning,shapes,arrows,snakes
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
diff --git a/README.md b/README.md
index da0a1f3f..a7130685 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,13 @@
-# PySDR Textbook Source Material
-
-This repo contains the source content used to generate the textbook [PySDR: A Guide to SDR and DSP using Python](https://pysdr.org) hosted at https://pysdr.org.
-
-Feel free to submit an issue, or even a Pull Request (PR) with fixes or improvements. Those who submit valuable feedback/fixes be permanently added to the acknowledgments section. Not good at Git but have changes to suggest? Feel free to email Marc at marc@pysdr.org.
+# PySDR
+[PySDR: A Guide to SDR and DSP using Python](https://pysdr.org) is a guide to software-defined radio (SDR) and RF signal processing using Python code examples, live at https://pysdr.org. It is a free online textbook that provides a gentle introduction to wireless communications and SDR using an abundance of diagrams, animations, and code examples. From FFTs to filters to digital modulation to receiving and transmitting from SDRs in Python, PySDR has you covered! This repo specifically contains the source content used to generate the textbook, including the body text and Python scripts to generate the figures. For questions/comments/suggestions feel free to submit an issue at the top of this page, or if you want to propose a change to the textbook (e.g. fix or improvement), you can use a Pull Request. Those who submit valuable feedback/fixes be permanently added to the acknowledgments section. Not good at Git but have changes to suggest? Feel free to email Marc at marc@pysdr.org.
+
+You can also support PySDR through the [PySDR Patreon page](https://www.patreon.com/c/PySDR) or a [one-time donation](https://www.paypal.com/donate/?hosted_button_id=FH3LQCJRUVPWL).
+
## Building
Note that the website is now automatically built and deployed with each push/merge into master branch, using the GitHub action [build-and-deploy.yml](https://github.com/777arc/PySDR/blob/master/.github/workflows/build-and-deploy.yml) and the GitHub pages system for hosting the actual textbook.
diff --git a/_images/2d_array_2d_doa_plot.svg b/_images/2d_array_2d_doa_plot.svg
index 60878821..844371cc 100644
--- a/_images/2d_array_2d_doa_plot.svg
+++ b/_images/2d_array_2d_doa_plot.svg
@@ -1,1380 +1,1200 @@
-
-
+
+
+********************************
+Frequentie-smoothingmethode (FSM)
+********************************
+
+Nu we conceptueel begrijpen wat de SCF doet, kijken we naar een efficiente berekeningsmethode. We starten met het periodogram, de gekwadrateerde magnitude van de Fouriertransformatie van een signaal:
+
+.. math::
+
+ I(u,f) = \frac{1}{N}\left|X(u,f)\right|^2
+
+Het cyclische periodogram krijgen we uit het product van twee in frequentie verschoven Fouriertransformaties:
+
+.. math::
+
+ I(u,f,\alpha) = \frac{1}{N}X(u,f + \alpha/2) X^*(u,f - \alpha/2)
+
+Beide zijn schattingen van PSD en SCF, maar voor een betrouwbare SCF moet je middelen over tijd of frequentie. Middelen over tijd heet de Time Smoothing Method (TSM):
+
+.. math::
+ S_X(f, \alpha) = \lim_{T\rightarrow\infty} \frac{1}{T} \lim_{U\rightarrow\infty} \frac{1}{U} \int_{-U/2}^{U/2} X(t,f + \alpha/2) X^*(t,f - \alpha/2) dt
+
+middelen over frequentie heet de Frequency Smoothing Method (FSM):
+
+.. math::
+ S_X(f, \alpha) = \lim_{\Delta\rightarrow 0} \lim_{T\rightarrow \infty} \frac{1}{T} g_{\Delta}(f) \otimes \left[X(t,f + \alpha/2) X^*(t,f - \alpha/2)\right]
+
+waar de functie :math:`g_{\Delta}(f)` een frequentiesmoothingfunctie is die over een klein frequentiebereik middelt.
+
+Hieronder staat een minimale Python-implementatie van FSM, een op frequentiemiddeling gebaseerde methode om de SCF van een signaal te berekenen. Eerst wordt het cyclische periodogram berekend door twee verschoven FFT-versies te vermenigvuldigen, daarna wordt elke slice gefilterd met een vensterfunctie waarvan de lengte de resolutie van de SCF-schatting bepaalt. Langere vensters geven gladdere resultaten met lagere resolutie; kortere vensters doen het omgekeerde.
+
+.. code-block:: python
+
+ alphas = np.arange(0, 0.3, 0.001)
+ Nw = 256 # window length
+ N = len(samples) # signal length
+ window = np.hanning(Nw)
+
+ X = np.fft.fftshift(np.fft.fft(samples)) # FFT of entire signal
+
+ num_freqs = int(np.ceil(N/Nw)) # freq resolution after decimation
+ SCF = np.zeros((len(alphas), num_freqs), dtype=complex)
+ for i in range(len(alphas)):
+ shift = int(alphas[i] * N/2)
+ SCF_slice = np.roll(X, -shift) * np.conj(np.roll(X, shift))
+ SCF[i, :] = np.convolve(SCF_slice, window, mode='same')[::Nw] # apply window and decimate by Nw
+ SCF = np.abs(SCF)
+ SCF[0, :] = 0 # null out alpha=0 which is just the PSD of the signal, it throws off the dynamic range
+
+ extent = (-0.5, 0.5, float(np.max(alphas)), float(np.min(alphas)))
+ plt.imshow(SCF, aspect='auto', extent=extent, vmax=np.max(SCF)/2)
+ plt.xlabel('Frequency [Normalized Hz]')
+ plt.ylabel('Cyclic Frequency [Normalized Hz]')
+ plt.show()
+
+Let op dat door de manier waarop de verschuiving als geheel aantal samples wordt berekend en afgerond, het helpt om minstens :code:`2 / alpha_resolution` samples tegelijk te verwerken.
+
+Laten we de SCF berekenen voor het rechthoekige BPSK-signaal van eerder, met 20 samples per symbool en cyclische frequenties van 0 tot 0.3 met stapgrootte 0.001:
+
+.. image:: ../_images/scf_freq_smoothing.svg
+ :align: center
+ :target: ../_images/scf_freq_smoothing.svg
+ :alt: SCF met de Frequency Smoothing Method (FSM), cyclostationaire verwerking
+
+Deze methode heeft als voordeel dat maar een grote FFT nodig is, maar als nadeel dat voor smoothing veel convoluties nodig zijn. Let op de decimatie na de convolve via :code:`[::Nw]`; dit is optioneel maar sterk aanbevolen om het aantal weer te geven pixels te beperken, en door de opbouw van de SCF gooi je hiermee in de praktijk geen bruikbare informatie weg.
+
+***************************
+Tijd-smoothingmethode (TSM)
+***************************
+
+Nu bekijken we een TSM-implementatie in Python. De code hieronder splitst het signaal in *num_windows* blokken, elk van lengte *Nw* met overlap *Noverlap*. Overlap is niet verplicht, maar geeft vaak een netter resultaat. Daarna wordt per blok een vensterfunctie toegepast (hier Hanning, maar andere vensters kunnen ook) en een FFT genomen. De SCF ontstaat vervolgens door over blokken te middelen. De vensterlengte bepaalt, net als bij FSM, de afweging tussen resolutie en gladheid.
+
+
+.. code-block:: python
+
+ alphas = np.arange(0, 0.3, 0.001)
+ Nw = 256 # window length
+ N = len(samples) # signal length
+ Noverlap = int(2/3*Nw) # block overlap
+ num_windows = int((N - Noverlap) / (Nw - Noverlap)) # Number of windows
+ window = np.hanning(Nw)
+
+ SCF = np.zeros((len(alphas), Nw), dtype=complex)
+ for ii in range(len(alphas)): # Loop over cyclic frequencies
+ neg = samples * np.exp(-1j*np.pi*alphas[ii]*np.arange(N))
+ pos = samples * np.exp( 1j*np.pi*alphas[ii]*np.arange(N))
+ for i in range(num_windows):
+ pos_slice = window * pos[i*(Nw-Noverlap):i*(Nw-Noverlap)+Nw]
+ neg_slice = window * neg[i*(Nw-Noverlap):i*(Nw-Noverlap)+Nw]
+ SCF[ii, :] += np.fft.fft(neg_slice) * np.conj(np.fft.fft(pos_slice)) # Cross Cyclic Power Spectrum
+ SCF = np.fft.fftshift(SCF, axes=1) # shift the RF freq axis
+ SCF = np.abs(SCF)
+ SCF[0, :] = 0 # null out alpha=0 which is just the PSD of the signal, it throws off the dynamic range
+
+ extent = (-0.5, 0.5, float(np.max(alphas)), float(np.min(alphas)))
+ plt.imshow(SCF, aspect='auto', extent=extent, vmax=np.max(SCF)/2)
+ plt.xlabel('Frequency [Normalized Hz]')
+ plt.ylabel('Cyclic Frequency [Normalized Hz]')
+ plt.show()
+
+.. image:: ../_images/scf_time_smoothing.svg
+ :align: center
+ :target: ../_images/scf_time_smoothing.svg
+ :alt: SCF met de Time Smoothing Method (TSM), cyclostationaire verwerking
+
+Ziet er grofweg hetzelfde uit als FSM.
+
+*****************
+Pulse-shaped BPSK
+*****************
+
+Tot nu toe onderzochten we CSP alleen voor een *rechthoekig* BPSK-signaal. In echte RF-systemen zien we echter bijna nooit rechthoekige pulsen; een uitzondering is de BPSK-chippingsequentie in direct-sequence spread spectrum (DSSS), die vaak ongeveer rechthoekig is.
+
+Laten we nu kijken naar een BPSK-signaal met raised-cosine (RC) pulse shaping, een veelgebruikte vorm in digitale communicatie om de bezette bandbreedte te verkleinen ten opzichte van rechthoekig BPSK. Zoals besproken in :ref:`pulse-shaping-chapter` is de RC-pulsvorm in het tijddomein:
+
+.. math::
+ h(t) = \mathrm{sinc}\left( \frac{t}{T} \right) \frac{\cos\left(\frac{\pi\beta t}{T}\right)}{1 - \left( \frac{2 \beta t}{T} \right)^2}
+
+De parameter :math:`\beta` bepaalt hoe snel het filter in het tijddomein afvalt, wat omgekeerd samenhangt met het afvallen in frequentie:
+
+.. image:: ../_images/raised_cosine_freq.svg
+ :align: center
+ :target: ../_images/raised_cosine_freq.svg
+ :alt: Raised-cosinefilter in het frequentiedomein met verschillende roll-offwaarden
+
+Let op dat :math:`\beta=0` overeenkomt met een oneindig lange pulsvorm en dus niet praktisch is. Ook geldt dat :math:`\beta=1` *niet* overeenkomt met een rechthoekige pulsvorm. In de praktijk ligt roll-off vaak tussen 0.2 en 0.4.
+
+We kunnen een BPSK-signaal met raised-cosine pulse shaping simuleren met onderstaande code; de eerste 5 en laatste 4 regels zijn gelijk aan rechthoekig BPSK:
+
+.. code-block:: python
+
+ N = 100000 # number of samples to simulate
+ f_offset = 0.2 # Hz normalized
+ sps = 20 # cyclic freq (alpha) will be 1/sps or 0.05 Hz normalized
+ num_symbols = int(np.ceil(N/sps))
+ symbols = np.random.randint(0, 2, num_symbols) * 2 - 1 # random 1's and -1's
+
+ pulse_train = np.zeros(num_symbols * sps)
+ pulse_train[::sps] = symbols # easier explained by looking at an example output
+ print(pulse_train[0:96].astype(int))
+
+ # Raised-Cosine Filter for Pulse Shaping
+ beta = 0.3 # roll-off parameter (avoid exactly 0.2, 0.25, 0.5, and 1.0)
+ num_taps = 101 # somewhat arbitrary
+ t = np.arange(num_taps) - (num_taps-1)//2
+ h = np.sinc(t/sps) * np.cos(np.pi*beta*t/sps) / (1 - (2*beta*t/sps)**2) # RC equation
+ bpsk = np.convolve(pulse_train, h, 'same') # apply the pulse shaping
+
+ bpsk = bpsk[:N] # clip off the extra samples
+ bpsk = bpsk * np.exp(2j * np.pi * f_offset * np.arange(N)) # Freq shift up the BPSK, this is also what makes it complex
+ noise = np.random.randn(N) + 1j*np.random.randn(N) # complex white Gaussian noise
+ samples = bpsk + 0.1*noise # add noise to the signal
+
+Let op dat :code:`pulse_train` simpelweg onze symbolen zijn met :code:`sps - 1` nullen na elk symbool, dus in volgorde bijvoorbeeld:
+
+.. code-block:: bash
+
+ [ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
+ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
+ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
+ 0 0 0 0 0 0 0 0 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0...
+
+De onderstaande plot toont het pulse-shaped BPSK-signaal in het tijddomein, nog zonder ruis en zonder frequentieverschuiving:
+
+.. image:: ../_images/pulse_shaped_BSPK.svg
+ :align: center
+ :target: ../_images/pulse_shaped_BSPK.svg
+ :alt: Pulse-shaped BPSK-signaal met raised-cosine pulsvorm
+
+Laten we nu de SCF van dit pulse-shaped BPSK-signaal berekenen met roll-off 0.3, 0.6 en 0.9. We gebruiken dezelfde frequentieverschuiving van 0.2 Hz, dezelfde FSM-implementatie, FSM-parameters en symboollengte als in het rechthoekige BPSK-voorbeeld voor een eerlijke vergelijking:
+
+:code:`beta = 0.3`:
+
+.. image:: ../_images/scf_freq_smoothing_pulse_shaped_bpsk.svg
+ :align: center
+ :target: ../_images/scf_freq_smoothing_pulse_shaped_bpsk.svg
+ :alt: SCF van pulse-shaped BPSK met de Frequency Smoothing Method (FSM), beta 0.3
+
+:code:`beta = 0.6`:
+
+.. image:: ../_images/scf_freq_smoothing_pulse_shaped_bpsk2.svg
+ :align: center
+ :target: ../_images/scf_freq_smoothing_pulse_shaped_bpsk2.svg
+ :alt: SCF van pulse-shaped BPSK met de Frequency Smoothing Method (FSM), beta 0.6
+
+:code:`beta = 0.9`:
+
+.. image:: ../_images/scf_freq_smoothing_pulse_shaped_bpsk3.svg
+ :align: center
+ :target: ../_images/scf_freq_smoothing_pulse_shaped_bpsk3.svg
+ :alt: SCF van pulse-shaped BPSK met de Frequency Smoothing Method (FSM), beta 0.9
+
+In alle drie gevallen verdwijnen de sterke sidelobes op de frequentie-as, en op de cyclische frequentie-as zien we niet dezelfde krachtige harmonischen van de grondfrequentie. Dat komt doordat raised-cosine pulse shaping de energie spectraal veel beter begrenst dan rechthoekige pulsenvormen. Hierdoor hebben pulse-shaped signalen doorgaans een "schonere" SCF dan rechthoekige signalen, vaak als een dominante piek met smeer erboven. Dit geldt voor alle enkelvoudige draaggolfsignalen met digitale modulatie, niet alleen BPSK. Bij grotere beta wordt de piek op de frequentie-as breder doordat het signaal meer bandbreedte gebruikt.
+
+********************************
+SNR en Aantal Symbolen
+********************************
+
+Komt binnenkort. We behandelen dan waarom boven een bepaald punt hogere SNR niet meer helpt, maar meer symbolen wel, en hoe packet-gebaseerde golfvormen leiden tot een beperkt aantal symbolen per transmissie.
+
+********************************
+QPSK en Hogere-orde Modulatie
+********************************
+
+Komt binnenkort. Dit deel zal QPSK, hogere orde PSK, QAM en een korte introductie tot hogere-orde cyclische momenten en cumulanten bevatten.
+
+********************************
+Meerdere Overlappende Signalen
+********************************
+
+Tot nu toe keken we naar een signaal tegelijk. Maar wat als het ontvangen signaal meerdere individuele signalen bevat die in frequentie, tijd en zelfs cyclische frequentie overlappen (dus hetzelfde aantal samples per symbool hebben)? Als signalen niet in frequentie overlappen, kun je ze met simpele filtering scheiden en met een PSD detecteren, mits boven de ruisvloer. Overlappen ze niet in de tijd, dan kun je stijg- en daalflanken per transmissie detecteren en met time-gating per signaal verwerken. In CSP richten we ons vaak op detectie van signalen met verschillende cyclische frequenties die in zowel tijd als frequentie overlappen.
+
+Laten we drie signalen simuleren met verschillende eigenschappen:
+
+* Signaal 1: rechthoekig BPSK met 20 samples per symbool en 0.2 Hz frequentie-offset
+* Signaal 2: pulse-shaped BPSK met 20 samples per symbool, -0.1 Hz frequentie-offset en 0.35 roll-off
+* Signaal 3: pulse-shaped QPSK met 4 samples per symbool, 0.2 Hz frequentie-offset en 0.21 roll-off
+
+Zoals je ziet hebben twee signalen dezelfde cyclische frequentie en twee dezelfde RF-frequentie. Daarmee kunnen we met verschillende graden van parameteroverlap experimenteren.
+
+Op elk signaal passen we een fractional-delay-filter toe met een willekeurige (niet-gehele) vertraging, zodat geen artefacten ontstaan doordat gesimuleerde samples exact uitgelijnd zijn (meer hierover in :ref:`sync-chapter`). Het rechthoekige BPSK-signaal verlagen we in vermogen ten opzichte van de andere twee, omdat rechthoekige pulsen zeer sterke cyclostationaire eigenschappen hebben en anders de SCF domineren.
+
+.. raw:: html
+
+
