qick_demos/04_Reading_Math_Writing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> Reading, math and writing demonstration\n",
    "\n",
    "### <center> In this demo you will use the tProc to do some math and/or bitwise operations on two variables that you will pass in through the <code> config </code> dictionary and take out with <code> single_read </code>."
   ]
  },
  {
   "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",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load bitstream with custom overlay\n",
    "soc = QickSoc()\n",
    "soccfg = soc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hardware Configuration\n",
    "\n",
    "tProc channel 7   : DAC 229 CH3  <-> Readout channel 0 : ADC 224 CH0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LoopbackProgram(AveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg=self.cfg   \n",
    "\n",
    "        # Move value of A into tProc register\n",
    "        self.regwi(0,1,self.cfg[\"A\"])\n",
    "\n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "    \n",
    "    def body(self):\n",
    "        # Do math: add value of B to the register value\n",
    "        self.mathi(0, 1, 1, '+', self.cfg[\"B\"])\n",
    "        \n",
    "        # Write the result to address 123\n",
    "        self.memwi(0,1,123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here we will add the value of  <code> A </code> to the value of <code> B </code> using the tProc. We write the result to tProc memory address 123, and then read out that address value at the end of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result =  50\n"
     ]
    }
   ],
   "source": [
    "config={\"reps\": 1, # fixed\n",
    "        \"A\": 100,\n",
    "        \"B\": -50\n",
    "       }\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "\n",
    "# Load the program into the tProc.\n",
    "prog.config_all(soc)\n",
    "# Start tProc.\n",
    "soc.start_tproc()\n",
    "time.sleep(0.1)\n",
    "result = soc.tproc.single_read(addr=123)\n",
    "print(\"Result = \", result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Here we show how similar register operations can also be done using the QickRegister object. \n",
    "\n",
    "The QickRegister object keeps the register page, address, gen_ch/ro_ch, and reg_type information, so unit conversions like freq2reg/us2cycle/deg2reg can be automatically used when we assign values to registers. This makes qick programs easier to write and read especially when a lot of operations on registers that correspond to physical values are involved. \n",
    "\n",
    "In the program below, we assign values to the frequency register of a generator, all the assignments are done directly using frequency values in MHz, and no explicit reference to the low level register value/page/address is needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qick.asm_v1 import QickRegister, QickRegisterManagerMixin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestRegProgram(QickRegisterManagerMixin, AveragerProgram):  # inhered the QickRegisterManagerMixin class\n",
    "    def initialize(self):\n",
    "        cfg = self.cfg\n",
    "        self.declare_gen(ch=cfg[\"gen_ch\"], nqz=1, ro_ch=cfg[\"ro_ch\"])  # this \"ro_ch\" will be automatically used for freq2reg operations later\n",
    "\n",
    "        # get the frequency register associated with gen_ch\n",
    "        self.gen_freq_reg = self.get_gen_reg(cfg[\"gen_ch\"], \"freq\")\n",
    "\n",
    "        # declare another frequency type register on the same generator page, initialize it to the integer that corresponds to frequency \"f1\" in MHz\n",
    "        # the \"gen_ch\" and \"ro_ch\" of cfg[\"gen_ch\"] will be automatically used when converting a physical frequency value to integers of this register\n",
    "        self.gen_freq_reg_temp = self.new_gen_reg(cfg[\"gen_ch\"], name=\"freq_temp\", init_val=cfg[\"f1\"], reg_type=\"freq\")\n",
    "\n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "\n",
    "    def body(self):\n",
    "        cfg = self.cfg\n",
    "\n",
    "        # set the register value to the integer that corresponds to frequency \"f0\" in MHz\n",
    "        self.gen_freq_reg.set_to(cfg[\"f0\"])\n",
    "        # Write the result to address 123\n",
    "        self.memwi(self.gen_freq_reg.page, self.gen_freq_reg.addr, 123)\n",
    "\n",
    "        # assign the value of register \"gen_freq_reg_temp\" to register \"gen_freq_reg\", which should corresponds to \"f1\"\n",
    "        self.gen_freq_reg.set_to(self.gen_freq_reg_temp)\n",
    "        # Write the result to address 124\n",
    "        self.memwi(self.gen_freq_reg.page, self.gen_freq_reg.addr, 124)\n",
    "\n",
    "        # add 300 MHz to the frequency kept in \"gen_freq_reg_temp\" and assign it to \"gen_freq_reg\"\n",
    "        self.gen_freq_reg.set_to(self.gen_freq_reg_temp, \"+\", 300)\n",
    "        # Write the result to address 125\n",
    "        self.memwi(self.gen_freq_reg.page, self.gen_freq_reg.addr, 125)\n",
    "\n",
    "        # sum the frequencies kept in \"gen_freq_reg_temp\" and \"gen_freq_reg\" and assign it to \"gen_freq_reg\"\n",
    "        self.gen_freq_reg.set_to(self.gen_freq_reg, \"+\", self.gen_freq_reg_temp)\n",
    "        # Write the result to address 126\n",
    "        self.memwi(self.gen_freq_reg.page, self.gen_freq_reg.addr, 126)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "// Program\n",
      "\n",
      "        regwi 0, $1, 312076190;                 //'freq_temp' <= 312076190 (500 MHz)\n",
      "        synci 200;\n",
      "        regwi 0, $15, 0;\n",
      "        regwi 0, $14, 0;\n",
      "LOOP_J: regwi 0, $22, 624152380;                //'gen0_freq' <= 624152380 (1000 MHz)\n",
      "        memwi 0, $22, 123;\n",
      "        mathi 0, $22, $1 + 0;                   // 'gen0_freq' <= 'freq_temp' + 0 (0 MHz)\n",
      "        memwi 0, $22, 124;\n",
      "        mathi 0, $22, $1 + 187245715;           // 'gen0_freq' <= 'freq_temp' + 187245715 (300 MHz)\n",
      "        memwi 0, $22, 125;\n",
      "        math 0, $22, $22 + $1;                  // 'gen0_freq' <= 'gen0_freq' + 'freq_temp'\n",
      "        memwi 0, $22, 126;\n",
      "        mathi 0, $15, $15 + 1;\n",
      "        memwi 0, $15, 1;\n",
      "        loopnz 0, $14, @LOOP_J;\n",
      "        end ;\n",
      "Result= 624152380 , expected: 624152380\n",
      "Result= 312076190 , expected: 312076190\n",
      "Result= 499321905 , expected: 499321905\n",
      "Result= 811398095 , expected: 811398095\n"
     ]
    }
   ],
   "source": [
    "config={\n",
    "        \"gen_ch\": 0,\n",
    "        \"ro_ch\": 0,\n",
    "        \"reps\": 1, # fixed\n",
    "        \"f0\": 1000, #MHz\n",
    "        \"f1\": 500 #MHz\n",
    "       }\n",
    "\n",
    "prog =TestRegProgram(soccfg, config)\n",
    "\n",
    "\n",
    "# Load the program into the tProc.\n",
    "prog.config_all(soc)\n",
    "# Start tProc.\n",
    "soc.start_tproc()\n",
    "\n",
    "print(prog)\n",
    "\n",
    "time.sleep(0.1)\n",
    "\n",
    "\n",
    "# compare the result with what we should get using freq2reg functions\n",
    "result = soc.tproc.single_read(addr=123)\n",
    "print(f\"Result=\", result, \", expected:\", prog.freq2reg(config[\"f0\"], config[\"gen_ch\"], config[\"ro_ch\"]))\n",
    "\n",
    "result = soc.tproc.single_read(addr=124)\n",
    "print(f\"Result=\", result, \", expected:\",prog.freq2reg(config[\"f1\"], config[\"gen_ch\"], config[\"ro_ch\"]))\n",
    "\n",
    "result = soc.tproc.single_read(addr=125)\n",
    "print(f\"Result=\", result, \", expected:\",prog.freq2reg(config[\"f1\"]+300, config[\"gen_ch\"], config[\"ro_ch\"]))\n",
    "\n",
    "result = soc.tproc.single_read(addr=126)\n",
    "print(f\"Result=\", result, \", expected:\",prog.freq2reg(config[\"f1\"]+300+config[\"f1\"], config[\"gen_ch\"], config[\"ro_ch\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  },
  "vscode": {
   "interpreter": {
    "hash": "618feb7b2b0a35f7e820dec88779cac1ef83ad948f0212540d069fdb92cbb234"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}