{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "#
Sending and receiving a pulse demonstration\n", "\n", "###
In this demo you will send and receive a pulse in loopback to demonstrate control over the QICK. \n", "\n", "By modifying the config Python dictionary in the below notebook cell, you can change several variables:\n", "* The pulse length length in FPGA clock ticks (1 clock tick = 2.6 ns).\n", "* The readout buffer length readout_length in FPGA clock ticks.\n", "* The pulse envelope shape pulse_style (either const or flat_top or arb )\n", "* The pulse amplitude pulse_gain in DAC units.\n", "* The pulse frequency pulse_freq in MHz.\n", "* The readout \"time of flight\" adc_trig_offset in FPGA clock ticks.\n", "* The number of times you average the read soft_avgs " ] }, { "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", "import time\n", "from tqdm.notebook import tqdm\n", "%pylab inline" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": false }, "outputs": [], "source": [ "# Load bitstream with custom overlay\n", "# soc = QickSoc()\n", "# soc = QickSoc(bitfile=\"q3diamond.bit\", force_init_clks=True)\n", "soc = QickSoc(bitfile=\"qick_111_rfbv1_mux.bit\")\n", "# soc = QickSoc(bitfile=\"../../qick-amo/pynq/qick-amo.bit\")\n", "\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)\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\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_v6 - 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_v6 - 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_v6 - 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_v6 - 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_v6 - 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_v6 - 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_sg_mux4_v2 - tProc output 7, switch ch -1, maxlen 0\n", "\t\tDAC tile 1, ch 3, 32-bit DDS, fabric=384.000 MHz, fs=1536.000 MHz\n", "\n", "\t4 readout channels:\n", "\t0:\tADC tile 0, ch 0, 35-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 16384 (avg) 1024 (decimated), trigger bit 12, tProc input 0\n", "\t1:\tADC tile 0, ch 0, 35-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 16384 (avg) 1024 (decimated), trigger bit 13, tProc input 1\n", "\t2:\tADC tile 0, ch 0, 35-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 16384 (avg) 1024 (decimated), trigger bit 14, tProc input 2\n", "\t3:\tADC tile 0, ch 0, 35-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 16384 (avg) 1024 (decimated), trigger bit 15, tProc input 3\n", "\n", "\t7 DACs:\n", "\t\tDAC tile 0, ch 0 is DAC228_T0_CH0 or RF board output 0\n", "\t\tDAC tile 0, ch 1 is DAC228_T0_CH1 or RF board output 1\n", "\t\tDAC tile 0, ch 2 is DAC228_T0_CH2 or RF board output 2\n", "\t\tDAC tile 1, ch 0 is DAC229_T1_CH0 or RF board output 4\n", "\t\tDAC tile 1, ch 1 is DAC229_T1_CH1 or RF board output 5\n", "\t\tDAC tile 1, ch 2 is DAC229_T1_CH2 or RF board output 6\n", "\t\tDAC tile 1, ch 3 is DAC229_T1_CH3 or RF board output 7\n", "\n", "\t1 ADCs:\n", "\t\tADC tile 0, ch 0 is ADC224_T0_CH0 or RF board AC input 0\n", "\n", "\t8 digital output pins (tProc output 0):\n", "\t0:\tPMOD0_0_LS\n", "\t1:\tPMOD0_1_LS\n", "\t2:\tPMOD0_2_LS\n", "\t3:\tPMOD0_3_LS\n", "\t4:\tPMOD0_4_LS\n", "\t5:\tPMOD0_5_LS\n", "\t6:\tPMOD0_6_LS\n", "\t7:\tPMOD0_7_LS\n", "\n", "\ttProc: 8192 words program memory, 4096 words data memory\n", "\t\texternal start pin: PMOD1_0_LS\n" ] } ], "source": [ "print(soccfg)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a9a68d88d939409a9e61575900f2f028", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/100 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "class LoopbackProgram(AveragerProgram):\n", " def initialize(self):\n", " cfg = self.cfg\n", " self.declare_gen(ch=cfg[\"res_ch\"], nqz=cfg['nqz'],\n", " mixer_freq=cfg[\"mixer_freq\"],\n", " mux_freqs=cfg[\"pulse_freqs\"],\n", " mux_gains=cfg[\"pulse_gains\"],\n", " ro_ch=cfg[\"ro_chs\"][0])\n", " for iCh, ch in enumerate(cfg[\"ro_chs\"]): # configure the readout lengths and downconversion frequencies\n", " self.declare_readout(ch=ch, freq=cfg[\"pulse_freqs\"][iCh],\n", " length=soccfg.us2cycles(cfg['length']+cfg['readout_padding'], ro_ch=ch),\n", " gen_ch=cfg[\"res_ch\"])\n", "\n", " self.set_pulse_registers(ch=cfg[\"res_ch\"], style=\"const\",\n", " length=soccfg.us2cycles(cfg['length'], gen_ch=cfg['res_ch']),\n", " mask=[0, 1, 2, 3])\n", " self.synci(200) # give processor some time to configure pulses\n", "\n", " def body(self):\n", " self.measure(pulse_ch=self.cfg[\"res_ch\"], \n", " adcs=self.ro_chs,\n", " pins=[0], \n", " adc_trig_offset=soccfg.us2cycles(self.cfg[\"adc_trig_offset\"]),\n", " wait=True,\n", " syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n", "\n", "config = {\n", " 'res_ch': 6,\n", " 'ro_chs': [0,1,2,3],\n", " 'nqz': 1,\n", " 'mixer_freq': 1700,\n", " 'pulse_freqs': [-200, 0, 200, 400],\n", " 'pulse_gains': [1.0, 1.0, 1.0, 1.0],\n", " 'pulse_style': 'const',\n", " 'adc_trig_offset': 0.2,\n", " 'length': 2,\n", " 'readout_padding': 0.2,\n", " 'relax_delay': 1,\n", " 'reps': 1,\n", " 'soft_avgs': 100\n", "}\n", "prog = LoopbackProgram(soccfg, config)\n", "# print(prog)\n", "# prog.acquire(soc, load_pulses=True, progress=True, debug=False)\n", "\n", "\n", "prog = LoopbackProgram(soccfg, config)\n", "\n", "iq_list = prog.acquire_decimated(soc, load_pulses=True, progress=True, debug=False)\n", "# Plot results.\n", "fig, axs = plt.subplots(4,1,figsize=(10,10))\n", "\n", "for ii, iq in enumerate(iq_list):\n", " plot = axs[ii]\n", " plot.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n", " plot.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n", " plot.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n", " plot.set_ylabel(\"a.u.\")\n", " plot.set_xlabel(\"Clock ticks\")\n", " plot.set_title(\"Averages = \" + str(config[\"soft_avgs\"]))\n", " plot.legend()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bc1bb29ea7f94542beae8ca1ba68a47d", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/96 [00:00]" ] }, "execution_count": 14, "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['length'] = 100\n", "config['pulse_freqs'] = [0, 0, 0, 0]\n", "config['pulse_gains'] = [1.0, 0.0, 0.0, 0.0]\n", "config['ro_chs'] = [0]\n", "config['reps'] = 100\n", "\n", "mixer_freqs = np.arange(100, 2001, 20)\n", "\n", "mags = np.zeros((len(mixer_freqs),2))\n", "\n", "for i, f in tqdm(list(enumerate(mixer_freqs))):\n", " config['mixer_freq'] = f\n", " \n", " for j in range(2):\n", " config['nqz'] = j+1\n", " prog = LoopbackProgram(soccfg, config)\n", " res = prog.acquire(soc, load_pulses=True, progress=False, debug=False)\n", " res = np.array(res).T[0]\n", " mags[i,j] = np.abs(res[:,0]+1j*res[:,1])\n", "plt.semilogy(mixer_freqs, mags[:,0])\n", "plt.semilogy(mixer_freqs, mags[:,1])" ] } ], "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.8.2" } }, "nbformat": 4, "nbformat_minor": 2 }