From ac00bd6fbe7acb6ea57952375f1e440063818a00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20Ku=CC=88hle?= Date: Tue, 19 Nov 2019 14:53:29 +0100 Subject: [PATCH 1/8] Rename of jupyter notebook and enhanced vals check in driver --- .../QCodes example with QDevil_QDAC.ipynb | 497 ++++++++++++++++++ 1 file changed, 497 insertions(+) create mode 100644 docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb new file mode 100644 index 000000000..1dc70eddb --- /dev/null +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -0,0 +1,497 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# QCoDeS Example with QDevil_QDAC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import qcodes as qc\n", + "import numpy as np\n", + "from time import sleep\n", + "import qcodes.instrument_drivers.QDevil.QDevil_QDAC as QDac" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Connect to the instrument\n", + "# By default the initialisation skips reading the current sensors on all channels\n", + "# as this takes some 0.2-0.5 secs per channel due to the sensor settling time. \n", + "# You can force reading the current sensors at startup by specifiying\n", + "# \"update_currents=True\" in the call.\n", + "qdac = QDac.QDac(name='qdac', address='ASRL2::INSTR', update_currents=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic QDAC Usage\n", + "\n", + "The QDevil_Qdac_channels driver supports controlling each individual BNC output channel. Each output channel \"qdac.ch##.\" has seven attributes:\n", + " * v: DC voltage\n", + " * mode: the combined voltage source and current sensor range: high/high (0), high/low (1), low/low (2)\n", + " * i: Current out (read-only)\n", + " * slope: Maximum ramp rate for an output channel\n", + " * sync: Sync output assigned to a channel \n", + " * sync_delay: Sync delay delay \n", + " * sync_duration: Sync duration\n", + " \n", + "The slope is the (maximal) slope in V/s that the channel will allow its voltage to change by. By default, all channels have a slope of \"Inf\". The slope can be changed dynamically, but no more than 8 channels can be ramped simultaneously.\n", + "\n", + "In addition this driver supports:\n", + " * Simultaneous ramping of up to 8 channels\n", + " * 2D ramping of two groups of channels (slow and fast channels, up to 8 in total)\n", + " * Reading the internal temperature sensors \n", + " * Pretty printing the state of all channels " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting voltages and reading currents" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Setting the output voltage of a channel using \"set\"\n", + "qdac.ch01.v.set(1)\n", + "# Reading the output voltage of a channel using \"get\"\n", + "print('Channel 1 voltage: {} {}'.format(qdac.ch01.v.get(), qdac.ch01.v.unit))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Setting the output voltage of a channel using short-hand notation, which is used hereafter\n", + "qdac.ch01.v(-1)\n", + "# Reading the output voltage of a channel using short hand notion \"qdac.ch01.v()\", which is used hereafter\n", + "print('Channel 1 voltage: {} {}'.format(qdac.ch01.v(), qdac.ch01.v.unit))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Reading the current output of a channel \n", + "print(qdac.ch01.i(), qdac.ch01.i.unit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Smooth ramping between voltages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# For smooth voltage changes the maximal voltage change (in V/s) may be set for each channel\n", + "qdac.ch01.slope(1)\n", + "qdac.ch02.slope(2)\n", + "# An overview may be printed (all other channels have 'Inf' slope)\n", + "qdac.print_slopes()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Now setting channel 1 and 2 voltages will cause slow ramping to 0V (1 V/s and 2 V/s, respectively)\n", + "# Note that ch02 is already at 0 V, so the ramping function will complain bacause a ramp time\n", + "# less than 2 ms is not possible.\n", + "qdac.ch01.v(0)\n", + "qdac.ch02.v(0)\n", + "sleep(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Note that only 8 (or fewer) channels can be slow ramped at a time\n", + "# To disable slow ramping of a channel, set its slope to 'Inf':\n", + "qdac.ch01.slope('Inf')\n", + "qdac.print_slopes()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Addressing multiple channels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Multiple channels can be addressed simultaneously via the 'channels' list, by use of slicing.\n", + "# Note that numbering goes from 0 to N, where N is the number of channels. \n", + "# This will query voltages of all channels of a 24 channel QDAC \n", + "# Note that index 0 refer to channel 01, and so on \n", + "print(qdac.channels[0:24].v())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Similarly, we may set them. The outputs will not change simultaneously but witin some milliseconds.\n", + "qdac.channels[0:24].v(-0.9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Output a SYNC pulse\n", + "The QDAC can output a puls one one of the SYNC outputs when a channel is ramped, either using the \"slope\" functionality, see above, or when using one of the ramping functions below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# To each channel one may assign a SYNC output\n", + "# SYNC output 1 will fire a 10 ms 5 V pulse when ch02 initiates a ramp\n", + "# ch will ramp when setting a voltage while a slope is assinged, or when using \"ramp_voltages\"\n", + "qdac.ch02.sync(1) \n", + "# note that a pulse is still fired even if no visible ramp is performed\n", + "# e.g if ramping from 1 V to 1 V\n", + "\n", + "# The sync pulse settings can be modified\n", + "qdac.ch02.sync_delay(0) # The sync pulse delay (s)\n", + "qdac.ch02.sync_duration(25e-3) # The sync pulse duration (secs). Default is 10 ms.\n", + "\n", + "# Print an overview of assigned SYNC ports\n", + "qdac.print_syncs()\n", + "\n", + "qdac.ch02.slope(1)\n", + "qdac.ch02.v(-0.5)\n", + "sleep(3)\n", + "qdac.ch02.v(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# syncs are unassigned by assigning sync 0\n", + "qdac.ch02.sync(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ramp one or more channels simultaneously \n", + "Setting several channels simutaneously is only possible using \"ramp_voltages\". Note that " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Here we ramp channels 1,9,11, and 16 from there current values to zero, in 0.2 seconds\n", + "duration = qdac.ramp_voltages([1,9,11,16],[],[0,0,0,0],0.2)\n", + "sleep(duration+0.05)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# As it takes tens of milliseconds to read the channels' current voltage, it is faster \n", + "# if their previous voltages are known:\n", + "duration = qdac.ramp_voltages([1,9,11,16],[0,0,0,0],[1,2,3,4],0.2)\n", + "sleep(duration+0.05)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ramp a single channel step by step and record and plot the current sensor reading" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Perform a 1D scan of the QDAC ch01 and record the current on\n", + "# the same channel also using the QDAC. \n", + "# Replace the QDAC current measurement by a DMM to do a typical physical measurement\n", + "\n", + "from qcodes.dataset.plotting import plot_by_id\n", + "from qcodes.dataset.measurements import Measurement\n", + "from time import ctime\n", + "STATION = qc.station.Station(qdac)\n", + "qc.new_experiment(\"QDAC\", \"TestIV\"+ctime())\n", + "meas = Measurement()\n", + "meas.register_parameter(qdac.ch01.v) # register the independent parameter\n", + "meas.register_parameter(qdac.ch01.i, setpoints=(qdac.ch01.v,)) # now register the dependent one\n", + "meas.write_period = 2\n", + "with meas.run() as datasaver:\n", + " for set_v in np.linspace(-1, 1, 10):\n", + " qdac.ch01.v(set_v)\n", + " sleep(0.1)\n", + " get_i = qdac.ch01.i()\n", + " datasaver.add_result((qdac.ch01.v, set_v),\n", + " (qdac.ch01.i, get_i))\n", + " print(set_v, get_i)\n", + " dataset = datasaver.dataset\n", + "myplot = plot_by_id(dataset.run_id)\n", + "qc.dataset.plotting.plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2D scan \n", + "It is possible to ramp two groups of channels simultaneously. This is useful for a 2D data acquisition setup\n", + "Note! The slope definitions are not used during the 2D scan." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# set outputs to zero\n", + "qdac.ch01.v(0)\n", + "qdac.ch02.v(0)\n", + "qdac.ch03.v(0)\n", + "\n", + "# enable sync on one of the fast channels (sync signal is output at every start of a staircase ramp.)\n", + "# for example for triggering a digitizer\n", + "qdac.ch02.sync(1)\n", + "# enable a 10ms sync delay which allows for stabilizing of the device\n", + "qdac.ch02.sync_delay(0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Note! The slope definitions are not used during the 2D scan\n", + "duration = qdac.ramp_voltages_2D( slow_chans=[1], slow_vstart=[0], slow_vend=[1],\n", + " fast_chans=[2,3], fast_vstart=[0,0], fast_vend=[1,-1],\n", + " slow_steps = 10, fast_steps = 10,\n", + " step_length=0.02)\n", + "# wait for the ramp to finish\n", + "sleep(duration+0.1)" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Set outputs back to zero\n", + "# First remove sync output so that we do not trigger an acquisition\n", + "qdac.ch02.sync(0)\n", + "qdac.ch01.v.set(0)\n", + "qdac.ch02.v.set(0)\n", + "qdac.ch03.v.set(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The \"mode\" parameter: controlling voltage and current ranges: \n", + "The mode parameter is can be 0, 1 or 2:\n", + "\n", + "0: high voltage/high current, 1: high voltage/low current, 2: low voltage/low current" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# The \"QDac.Mode\" class and \"QDac.mode_dict\" dictionary help setting and reading the mode. \n", + "# QCAD.Mode: 0=vhigh_ihigh, 1=vhigh_ilow, 2=vlow_ilow\n", + "\n", + "# This will set the voltage output range to low, and the current sensor range to low\n", + "qdac.ch01.mode(QDac.Mode.vlow_ilow)\n", + "print(QDac.mode_dict[qdac.ch01.mode()])\n", + "\n", + "# This will return ch01 to the default mode: high voltage range, high current sensing range\n", + "qdac.ch01.mode(QDac.Mode.vhigh_ihigh)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Changing \"mode\" between (0,1) and 2 - attention!\n", + "\n", + "The \"mode\" parameter is controlling a voltage attenuator and a current measurement shunt resistor. When changing \"mode\" so that the voltage range is changing - form (0,1) to 2 or vice versa - the attenuator is switched immidiately. The driver will re-adjust the output voltage in order to keep it constant, but a spike will always occur. If the set voltage is outside the range of the low range and the transition is from high to low range, the output will be clipped. So it is recommended always to set the output to zero before changing the voltage range." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Here is a small example showing demonstrating the behavior - if posible hook up an oscilloscope on ch01\n", + "#\n", + "qdac.ch01.slope('Inf') # Make sure that we are not fooled by a slow changing ch01 \n", + "qdac.ch01.mode(QDac.Mode.vhigh_ihigh) # Attenuation OFF (the default), high voltage range\n", + "qdac.ch01.v(1.5) # Set the voltage to outside the low voltage range (but inside present range)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "qdac.ch01.mode(QDac.Mode.vlow_ilow) # Attenuation ON, low voltage range - signal is clipped, and a dip occurred\n", + "print(qdac.ch01.v()) # Returns approximately 1.1V as the output is clipped to the low range limit" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "qdac.ch01.mode(QDac.Mode.vhigh_ihigh) # Attenuation off, high voltage range\n", + "print(qdac.ch01.v()) # Returns approximately 1.1V, unchanged - but a spike occured" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview of channel settings\n", + "\n", + "The driver provides a method for pretty-printing the state of all channels. On startup, all channels are queried for voltage and current across them, but the current query is very slow (long integration time)\n", + "\n", + "The pretty-print method may or may not **update** the values for the currents, depending on the value of the `update_currents` flag. Each current reading takes some 200-500 ms, so updating all current values takes about 14-24 seconds depending on the number of channels." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "qdac.print_overview(update_currents=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Temperature sensors\n", + "Physically, the QDac consists of either three or six boards each hosting eight channels. For diagnostics purposes temperature sensors are placed at three locations on each board,. Read-only parameters for these sensors are provided, named tempX_Y where X is the board number (0-2, or 0-5) and Y the sensor number (0-2)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(qdac.temp0_0.get(), qdac.temp0_0.unit)\n", + "print(qdac.temp2_1.get(), qdac.temp0_0.unit)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "qdac.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 396f13253561d8d33b1d76c342e0ca6ac3bb7c8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20Ku=CC=88hle?= Date: Thu, 28 Nov 2019 14:34:21 +0100 Subject: [PATCH 2/8] Added "nbsphinx": { "execute": "never" } to notebook example, so that it is not executed during automatic tests Removed unused imports from drivers Replaced parameter .get_latest by .cache and ._save_val by .cache.set --- .../QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb index 1dc70eddb..e262bd08f 100644 --- a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -285,7 +285,7 @@ " print(set_v, get_i)\n", " dataset = datasaver.dataset\n", "myplot = plot_by_id(dataset.run_id)\n", - "qc.dataset.plotting.plt.show()" + "qc.dataset.plotting.plt.show() # It may be necessary to comment this line for teh graph to sho in Jupyter" ] }, { @@ -490,6 +490,9 @@ "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.0" + }, + "nbsphinx": { + "execute": "never" } }, "nbformat": 4, From d8c507665f6f9f5949703083cc49776030228b5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20Ku=CC=88hle?= Date: Mon, 2 Dec 2019 13:33:26 +0100 Subject: [PATCH 3/8] style: fixed notebook example after correcting linting errors --- .../QDAC1/QCodes example with QDevil_QDAC.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb index e262bd08f..936aa2b91 100644 --- a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -285,7 +285,7 @@ " print(set_v, get_i)\n", " dataset = datasaver.dataset\n", "myplot = plot_by_id(dataset.run_id)\n", - "qc.dataset.plotting.plt.show() # It may be necessary to comment this line for teh graph to sho in Jupyter" + "#qc.dataset.plotting.plt.show() # It is necessasry to uncomment this line when executed outside of Jupyter" ] }, { @@ -322,7 +322,7 @@ "outputs": [], "source": [ "# Note! The slope definitions are not used during the 2D scan\n", - "duration = qdac.ramp_voltages_2D( slow_chans=[1], slow_vstart=[0], slow_vend=[1],\n", + "duration = qdac.ramp_voltages_2d( slow_chans=[1], slow_vstart=[0], slow_vend=[1],\n", " fast_chans=[2,3], fast_vstart=[0,0], fast_vend=[1,-1],\n", " slow_steps = 10, fast_steps = 10,\n", " step_length=0.02)\n", @@ -372,15 +372,16 @@ "metadata": {}, "outputs": [], "source": [ - "# The \"QDac.Mode\" class and \"QDac.mode_dict\" dictionary help setting and reading the mode. \n", + "# The \"QDac.Mode\" class and \"QDac.MODE_DICT\" dictionary help setting and reading the mode. \n", "# QCAD.Mode: 0=vhigh_ihigh, 1=vhigh_ilow, 2=vlow_ilow\n", "\n", "# This will set the voltage output range to low, and the current sensor range to low\n", "qdac.ch01.mode(QDac.Mode.vlow_ilow)\n", - "print(QDac.mode_dict[qdac.ch01.mode()])\n", + "print(QDac.MODE_DICT[qdac.ch01.mode()])\n", "\n", "# This will return ch01 to the default mode: high voltage range, high current sensing range\n", - "qdac.ch01.mode(QDac.Mode.vhigh_ihigh)" + "qdac.ch01.mode(QDac.Mode.vhigh_ihigh)\n", + "print(QDac.MODE_DICT[qdac.ch01.mode()])" ] }, { From ef2f2e1ee36f7bbe24301a7bfd77ae527307386b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20Ku=CC=88hle?= Date: Mon, 10 Feb 2020 14:18:43 +0100 Subject: [PATCH 4/8] refactor: Update QDevil_QDAC driver and example notebook Apply most changes suggested in review, and changed behavior to not touch the outputs at initialisation. The QDAC state is instead read at initialisation leaving any on going ramping to continue, thus restoring the internal generator book keeping. A reset command is added to make it possible to reset all parameters to default values. --- .../QCodes example with QDevil_QDAC.ipynb | 165 +++++++++++++----- 1 file changed, 126 insertions(+), 39 deletions(-) diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb index 936aa2b91..157037018 100644 --- a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -16,7 +16,20 @@ "import qcodes as qc\n", "import numpy as np\n", "from time import sleep\n", - "import qcodes.instrument_drivers.QDevil.QDevil_QDAC as QDac" + "import qcodes.instrument_drivers.QDevil.QDevil_QDAC as QDac\n", + "from qcodes.instrument_drivers.QDevil.QDevil_QDAC import Mode" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialisation\n", + "When initialised, the driver will read in the state of the QDAC to the extend spossible. This means that initialisation does not change any outputs, implying that any ongoing ramping is continuing undisturbed. The initialisation is, however, **not** able to figure out if any **slopes** have been assigned to channels, see later. So these will have to be set again by the user. \n", + "\n", + "During the initialisation all channels are queried in order to update the parmeter cache. However, as the current query is very slow due to the long current sensor integration time, it is optional to update currents. They are only read at startup if the **update_currents** flag is set to True. \n", + "\n", + "NOTE: After switching the QDAC off and back on the driver has to be re-initialised, OR the reset() command has to be executed." ] }, { @@ -28,9 +41,10 @@ "# Connect to the instrument\n", "# By default the initialisation skips reading the current sensors on all channels\n", "# as this takes some 0.2-0.5 secs per channel due to the sensor settling time. \n", - "# You can force reading the current sensors at startup by specifiying\n", - "# \"update_currents=True\" in the call.\n", - "qdac = QDac.QDac(name='qdac', address='ASRL2::INSTR', update_currents=False)" + "# You can force reading the current sensors at startup by specifiying \"update_currents=True\" in the call.\n", + "\n", + "qdac = QDac.QDac(name='qdac', address='ASRL2::INSTR', update_currents=False)\n", + "print(\"Number of channels: \",qdac.num_chans)" ] }, { @@ -39,22 +53,25 @@ "source": [ "## Basic QDAC Usage\n", "\n", - "The QDevil_Qdac_channels driver supports controlling each individual BNC output channel. Each output channel \"qdac.ch##.\" has seven attributes:\n", + "The QDevil_QDAC driver supports controlling each individual BNC output channel. Each output channel \"qdac.ch##.\" has seven attributes:\n", " * v: DC voltage\n", - " * mode: the combined voltage source and current sensor range: high/high (0), high/low (1), low/low (2)\n", " * i: Current out (read-only)\n", - " * slope: Maximum ramp rate for an output channel\n", + " * mode: the combined voltage output and current sensor range: Mode.vhigh_ihigh, Mode.vhigh_ilow, Mode.vlow_ilow\n", + " * slope: Maximum ramp rate for an output channel when changing teh DC voltage,v.\n", " * sync: Sync output assigned to a channel \n", - " * sync_delay: Sync delay delay \n", - " * sync_duration: Sync duration\n", + " * sync_delay: Sync pulse delay \n", + " * sync_duration: Sync pulse duration\n", " \n", "The slope is the (maximal) slope in V/s that the channel will allow its voltage to change by. By default, all channels have a slope of \"Inf\". The slope can be changed dynamically, but no more than 8 channels can be ramped simultaneously.\n", "\n", "In addition this driver supports:\n", + " * Reset the QDAC to start up conditions. Allows continuing operation after the QDAC has been \n", + " powered off/on without restarting teh driver\n", " * Simultaneous ramping of up to 8 channels\n", " * 2D ramping of two groups of channels (slow and fast channels, up to 8 in total)\n", + " * Override of protection against mode change for non-zero output voltages\n", " * Reading the internal temperature sensors \n", - " * Pretty printing the state of all channels " + " * Pretty printing the state of all channels, of assigned sync outputs and of assigned slopes " ] }, { @@ -148,7 +165,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Addressing multiple channels" + "### Addressing multiple channels\n", + "Multiple channels can be addressed simultaneously via the 'channels' list, by use of slicing.\n", + "Note that numbering goes from 0 to N-1, where N is the number of channels. " ] }, { @@ -157,11 +176,9 @@ "metadata": {}, "outputs": [], "source": [ - "# Multiple channels can be addressed simultaneously via the 'channels' list, by use of slicing.\n", - "# Note that numbering goes from 0 to N, where N is the number of channels. \n", "# This will query voltages of all channels of a 24 channel QDAC \n", "# Note that index 0 refer to channel 01, and so on \n", - "print(qdac.channels[0:24].v())" + "print(qdac.channels[0:8].v())" ] }, { @@ -171,7 +188,7 @@ "outputs": [], "source": [ "# Similarly, we may set them. The outputs will not change simultaneously but witin some milliseconds.\n", - "qdac.channels[0:24].v(-0.9)" + "qdac.channels[0:8].v(-0.9)" ] }, { @@ -200,8 +217,16 @@ "qdac.ch02.sync_duration(25e-3) # The sync pulse duration (secs). Default is 10 ms.\n", "\n", "# Print an overview of assigned SYNC ports\n", - "qdac.print_syncs()\n", - "\n", + "qdac.print_syncs()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Plug in an oscilloscope to CH02 and SYNC1 and observe the ramping and the sync pulse\n", "qdac.ch02.slope(1)\n", "qdac.ch02.v(-0.5)\n", "sleep(3)\n", @@ -232,8 +257,8 @@ "metadata": {}, "outputs": [], "source": [ - "# Here we ramp channels 1,9,11, and 16 from there current values to zero, in 0.2 seconds\n", - "duration = qdac.ramp_voltages([1,9,11,16],[],[0,0,0,0],0.2)\n", + "# Here we ramp channels 1, 2, 3, and 7 from there current values to zero, in 0.2 seconds\n", + "duration = qdac.ramp_voltages([1,2,3,7],[],[0,0,0,0],0.2)\n", "sleep(duration+0.05)" ] }, @@ -245,7 +270,7 @@ "source": [ "# As it takes tens of milliseconds to read the channels' current voltage, it is faster \n", "# if their previous voltages are known:\n", - "duration = qdac.ramp_voltages([1,9,11,16],[0,0,0,0],[1,2,3,4],0.2)\n", + "duration = qdac.ramp_voltages([1,2,3,7],[0,0,0,0],[1,2,3,4],0.2)\n", "sleep(duration+0.05)" ] }, @@ -285,7 +310,7 @@ " print(set_v, get_i)\n", " dataset = datasaver.dataset\n", "myplot = plot_by_id(dataset.run_id)\n", - "#qc.dataset.plotting.plt.show() # It is necessasry to uncomment this line when executed outside of Jupyter" + "qc.dataset.plotting.plt.show() # Sometimes it is necessasry to out-comment this line in Jupyter...." ] }, { @@ -342,6 +367,15 @@ "" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "qdac.print_syncs()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -361,9 +395,13 @@ "metadata": {}, "source": [ "## The \"mode\" parameter: controlling voltage and current ranges: \n", - "The mode parameter is can be 0, 1 or 2:\n", + "The \"mode\" parameter is controlling the output voltage range (by an attenuator) and the current sensor range. Only certain combinations of the two are allowed, which is why they are conrolled by a single parameter. The mode parameter is allowed values are:\n", + "\n", + "Mode.vhigh_ihigh : high voltage output range / high current sensing range\n", "\n", - "0: high voltage/high current, 1: high voltage/low current, 2: low voltage/low current" + "Mode.vhigh_ilow : high voltage output range / low current sensing range\n", + "\n", + "Mode.vlow_ilow : low voltage output range / low current sensing range" ] }, { @@ -372,25 +410,26 @@ "metadata": {}, "outputs": [], "source": [ - "# The \"QDac.Mode\" class and \"QDac.MODE_DICT\" dictionary help setting and reading the mode. \n", - "# QCAD.Mode: 0=vhigh_ihigh, 1=vhigh_ilow, 2=vlow_ilow\n", + "# The \"QDac.Mode\" enum class is used for setting and reading the mode. \n", "\n", "# This will set the voltage output range to low, and the current sensor range to low\n", - "qdac.ch01.mode(QDac.Mode.vlow_ilow)\n", - "print(QDac.MODE_DICT[qdac.ch01.mode()])\n", + "qdac.ch01.mode(Mode.vlow_ilow)\n", + "print(qdac.ch01.mode.cache().get_label())\n", "\n", "# This will return ch01 to the default mode: high voltage range, high current sensing range\n", - "qdac.ch01.mode(QDac.Mode.vhigh_ihigh)\n", - "print(QDac.MODE_DICT[qdac.ch01.mode()])" + "qdac.ch01.mode(Mode.vhigh_ihigh)\n", + "print(qdac.ch01.mode.cache().get_label())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Changing \"mode\" between (0,1) and 2 - attention!\n", + "### When \"mode\" change results in change of voltage range\n", + "\n", + "When changing \"mode\" so that the voltage range is changed the attenuator is switched immidiately. The driver will re-adjust the output voltage in order to keep it constant, but a spike will always occur if the voltage is non-zero. If the set voltage is outside the range of the low range and the transition is from high to low range, the output will be clipped. \n", "\n", - "The \"mode\" parameter is controlling a voltage attenuator and a current measurement shunt resistor. When changing \"mode\" so that the voltage range is changing - form (0,1) to 2 or vice versa - the attenuator is switched immidiately. The driver will re-adjust the output voltage in order to keep it constant, but a spike will always occur. If the set voltage is outside the range of the low range and the transition is from high to low range, the output will be clipped. So it is recommended always to set the output to zero before changing the voltage range." + "To avoid spikes, the driver by default **does not allow changing the voltage range (mode)** when the output is non-zero. To over-ride this protection, set qdac.mode_force(True)." ] }, { @@ -402,7 +441,7 @@ "# Here is a small example showing demonstrating the behavior - if posible hook up an oscilloscope on ch01\n", "#\n", "qdac.ch01.slope('Inf') # Make sure that we are not fooled by a slow changing ch01 \n", - "qdac.ch01.mode(QDac.Mode.vhigh_ihigh) # Attenuation OFF (the default), high voltage range\n", + "qdac.ch01.mode(Mode.vhigh_ihigh) # Attenuation OFF (the default), high voltage range\n", "qdac.ch01.v(1.5) # Set the voltage to outside the low voltage range (but inside present range)" ] }, @@ -412,7 +451,8 @@ "metadata": {}, "outputs": [], "source": [ - "qdac.ch01.mode(QDac.Mode.vlow_ilow) # Attenuation ON, low voltage range - signal is clipped, and a dip occurred\n", + "qdac.mode_force(True) # Enable changing voltage range eventhough the output is non-zero\n", + "qdac.ch01.mode(Mode.vlow_ilow) # Attenuation ON, low voltage range - signal is clipped, and a dip occurred\n", "print(qdac.ch01.v()) # Returns approximately 1.1V as the output is clipped to the low range limit" ] }, @@ -422,17 +462,42 @@ "metadata": {}, "outputs": [], "source": [ - "qdac.ch01.mode(QDac.Mode.vhigh_ihigh) # Attenuation off, high voltage range\n", + "qdac.ch01.mode(Mode.vhigh_ihigh) # Attenuation off, high voltage range\n", "print(qdac.ch01.v()) # Returns approximately 1.1V, unchanged - but a spike occured" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Return to protected mode\n", + "qdac.mode_force(False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Now provoke an error\n", + "print(qdac.ch01.v())\n", + "print(qdac.ch01.mode.cache().get_label()) # Pretty printing the mode parameter\n", + "try:\n", + " qdac.ch01.mode(Mode.vlow_ilow)\n", + "except ValueError as ve:\n", + " print(\"ERROR: \", ve)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Overview of channel settings\n", + "## Overview of channels\n", "\n", - "The driver provides a method for pretty-printing the state of all channels. On startup, all channels are queried for voltage and current across them, but the current query is very slow (long integration time)\n", + "The driver provides a method for pretty-printing the state of all channels\n", "\n", "The pretty-print method may or may not **update** the values for the currents, depending on the value of the `update_currents` flag. Each current reading takes some 200-500 ms, so updating all current values takes about 14-24 seconds depending on the number of channels." ] @@ -443,7 +508,7 @@ "metadata": {}, "outputs": [], "source": [ - "qdac.print_overview(update_currents=True)" + "qdac.print_overview(update_currents=False)" ] }, { @@ -464,21 +529,43 @@ "print(qdac.temp2_1.get(), qdac.temp0_0.unit)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Resetting the driver and the QDAC\n", + "To get to a well defined state, the QDAC should be powered off and then on before starting this driver.\n", + "\n", + "Alternatively the reset command can be executed. The reset command can also be used to recover an off/on situation of the QDAC without having to restart the driver." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "qdac.reset(update_currents=False)\n", + "# Then print the overview gain\n", + "qdac.print_overview(update_currents=False)" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "# Shut down the VISA connection\n", "qdac.close()" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "'Python Interactive'", "language": "python", - "name": "python3" + "name": "30e14b23-afba-469e-97a2-7642068d43d1" }, "language_info": { "codemirror_mode": { From c367856c270fcd5bf44ae8908e7df3f1cb0e1541 Mon Sep 17 00:00:00 2001 From: "Jens H. Nielsen" Date: Thu, 5 Jan 2023 09:46:39 +0100 Subject: [PATCH 5/8] run pyupgrade on notebooks --- .../QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb index 157037018..50beb41de 100644 --- a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -90,7 +90,7 @@ "# Setting the output voltage of a channel using \"set\"\n", "qdac.ch01.v.set(1)\n", "# Reading the output voltage of a channel using \"get\"\n", - "print('Channel 1 voltage: {} {}'.format(qdac.ch01.v.get(), qdac.ch01.v.unit))" + "print(f'Channel 1 voltage: {qdac.ch01.v.get()} {qdac.ch01.v.unit}')" ] }, { @@ -102,7 +102,7 @@ "# Setting the output voltage of a channel using short-hand notation, which is used hereafter\n", "qdac.ch01.v(-1)\n", "# Reading the output voltage of a channel using short hand notion \"qdac.ch01.v()\", which is used hereafter\n", - "print('Channel 1 voltage: {} {}'.format(qdac.ch01.v(), qdac.ch01.v.unit))" + "print(f'Channel 1 voltage: {qdac.ch01.v()} {qdac.ch01.v.unit}')" ] }, { From 29c01a80e71a9e64192bda1201c59bd354d7feef Mon Sep 17 00:00:00 2001 From: "Jens H. Nielsen" Date: Thu, 5 Jan 2023 09:55:13 +0100 Subject: [PATCH 6/8] sort imports in notebooks --- .../QDAC1/QCodes example with QDevil_QDAC.ipynb | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb index 50beb41de..0466dc6eb 100644 --- a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -13,9 +13,11 @@ "metadata": {}, "outputs": [], "source": [ - "import qcodes as qc\n", - "import numpy as np\n", "from time import sleep\n", + "\n", + "import numpy as np\n", + "\n", + "import qcodes as qc\n", "import qcodes.instrument_drivers.QDevil.QDevil_QDAC as QDac\n", "from qcodes.instrument_drivers.QDevil.QDevil_QDAC import Mode" ] @@ -291,9 +293,11 @@ "# the same channel also using the QDAC. \n", "# Replace the QDAC current measurement by a DMM to do a typical physical measurement\n", "\n", - "from qcodes.dataset.plotting import plot_by_id\n", - "from qcodes.dataset.measurements import Measurement\n", "from time import ctime\n", + "\n", + "from qcodes.dataset.measurements import Measurement\n", + "from qcodes.dataset.plotting import plot_by_id\n", + "\n", "STATION = qc.station.Station(qdac)\n", "qc.new_experiment(\"QDAC\", \"TestIV\"+ctime())\n", "meas = Measurement()\n", From 5f113e3d2520e8fe285e4e4d2d5ebac937230190 Mon Sep 17 00:00:00 2001 From: "Jens H. Nielsen" Date: Thu, 5 Jan 2023 10:01:59 +0100 Subject: [PATCH 7/8] update qcodes imports --- .../QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb index 0466dc6eb..87e637aaf 100644 --- a/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb +++ b/docs/examples/QDevil/QDAC1/QCodes example with QDevil_QDAC.ipynb @@ -295,8 +295,7 @@ "\n", "from time import ctime\n", "\n", - "from qcodes.dataset.measurements import Measurement\n", - "from qcodes.dataset.plotting import plot_by_id\n", + "from qcodes.dataset import Measurement, plot_by_id\n", "\n", "STATION = qc.station.Station(qdac)\n", "qc.new_experiment(\"QDAC\", \"TestIV\"+ctime())\n", From 253011e883b7954af0248df66f51b259d5b2d741 Mon Sep 17 00:00:00 2001 From: "Jens H. Nielsen" Date: Mon, 23 Jan 2023 09:45:47 +0100 Subject: [PATCH 8/8] Add qdac 1 notebook to index --- docs/examples/QDevil/QDAC1/index.rst | 7 +++++++ docs/examples/QDevil/index.rst | 1 + 2 files changed, 8 insertions(+) create mode 100644 docs/examples/QDevil/QDAC1/index.rst diff --git a/docs/examples/QDevil/QDAC1/index.rst b/docs/examples/QDevil/QDAC1/index.rst new file mode 100644 index 000000000..9c637006e --- /dev/null +++ b/docs/examples/QDevil/QDAC1/index.rst @@ -0,0 +1,7 @@ +QCoDeS examples of how to use QDAC-I +==================================== + +.. toctree:: + :glob: + + * \ No newline at end of file diff --git a/docs/examples/QDevil/index.rst b/docs/examples/QDevil/index.rst index b641b3070..4b37c7023 100644 --- a/docs/examples/QDevil/index.rst +++ b/docs/examples/QDevil/index.rst @@ -3,4 +3,5 @@ QDevil drivers .. toctree:: + QDAC1/index QDAC2/index