{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", "try {\n", "require(['notebook/js/codecell'], function(codecell) {\n", " codecell.CodeCell.options_default.highlight_modes[\n", " 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n", " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", " Jupyter.notebook.get_cells().map(function(cell){\n", " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", " });\n", "});\n", "} catch (e) {};\n" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/javascript": [ "\n", "try {\n", "require(['notebook/js/codecell'], function(codecell) {\n", " codecell.CodeCell.options_default.highlight_modes[\n", " 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n", " Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n", " Jupyter.notebook.get_cells().map(function(cell){\n", " if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n", " });\n", "});\n", "} catch (e) {};\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] } ], "source": [ "# Import the QICK drivers and auxiliary libraries\n", "from qick import *\n", "from qick.rfboard import RFQickSoc\n", "%pylab inline" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "resetting clocks: 204.8\n", "\n", "QICK configuration:\n", "\n", "\tBoard: ZCU111\n", "\n", "\tGlobal clocks (MHz): tProcessor 384.000, RF reference 204.800\n", "\n", "\t7 signal generator channels:\n", "\t0:\taxis_signal_gen_v4 - tProc output 1, switch ch 0, maxlen 65536\n", "\t\tDAC tile 0, ch 0, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t1:\taxis_signal_gen_v4 - tProc output 2, switch ch 1, maxlen 65536\n", "\t\tDAC tile 0, ch 1, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t2:\taxis_signal_gen_v4 - tProc output 3, switch ch 2, maxlen 65536\n", "\t\tDAC tile 0, ch 2, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t3:\taxis_signal_gen_v4 - tProc output 4, switch ch 3, maxlen 65536\n", "\t\tDAC tile 1, ch 0, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t4:\taxis_signal_gen_v4 - tProc output 5, switch ch 4, maxlen 65536\n", "\t\tDAC tile 1, ch 1, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t5:\taxis_signal_gen_v4 - tProc output 6, switch ch 5, maxlen 65536\n", "\t\tDAC tile 1, ch 2, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t6:\taxis_signal_gen_v4 - tProc output 7, switch ch 6, maxlen 65536\n", "\t\tDAC tile 1, ch 3, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\n", "\t2 readout channels:\n", "\t0:\tADC tile 0, ch 0, 32-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 1024 (avg) 1024 (decimated), trigger 14, tProc input 0\n", "\t1:\tADC tile 0, ch 1, 32-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 1024 (avg) 1024 (decimated), trigger 15, tProc input 1\n", "\n", "\ttProc: 8192 words program memory, 4096 words data memory\n" ] } ], "source": [ "# Load bitstream with custom overlay\n", "# soc = QickSoc()\n", "soc = RFQickSoc(bitfile=\"qick_111_rfbrd.bit\")\n", "# Since we're running locally on the QICK, we don't need a separate QickConfig object.\n", "# If running remotely, you could generate a QickConfig from the QickSoc:\n", "# soccfg = QickConfig(soc.get_cfg())\n", "# or save the config to file, and load it later:\n", "# with open(\"qick_config.json\", \"w\") as f:\n", "# f.write(soc.dump_cfg())\n", "# soccfg = QickConfig(\"qick_config.json\")\n", "soccfg = soc\n", "print(soccfg)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Set BIAS DACs to integer values for testing.\n", "for i in range(8):\n", " soc.rfb_set_bias(i, i+1)\n", " \n", "# Set LO to 6.5 GHz\n", "soc.rfb_set_lo(6500)\n", "\n", "# Set attenuators to good values (tested for loopback with 10 dB external attenuation)\n", "for iGen in range(len(soccfg['gens'])):\n", " soc.rfb_set_genrf(gen_ch=iGen, att1=0, att2=30)\n", "\n", "for iRo in range(len(soccfg['readouts'])):\n", " soc.rfb_set_ro(ro_ch=iRo, att=30)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Hardware Configuration\n", "\n", "generator channel 6 : DAC 229 CH3 <-> Readout channel 0 : ADC 224 CH0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Things to know when writing programs\n", "\n", "### How to avoid timing problems\n", "Timed instructions are executed in two steps: first when the control core of the tProcessor pushes the instruction into the timed queue, and second when the instruction pops off the timed queue.\n", "* The control core executes all instructions in order and (except wait/waiti) as quickly as possible. If you have a non-timed instruction with external effects, it will generally execute before the timed instructions before and after it. Specifically, programs typically use memwi to update a data counter, and then read that counter to know how many data samples to get from the buffers - if the memwi happens before the readout is triggered or completed, you will read invalid data.\n", "* If the instruction is pushed later than the specified time, it will execute later than specified - this can lead to variations in the relative timing of pulses and readout windows. You are responsible for keeping the control core running ahead of the instruction times.\n", "\n", "Things you should do in your programs:\n", "* Your initialization should contain a synci instruction which gives the tProcessor time to get ahead of the clock.\n", "* Put a `sync_all()` somewhere in your loop body, probably at the end. This ensures that you don't have pulses or readouts that exceed the loop length.\n", "* Put a waiti instruction after the last readout in your loop body, to make sure the tProcessor doesn't prematurely update the data counter.\n", "* Follow the waiti with a sync that exceeds the waiti, to allow the tProcessor to get ahead of the clock.\n", "\n", "The last three points are automatically addressed if the last timed instruction in your loop body is a `measure()` instruction that specifies `wait=True` and a nonzero `syncdelay`.\n", "\n", "### How to ensure frequency matching\n", "DACs and ADCs have different frequency units, and the frequencies used in the two systems must be exactly equal. If they are not, there will be a small difference between the upconversion and downconversion frequencies - this will manifest as a sliding phase, and so you will not see a consistent phase between acquisitions.\n", "\n", "There are two ways to ensure frequency matching:\n", "* When converting a frequency to an integer value (often with `freq2reg()` or `declare_readout()`), specify not only the channel you are configuring, but the channel you want to be frequency-matched to.\n", "* Before doing any conversion, round the frequency to the closest frequency that is valid on both channels using `soccfg.adcfreq(f, gen_ch, ro_ch)`.\n", "\n", "Frequency-matching makes your frequency resolution worse, since the smallest possible frequency step is now the LCM of the two channels' frequency steps. Usually this doesn't matter - O(10 Hz) resolution is ample for most applications - but you can disable frequency-matching by specifying None as the other channel.\n", "\n", "You may have a DAC channel that does not itself drive any ADC channels, but needs to be phase-locked to a DAC channel that does. In this case you will want to frequency-match both DAC channels to that ADC, otherwise you will have a sliding phase between the two DAC channels.\n", "\n", "Since all DAC and ADC channels are the same in the standard QICK firmware, it's OK to just use ch 0 for the matched channel. But it's a good habit to do this consistently correctly, and that is the approach here.\n", "\n", "### Clocks and durations\n", "Time durations are generally specified in units of clock cycles. The relevant clocks are the tProcessor clock and the fabric clocks of the DACs and ADCs. In general these can all be different (and can even vary among DACs), though the standard ZCU111 firmware uses the same clock in all three places.\n", "\n", "For convenience, the `us2cycles()` and `cycles2us()` methods will convert between floating-point times and integer cycles. You should be careful to specify which clock you are using, and set the appropriate parameter in `us2cycles()`:\n", "* Pulse parameters (the `length` parameter to `set_pulse_registers()`, the `length` and `sigma` parameters to `add_gauss`) use the DAC clock and you should specify `gen_ch`.\n", "* Readout parameters (the `length` parameter to `declare_readout()`) use the ADC clock and you should specify `ro_ch`.\n", "* All other values will use the tProc clock. This includes sync and wait commands, and any sort of delay (`t`, `adc_trig_offset`). No special parameter needed.\n", "\n", "### How to play pulses\n", "There are three steps to playing a pulse:\n", "\n", "#### Loading a waveform\n", "(You skip this step for rectangular \"const\" pulses, which have no envelope.)\n", "\n", "Each signal generator has an internal waveform memory, which stores the I/Q data for the pulse envelope. Multiple waveforms can be stored in the same signal generator, and a single waveform can be used for different pulses (e.g. a Gaussian waveform can be used for Gaussian pulses and the ramp-up/ramp-down of flat-top pulses with different flat-top duration, each with its own gain and carrier frequency).\n", "\n", "`add_pulse(ch, name, idata, qdata)` writes an arbitrary waveform to the specified channel's waveform memory. \n", "`add_gauss(ch, name, length, sigma)`, `add_triangle(ch, name, length)`, and `add_DRAG(ch, name, length, sigma, delta, alpha)` write commonly-used standard pulse waveforms, with duration units of fabric clock cycles. The name is used in the next step.\n", "\n", "#### Setting registers\n", "There are a lot of parameters that need to be specified when playing a pulse - more than can be specified inline in a tProcessor instruction. So all the parameters must be written to registers first, and when we fire the pulse we just tell the tProcessor which registers to read.\n", "\n", "`set_pulse_registers()` writes the settings for a pulse to registers. All arguments to this method must be integers in the native units of the signal generator. This can happen immediately before you fire the pulse, but if a signal generator is only used for one type of pulse you will save time for the tProcessor by setting registers in initialization, before the program loop.\n", "\n", "If you want to modify pulse parameters on the fly (for example, you might want to sweep the frequency of the qubit drive pulse), you will set the registers in two steps (you can see an example in the demo 02_Sweeping_variables):\n", "* First, use set_pulse_registers() to write initial values for all parameters. You could do this in initialization, or right before the following step.\n", "* Second, overwrite the register(s) you want to update. You need to get the page and address of the register using ch_page(ch) and sreg(ch, name). Then you can use assembly instructions to change the value of that register.\n", "\n", "#### Firing the pulse\n", "`pulse(ch, t)` fires a pulse on the specified channel at the specified time, using whatever values are loaded in the registers.\n", "\n", "Often you will want to trigger the readout at the same time: `measure()` is a wrapper around `trigger()` and `pulse()`, and that's what is used in this demo." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "class LoopbackProgram(AveragerProgram):\n", " def initialize(self):\n", " cfg=self.cfg \n", " res_ch = cfg[\"res_ch\"]\n", "\n", " # set the nyquist zone\n", " self.declare_gen(ch=cfg[\"res_ch\"], nqz=1)\n", " \n", " # configure the readout lengths and downconversion frequencies (ensuring it is an available DAC frequency)\n", " for ch in cfg[\"ro_chs\"]:\n", " self.declare_readout(ch=ch, length=self.cfg[\"readout_length\"],\n", " freq=self.cfg[\"pulse_freq\"], gen_ch=cfg[\"res_ch\"])\n", "\n", " # convert frequency to DAC frequency (ensuring it is an available ADC frequency)\n", " freq = self.freq2reg(cfg[\"pulse_freq\"],gen_ch=res_ch, ro_ch=cfg[\"ro_chs\"][0])\n", " phase = self.deg2reg(cfg[\"res_phase\"], gen_ch=res_ch)\n", " gain = cfg[\"pulse_gain\"]\n", " self.default_pulse_registers(ch=res_ch, freq=freq, phase=phase, gain=gain)\n", "\n", " style=self.cfg[\"pulse_style\"]\n", "\n", " if style in [\"flat_top\",\"arb\"]:\n", " sigma = cfg[\"sigma\"]\n", " self.add_gauss(ch=res_ch, name=\"measure\", sigma=sigma, length=sigma*5)\n", " \n", " if style == \"const\":\n", " self.set_pulse_registers(ch=res_ch, style=style, length=cfg[\"length\"])\n", " elif style == \"flat_top\":\n", " # The first half of the waveform ramps up the pulse, the second half ramps down the pulse\n", " self.set_pulse_registers(ch=res_ch, style=style, waveform=\"measure\", length=cfg[\"length\"])\n", " elif style == \"arb\":\n", " self.set_pulse_registers(ch=res_ch, style=style, waveform=\"measure\")\n", " \n", " self.synci(200) # give processor some time to configure pulses\n", " \n", " def body(self):\n", " # fire the pulse\n", " # trigger all declared ADCs\n", " # pulse PMOD0_0 for a scope trigger\n", " # pause the tProc until readout is done\n", " # increment the time counter to give some time before the next measurement\n", " # (the syncdelay also lets the tProc get back ahead of the clock)\n", " self.measure(pulse_ch=self.cfg[\"res_ch\"], \n", " adcs=self.ro_chs,\n", " pins=[0], \n", " adc_trig_offset=self.cfg[\"adc_trig_offset\"],\n", " wait=True,\n", " syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n", " \n", " # equivalent to the following:\n", "# self.trigger(adcs=self.ro_chs,\n", "# pins=[0], \n", "# adc_trig_offset=self.cfg[\"adc_trig_offset\"])\n", "# self.pulse(ch=self.cfg[\"res_ch\"])\n", "# self.wait_all()\n", "# self.sync_all(self.us2cycles(self.cfg[\"relax_delay\"]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Send/receive a pulse with pulse_style = const " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5242490f466b4913ad56378c0bedddbe", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/100 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot results.\n", "plt.figure(1)\n", "for ii, iq in enumerate(iq_list):\n", " plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n", " plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n", " plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n", "plt.ylabel(\"a.u.\")\n", "plt.xlabel(\"Clock ticks\")\n", "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n", "plt.legend()\n", "plt.savefig(\"images/Send_recieve_pulse_const.pdf\", dpi=350)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Rep-to-rep consistency\n", "In this notebook we mostly use decimated readout (we acquire a full waveform, not just a single accumulated value). To avoid exhausting the waveform buffer, we usually run with reps=1 (the tProcessor program only fires+reads one pulse, and we run the program `soft_avgs` times).\n", "\n", "However, it's important to check that if you run a tProcessor loop with reps>1, the pulse looks the same in each iteration of the loop. So let's do a decimated readout with multiple reps; the 1024-sample buffer will allow for 10 reps of 100 samples each.\n", "\n", "Try changing the relax_delay to 0. You will see that the first rep appears in the same place, but the others are delayed by a bit because the tProcessor didn't have enough time between waiting for the measurement in one rep and firing the pulse in the next rep." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8a28f1abc91049579e0b61726a9dc3b0", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/100 [00:00" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "config={\"res_ch\":5, # --Fixed\n", " \"ro_chs\":[1], # --Fixed\n", " \"reps\":10, # --Fixed\n", " \"relax_delay\":1.0, # --us\n", " \"res_phase\":0, # --degrees\n", " \"pulse_style\": \"const\", # --Fixed\n", " \n", " \"length\":20, # [Clock ticks]\n", " # Try varying length from 10-100 clock ticks\n", " \n", " \"readout_length\":100, # [Clock ticks]\n", " # Try varying readout_length from 50-1000 clock ticks\n", "\n", " \"pulse_gain\":10000, # [DAC units]\n", " # Try varying pulse_gain from 500 to 30000 DAC units\n", "\n", " \"pulse_freq\": 1000, # [MHz]\n", " # In this program the signal is up and downconverted digitally so you won't see any frequency\n", " # components in the I/Q traces below. But since the signal gain depends on frequency, \n", " # if you lower pulse_freq you will see an increased gain.\n", "\n", " \"adc_trig_offset\": 100, # [Clock ticks]\n", " # Try varying adc_trig_offset from 100 to 220 clock ticks\n", "\n", " \"soft_avgs\":100\n", " # Try varying soft_avgs from 1 to 200 averages\n", "\n", " }\n", "\n", "###################\n", "# Try it yourself !\n", "###################\n", "\n", "prog =LoopbackProgram(soccfg, config)\n", "iq_list = prog.acquire_decimated(soc, load_pulses=True, progress=True, debug=False)\n", "\n", "plt.figure(1)\n", "for ii, iq in enumerate(iq_list[0]):\n", "# plt.plot(iq[0], label=\"I value, rep %d\"%(ii))\n", "# plt.plot(iq[1], label=\"Q value, rep %d\"%(ii))\n", " plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, rep %d\"%(ii))\n", "plt.ylabel(\"a.u.\")\n", "plt.xlabel(\"Clock ticks\")\n", "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n", "plt.legend()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Send/receive a pulse with pulse_style = flat_top " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "730cc1de0ee54e518a5750224ca6bb97", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/100 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot results.\n", "plt.figure(1)\n", "for ii, iq in enumerate(iq_list):\n", " plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n", " plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n", " plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n", "plt.ylabel(\"a.u.\")\n", "plt.xlabel(\"Clock ticks\")\n", "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n", "plt.legend()\n", "plt.savefig(\"images/Send_recieve_pulse_flattop.pdf\", dpi=350)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Send/receive a pulse with pulse_style = arb " ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "e271dac0623c44e0b8667d3314fd6fab", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/100 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot results.\n", "plt.figure(1)\n", "for ii, iq in enumerate(iq_list):\n", " plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n", " plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n", " plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n", "plt.ylabel(\"a.u.\")\n", "plt.xlabel(\"Clock ticks\")\n", "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n", "plt.legend()\n", "plt.savefig(\"images/Send_recieve_pulse_arb.pdf\", dpi=350)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Compare the two main ways of acquiring data: prog.acquire_decimated and prog.acquire\n", "\n", "In the previous two demonstrations we used prog.acquire_decimated which uses the QICK decimated buffer (acquiring a whole time trace of data for every measurement shot. The QICK accumulated buffer is used in prog.acquire, which acquires a single I/Q data point per measurement shot- the average of the I/Q values in the decimated buffer. In qubit experiments we will be mainly using prog.acquire since for every shot we only need one I/Q value to assess the state of the qubit. So let's verify that prog.acquire_decimated and prog.acquire produce similar results (to within +/- 1 DAC units)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "77be34d70b994cfcbe33f25b7379616c", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/100 [00:00