From faf0e5421fcca873aaa8e3056f70cdd91a663f59 Mon Sep 17 00:00:00 2001
From: Rahix <rahix@rahix.de>
Date: Sun, 13 Jul 2025 12:55:04 +0200
Subject: [PATCH] Add sweeping notebook for X-axis sweep experiments

This is a hacked together X-axis sweep with a duration of 4.3 seconds.
The whole setup is quite janky because the sweep seems to only fill half
of the sample buffer.  We probably need to dig deeper into the way the
red pitaya is working...
---
 Control/STM_Sweep.ipynb | 342 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 342 insertions(+)
 create mode 100644 Control/STM_Sweep.ipynb

diff --git a/Control/STM_Sweep.ipynb b/Control/STM_Sweep.ipynb
new file mode 100644
index 0000000..e80c4d3
--- /dev/null
+++ b/Control/STM_Sweep.ipynb
@@ -0,0 +1,342 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Synchronised one-pulse signal generation and acquisition\n",
+    "Now that we are familiar with generating and acquiring signals with Red Pitaya, we can finally learn a few tricks for combining both and use them in practice. In this example, the acquisition is triggered together with the generation, which is used for measuring cable length and other applications where signal propagation delay is important.\n",
+    "\n",
+    "**Note:**  \n",
+    "The voltage range of fast analog inputs on the Red Pitaya depends on the input jumper position. HV sets the input range to ±20 V, while LV sets the input range to ±1 V. For more information, please read the following [chapter](https://redpitaya.readthedocs.io/en/latest/developerGuide/hardware/125-14/fastIO.html#analog-inputs).\n",
+    "\n",
+    "As previously, create a loop-back from fast analog outputs to fast analog inputs, as shown in the picture below.  \n",
+    "Please make sure the jumpers are set to ±1 V (LV).\n",
+    "\n",
+    "![Fast loop back](../img/FastIOLoopBack.png \"Example of the fast loop back.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Libraries and FPGA image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Check FPGA [OK].\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from rp_overlay import overlay\n",
+    "import rp\n",
+    "\n",
+    "fpga = overlay()\n",
+    "rp.rp_Init()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Marcos\n",
+    "Throughout this tutorial we will mention macros multiple times. Here is a complete list of macros that will come in handy when customising this notebook. The marcos are a part of the **rp** library.\n",
+    "\n",
+    "**GENERATION**\n",
+    "\n",
+    "- **Waveforms** - RP_WAVEFORM_SINE, RP_WAVEFORM_SQUARE, RP_WAVEFORM_TRIANGLE, RP_WAVEFORM_RAMP_UP, RP_WAVEFORM_RAMP_DOWN, RP_WAVEFORM_DC, RP_WAVEFORM_PWM, RP_WAVEFORM_ARBITRARY, RP_WAVEFORM_DC_NEG, RP_WAVEFORM_SWEEP\n",
+    "- **Generator modes** - RP_GEN_MODE_CONTINUOUS, RP_GEN_MODE_BURST\n",
+    "- **Sweep direction** - RP_GEN_SWEEP_DIR_NORMAL, RP_GEN_SWEEP_DIR_UP_DOWN\n",
+    "- **Sweep mode** - RP_GEN_SWEEP_MODE_LINEAR, RP_GEN_SWEEP_MODE_LOG\n",
+    "- **Generator trigger source** - RP_GEN_TRIG_SRC_INTERNAL, RP_GEN_TRIG_SRC_EXT_PE, RP_GEN_TRIG_SRC_EXT_NE\n",
+    "- **Generator triggers** - RP_T_CH_1, RP_T_CH_2, RP_T_CH_EXT\n",
+    "- **Rise and fall times** - RISE_FALL_MIN_RATIO, RISE_FALL_MAX_RATIO\n",
+    "\n",
+    "**ACQUISITION**\n",
+    "\n",
+    "- **Decimation** - RP_DEC_1, RP_DEC_2, RP_DEC_4, RP_DEC_8, RP_DEC_16, RP_DEC_32, RP_DEC_64, RP_DEC_128, RP_DEC_256, RP_DEC_512, RP_DEC_1024, RP_DEC_2048, RP_DEC_4096, RP_DEC_8192, RP_DEC_16384, RP_DEC_32768, RP_DEC_65536 \n",
+    "- **Acquisition trigger** - RP_TRIG_SRC_DISABLED, RP_TRIG_SRC_NOW, RP_TRIG_SRC_CHA_PE, RP_TRIG_SRC_CHA_NE, RP_TRIG_SRC_CHB_PE, RP_TRIG_SRC_CHB_NE, RP_TRIG_SRC_EXT_PE, RP_TRIG_SRC_EXT_NE, RP_TRIG_SRC_AWG_PE, RP_TRIG_SRC_AWG_NE\n",
+    "- **Acquisition trigger state** - RP_TRIG_STATE_TRIGGERED, RP_TRIG_STATE_WAITING\n",
+    "- **Buffer size** - ADC_BUFFER_SIZE, DAC_BUFFER_SIZE\n",
+    "- **Fast analog channels** - RP_CH_1, RP_CH_2\n",
+    "\n",
+    "SIGNALlab 250-12 only:\n",
+    "- **Input coupling** - RP_DC, RP_AC\n",
+    "- **Generator gain** - RP_GAIN_1X, RP_GAIN_5X\n",
+    "\n",
+    "STEMlab 125-14 4-Input only:\n",
+    "- **Fast analog channels** - RP_CH_3, RP_CH_4\n",
+    "- **Acquisition trigger** - RP_TRIG_SRC_CHC_PE, RP_TRIG_SRC_CHC_NE, RP_TRIG_SRC_CHD_PE, RP_TRIG_SRC_CHD_NE"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Synchronising generation and acquisition\n",
+    "\n",
+    "The example itself is relatively trivial in comparison to others already presented during the tutorials. The only practical change is the **RP_TRIG_SOUR_AWG_PE**.\n",
+    "\n",
+    "Parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "###### Generation #####\n",
+    "channel = rp.RP_CH_1        # rp.RP_CH_2\n",
+    "waveform = rp.RP_WAVEFORM_RAMP_UP\n",
+    "freq = 0.1164153218269348 * 2\n",
+    "ampl = 1.0\n",
+    "\n",
+    "ncyc = 1\n",
+    "nor = 1\n",
+    "period = 10\n",
+    "\n",
+    "gen_trig_sour = rp.RP_GEN_TRIG_SRC_INTERNAL\n",
+    "\n",
+    "##### Acquisition #####\n",
+    "trig_lvl = 0.5\n",
+    "trig_dly = 0\n",
+    "dec = rp.RP_DEC_65536\n",
+    "\n",
+    "acq_trig_sour = rp.RP_TRIG_SRC_AWG_PE\n",
+    "\n",
+    "N = 32768 // 2\n",
+    "\n",
+    "# Reset Generation and Acquisition\n",
+    "rp.rp_GenReset()\n",
+    "rp.rp_AcqReset()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Setting up both the generation and acquisition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Gen_start\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "###### Generation #####\n",
+    "print(\"Gen_start\")\n",
+    "rp.rp_GenWaveform(channel, waveform)\n",
+    "rp.rp_GenFreqDirect(channel, freq)\n",
+    "rp.rp_GenAmp(channel, ampl)\n",
+    "\n",
+    "# Change to burst mode\n",
+    "rp.rp_GenMode(channel, rp.RP_GEN_MODE_BURST)\n",
+    "rp.rp_GenBurstCount(channel, ncyc)                  # Ncyc\n",
+    "rp.rp_GenBurstRepetitions(channel, nor)             # Nor\n",
+    "rp.rp_GenBurstPeriod(channel, period)               # Period\n",
+    "\n",
+    "\n",
+    "# Specify generator trigger source\n",
+    "rp.rp_GenTriggerSource(channel, gen_trig_sour)\n",
+    "\n",
+    "# Enable output synchronisation\n",
+    "rp.rp_GenOutEnableSync(True)\n",
+    "\n",
+    "\n",
+    "##### Acquisition #####\n",
+    "# Set Decimation\n",
+    "rp.rp_AcqSetDecimation(dec)\n",
+    "rp.rp_AcqSetAveraging(True)\n",
+    "rp.rp_AcqSetGain(rp.RP_CH_1, rp.RP_HIGH)\n",
+    "\n",
+    "# Set trigger level and delay\n",
+    "rp.rp_AcqSetTriggerLevel(rp.RP_T_CH_1, trig_lvl)\n",
+    "rp.rp_AcqSetTriggerDelay(trig_dly)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Starting acquisition and capturing data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Acq_start\n",
+      "Trigger state: 0\n",
+      "Fill state: False\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Start Acquisition\n",
+    "print(\"Acq_start\")\n",
+    "rp.rp_AcqStart()\n",
+    "\n",
+    "# Specify trigger - input 1 positive edge\n",
+    "rp.rp_AcqSetTriggerSrc(acq_trig_sour)\n",
+    "\n",
+    "time.sleep(5)\n",
+    "\n",
+    "rp.rp_GenTriggerOnly(channel)       # Trigger generator\n",
+    "\n",
+    "print(f\"Trigger state: {rp.rp_AcqGetTriggerState()[1]}\")\n",
+    "\n",
+    "# Trigger state\n",
+    "while 1:\n",
+    "    trig_state = rp.rp_AcqGetTriggerState()[1]\n",
+    "    if trig_state == rp.RP_TRIG_STATE_TRIGGERED:\n",
+    "        break\n",
+    "\n",
+    "# Fill state\n",
+    "print(f\"Fill state: {rp.rp_AcqGetBufferFillState()[1]}\")\n",
+    "\n",
+    "while 1:\n",
+    "    if rp.rp_AcqGetBufferFillState()[1]:\n",
+    "        break\n",
+    "\n",
+    "\n",
+    "### Get data ###\n",
+    "# Volts\n",
+    "fbuff = rp.fBuffer(N)\n",
+    "res = rp.rp_AcqGetOldestDataV(rp.RP_CH_1, N, fbuff)[1]\n",
+    "\n",
+    "data_V = np.zeros(N // 2, dtype = float)\n",
+    "\n",
+    "for i in range(0, N // 2, 1):\n",
+    "    data_V[i] = fbuff[i + N // 2]\n",
+    "\n",
+    "plt.plot(data_V)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Release resources\n",
+    "rp.rp_Release()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One of the applications for this example is to measure how many samples are taken from the triggering moment to the start of the captured pulse, which corresponds to propagation delay on the transmission line."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Note\n",
+    "There are a lot of different commands for the Acquisition. The list of available functions is quite an achievement to read through, so from now on, please refer to the *C and Python API section* of the [SCPI & API command list](https://redpitaya.readthedocs.io/en/latest/appsFeatures/remoteControl/command_list.html#list-of-supported-scpi-api-commands) for all available commands.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (RP api)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}