api/python/vds1022.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1691ce30",
   "metadata": {},
   "source": [
    "# VDS 1022/i Oscilloscope\n",
    "\n",
    "To install from this folder :"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4e8bc9",
   "metadata": {},
   "source": [
    "`python -m pip install .`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "264c9c3f",
   "metadata": {},
   "source": [
    "Help:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e311868",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "help(vds1022)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7e66d69",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "help(vds1022.Frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ed02b3a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "help(vds1022.Frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48a8221e",
   "metadata": {},
   "source": [
    "Note that the first call of `VDS1022()` will take a few seconds since it has to load the FPGA firmware.  \n",
    "The device will remain connected unless `.dispose()` is called or if the kernel is restarted.  \n",
    "Interrupting the kernel (`I`,`I`) will not terminate the connection.\n",
    "\n",
    "### Examples :\n",
    "1. [Measure voltage](#1.-Read-voltage)\n",
    "2. [Acquire a signal](#2.-Acquire-a-signal)\n",
    "3. [Live plotting](#3.-Live-plotting)\n",
    "4. [Data logging](#4.-Data-logging)\n",
    "5. [Continuous sampling](#5.-Continuous-sampling)\n",
    "6. [Decoding](#6.-Decoding)\n",
    "7. [Spectrum analysis](#7.-Spectrum-analysis)\n",
    "8. [Calibration](#8.-Calibration)\n",
    "9. [Release device](#9.-Release-device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d9a759e",
   "metadata": {},
   "source": [
    "## 1. Measure voltage"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8634cd25",
   "metadata": {},
   "source": [
    "Read RMS voltage on channel 1  \n",
    "Available metrics: `size, rms, avg, max, min, std, levels, freq, phase, median, percentile`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c485f721",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_channel(CH1, range='10v', offset=1/10, probe='x10')\n",
    "frames = dev.fetch()\n",
    "print(\"%s Vrms\" % frames.ch1.rms())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d60bf08c",
   "metadata": {},
   "source": [
    "Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0093a70e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "frames.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6757a3d",
   "metadata": {},
   "source": [
    "Measure in a loop (interrupt to stop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0b4df67",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    for frames in dev.fetch_iter(freq=2, autorange=False):\n",
    "        print('CH1: %sv     ' % frames.ch1.rms(), end='\\r')\n",
    "except KeyboardInterrupt: pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57a4dad9",
   "metadata": {},
   "source": [
    "## 2. Acquire a signal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d990ca",
   "metadata": {},
   "source": [
    "Autoset the device and plot the signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53b2a474",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "frames = dev.autoset().fetch()\n",
    "frames.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "916347ad",
   "metadata": {},
   "source": [
    "Generate descriptive statistics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d85f9c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "frames.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33cb7b63",
   "metadata": {},
   "source": [
    "Convert to [pandas DataFrame](https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html#dataframe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b1d7a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "frames.to_dataframe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70dceae8",
   "metadata": {},
   "source": [
    "Convert to [Numpy ndarray](https://numpy.org/doc/stable/reference/arrays.ndarray.html).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c32a3ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "frames.to_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68d44094",
   "metadata": {},
   "source": [
    "Set a trigger and plot the signal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb3927d5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_timerange('10ms')\n",
    "dev.set_channel(CH1, range='20v', offset=5/10, probe='x10')\n",
    "dev.set_channel(CH2, range='20v', offset=1/10, probe='x10')\n",
    "dev.set_trigger(CH1, EDGE, RISE, level='2v', position=1/2)\n",
    "frames = dev.fetch()\n",
    "frames.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c684d09",
   "metadata": {},
   "source": [
    "## 3. Live plotting\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2720c7bf",
   "metadata": {},
   "source": [
    "Plot the signals with AUTO auto sweep mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7673722",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('250k')\n",
    "dev.set_channel(CH1, range='20v', offset=5/10, probe='x10')\n",
    "dev.set_channel(CH2, range='20v', offset=1/10, probe='x10')\n",
    "dev.set_trigger(CH1, EDGE, RISE, level='1v', position=1/2, sweep=AUTO)\n",
    "dev.plot(freq=2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9ac3396",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev.stop();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa7883b5",
   "metadata": {},
   "source": [
    "Plot the signals with NORMAL sweep mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f37ce617",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('250k')\n",
    "dev.set_channel(CH1, range='20v', offset=5/10, probe='x10')\n",
    "dev.set_channel(CH2, range='20v', offset=1/10, probe='x10')\n",
    "dev.set_trigger(CH1, EDGE, RISE, level='1v', position=1/2, sweep=NORMAL)\n",
    "dev.plot(freq=2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a874ba90",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev.stop();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b35af35",
   "metadata": {},
   "source": [
    "## 4. Data logging\n",
    "This section provides examples to measure a signal at a defined interval."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4bbf843",
   "metadata": {},
   "source": [
    "Stream the RMS voltage to a plot every second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72feb704",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_channel(CH1, range='10v', offset=1/10, probe='x10')\n",
    "dev.stream(freq=2).rms().plot();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85322394",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev.stop();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0cd8dd6",
   "metadata": {},
   "source": [
    "Stream the average voltage to stdout every second."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91e2a00e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_channel(CH1, range='20v', offset=1/10, probe='x10')\n",
    "dev.set_channel(CH2, range='20v', offset=1/10, probe='x10')\n",
    "dev.stream(freq=1).avg().sink(print);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a16d920e",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev.stop();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "850ccb3e",
   "metadata": {},
   "source": [
    "Device roll/slow mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c09a41b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_timerange('60s', roll=True)\n",
    "dev.set_channel(CH1, range='10v', offset=1/10, probe='x10')\n",
    "dev.plot(freq=1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9175520",
   "metadata": {},
   "outputs": [],
   "source": [
    "dev.stop();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26b7bfba",
   "metadata": {},
   "source": [
    "Help:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d12f0446",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "help(vds1022.Stream)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d392ef",
   "metadata": {},
   "source": [
    "## 5. Continuous sampling\n",
    "\n",
    "This section provides examples to aquire and plot continuous samples without interruption for a defined duration.  \n",
    "While this device can acquire sampling frames at 100Ms/s, the maximum continuous sampling rate is around 100Ks/s.  \n",
    "If the amount of collected data is too consequent, the ploting will have to go through rasterization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e09545c",
   "metadata": {},
   "source": [
    "Acquire continuously 10 samples per period for a 1Khz signal and plot :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaf46dda",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('10k')  # 1K samples per seconds * 10 samples\n",
    "dev.set_channel(CH1, range='10v', offset=2/10, probe='x10')\n",
    "dev.set_trigger(CH1, EDGE, FALL, level='2.5v')\n",
    "\n",
    "frames = dev.read('1s')\n",
    "frames.plot()\n",
    "print(\"Samples: %s\" % frames.ch1.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f36878be",
   "metadata": {},
   "outputs": [],
   "source": [
    "frames.slice('0.5s', '0.6s').plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6be8dc",
   "metadata": {},
   "source": [
    "Acquire continuously 10 samples per period for a 1Khz signal and plot with rasterisation :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "155c6f63",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "import hvplot.pandas\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('10k')  # 1K samples per seconds * 10 samples\n",
    "dev.set_channel(CH1, range='10v', offset=2/10, probe='x10')\n",
    "dev.set_trigger(CH1, EDGE, FALL, level='2.5v')\n",
    "\n",
    "df = dev.read('1s').to_dataframe()\n",
    "df.hvplot(rasterize=True).opts(width=800, ylim=dev.ylim(), colorbar=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3509cea5",
   "metadata": {},
   "source": [
    "## 6. Decoding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "469b7b0c",
   "metadata": {},
   "source": [
    "TTL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a3fb967",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('10k')  # 1K samples per seconds * 10 samples\n",
    "dev.set_channel(CH1, range='10v', offset=2/10, probe='x10')\n",
    "dev.set_trigger(CH1, EDGE, FALL, level='2.5v')\n",
    "\n",
    "frames = dev.read('1s')\n",
    "frames.ch1.to_ttl()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47f2215d",
   "metadata": {},
   "source": [
    "I2C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7fa49f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022()\n",
    "dev.set_sampling('10k')  # signal frequency * n samples\n",
    "dev.set_channel(CH1, range='20v', offset=5/10, probe='x10')  # sda\n",
    "dev.set_channel(CH2, range='20v', offset=1/10, probe='x10')  # scl\n",
    "dev.set_trigger(CH1, EDGE, FALL, position=1/20, level='1.2v')\n",
    "frames = dev.fetch()\n",
    "frames.plot()\n",
    "\n",
    "for msg in frames.decode_i2c():\n",
    "    print(msg, msg.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "863132d2",
   "metadata": {},
   "source": [
    "## 7. Spectrum analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0e91a47",
   "metadata": {},
   "source": [
    "Plot spectrum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32421a07",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from numpy import log10, arange, pi, sqrt\n",
    "from vds1022 import *\n",
    "\n",
    "# Setup device for 1kHz signal\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('50k')  # samples per second\n",
    "dev.set_channel(CH1, range='20v', probe='x10', coupling=DC)\n",
    "# dev.set_trigger(CH1)  # align phase angle origine at center\n",
    "\n",
    "# Acquire samples and compute the discrete Fourier Transform\n",
    "frame = dev.fetch().ch1\n",
    "f, m, p = frame.spectrum()  # frequencies(Hz), magnitudes(Vmax), phases(-1+1)\n",
    "\n",
    "# Plot\n",
    "fig, axs = plt.subplots(4, 1, figsize=(10, 4 * 1.6), constrained_layout=True)\n",
    "for ax in axs: ax.grid()\n",
    "axs[0].set(ylabel='y(t)', xlabel='Time [ms]', ylim=frame.ylim)\n",
    "axs[1].set(ylabel='Magnitude [Vrms]')\n",
    "axs[2].set(ylabel='Magnitude [dBV]', yticks=arange(-80,20,20))\n",
    "axs[3].set(ylabel='Phase -1+1', xlabel='Frequency [kHz]', ylim=(-1,1))\n",
    "axs[0].plot(frame.x() * 1000, frame.y())\n",
    "axs[1].plot(f / 1000, m / sqrt(2))         # Vmax to Vrms\n",
    "axs[2].plot(f / 1000, 20 * log10(m))       # Vmax to log\n",
    "axs[3].plot(f / 1000, p * (m > frame.sy))  # Phases -1+1\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aba3006d",
   "metadata": {},
   "source": [
    "Extract components from signal.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e9c13de",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "for f, m, p in frame.components(threshold='3%'):\n",
    "    print(\"%6s Hz  %5.2f Vrms  %5.2f rad\" % (f, m / sqrt(2), p * pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1156107f",
   "metadata": {},
   "source": [
    "**Power Spectral Density (PSD)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ec8b00f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from vds1022 import *\n",
    "\n",
    "# Setup device\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('100k')  #  1kHz * 100 samples\n",
    "dev.set_channel(CH1, range='20v', probe='x10', coupling=DC)\n",
    "\n",
    "# Acquire samples\n",
    "frame = dev.fetch().ch1\n",
    "xs, ys = frame.xy()\n",
    "\n",
    "# Plot\n",
    "fig, axs = plt.subplots(2, 1, figsize=(10, 4), constrained_layout=True)\n",
    "for ax in axs: ax.grid()\n",
    "axs[0].set(ylabel='y(t)', xlabel='Time [ms]', ylim=frame.ylim)\n",
    "axs[0].plot(xs, ys)\n",
    "axs[1].psd(ys, 512, 1 / frame.sx)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca5f6db1",
   "metadata": {},
   "source": [
    "## 8. Frequency response"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb97d7ae",
   "metadata": {},
   "source": [
    "**Manually sweep frequencies and plot a Bode graph**  \n",
    "The plotting is done once the excution is interrupted (Ctrl+C or I+I)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2601a7cc",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.set_sampling('10k')\n",
    "dev.set_channel(CH1, range='10v', probe='x10')\n",
    "dev.set_channel(CH2, range='10v', probe='x10')\n",
    "\n",
    "points, freq_prev = { }, -1\n",
    "try:\n",
    "    for ch1, ch2 in dev.fetch_iter(freq=4):\n",
    "        freq, phase = ch1.freq()  # compute frequency and phase\n",
    "        freq = freq and round(freq)\n",
    "        if freq and freq == freq_prev:\n",
    "            points[freq] = 20 * np.log10(ch2.rms() / ch1.rms())\n",
    "            dev.set_sampling(freq * 50)  # increase frequency\n",
    "            print('%d: %dHz  %.fdBv   ' % (len(points), freq, points[freq]), end='\\r')\n",
    "        freq_prev = freq\n",
    "\n",
    "except KeyboardInterrupt:\n",
    "    x, y = zip(*sorted(points.items()))  # sort, unzip\n",
    "\n",
    "    plt.subplots(figsize=(12, 4))\n",
    "    plt.xlabel('Frequency [Hz]')\n",
    "    plt.ylabel('Gain [dBV]')\n",
    "    plt.grid(True, which=\"both\", axis='x')\n",
    "    plt.grid(True, which=\"major\", axis='y')\n",
    "    plt.minorticks_on()\n",
    "    plt.xscale('log')\n",
    "    plt.xlim(10 ** int(np.log10(x[0])), 10 ** int(np.log10(x[-1] * 10)))\n",
    "    plt.ylim(-60, 20)\n",
    "    plt.plot(x, y)\n",
    "    plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5df43bbc",
   "metadata": {},
   "source": [
    "## 9. Calibration\n",
    "Wait a few minutes for the temperature of the device to stabilize before running the calibration.  \n",
    "Once done, the calibration is saved to a file which will be used from now on.  \n",
    "To restore the factory calibration, simply delete the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf645020",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.calibrate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0086a6f6",
   "metadata": {},
   "source": [
    "## 10. Release device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "398380f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022 import *\n",
    "\n",
    "dev = VDS1022(debug=0)\n",
    "dev.dispose()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00675248",
   "metadata": {},
   "source": [
    "## 11. Audio generator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5a17de6",
   "metadata": {},
   "source": [
    "This section provides examples to generate a signal with a sound card.  \n",
    "For an accurate output, disable the sound effects in the sound card settings.  \n",
    "The generated signal is arround +1,-1 volt depending on the volume.   \n",
    "\n",
    "https://pyacq.readthedocs.io/en/latest/examples/pyaudio_oscope_local.html  \n",
    "https://www.szynalski.com/tone-generator/  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "571d7e5c",
   "metadata": {},
   "source": [
    "**List devices**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d6dc88a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022.generator import Generator\n",
    "Generator.print_devices()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d43db156",
   "metadata": {},
   "source": [
    "**Play a indefinitely a sine wave on the default device.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d91302dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022.generator import Generator\n",
    "\n",
    "sg = Generator(device=None, scale=1)\n",
    "sg.sine(freq=900)  # next channel (left)\n",
    "sg.sine(freq=300)  # next channel (right)\n",
    "sg.plot()\n",
    "sg.play()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bc38c6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "sg.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aeb0a6b",
   "metadata": {},
   "source": [
    "**Generate a composite signal**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "914f0d01",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from vds1022.generator import Generator\n",
    "\n",
    "sg = Generator(device=None, scale=0.5)\n",
    "\n",
    "# channel 0 (left)\n",
    "sg.sine(channel=0, freq=1000*1, scale=1.41/1)  # square wave harmonic 1\n",
    "sg.sine(channel=0, freq=1000*3, scale=1.41/3)  # square wave harmonic 3\n",
    "sg.sine(channel=0, freq=1000*5, scale=1.41/5)  # square wave harmonic 5\n",
    "sg.sine(channel=0, freq=1000*7, scale=1.41/7)  # square wave harmonic 7\n",
    "\n",
    "# channel 1 (right)\n",
    "sg.square(channel=1, freq=1000)  # ideal square wave\n",
    "\n",
    "sg.plot()\n",
    "sg.play(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0600e4b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "sg.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "103667f8",
   "metadata": {},
   "source": [
    "**Sweep a frequency range**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2b8cb4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from vds1022.generator import Generator\n",
    "\n",
    "sg = Generator(device=None, scale=1)\n",
    "sg.sweep(duration=1, f0=1, f1=1000)\n",
    "sg.play(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a1ef0f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "sg.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55cadeb7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}