Lab5_State_Machines.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/byuccl/digital_design_colab/blob/dev/Lab5_State_Machines.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6kxaCkmhoWGz"
      },
      "source": [
        " <p align=\"right\">\n",
        "<img src=\"https://raw.githubusercontent.com/byuccl/digital_design_colab/main/Dataflow/media/BYU.svg\"\n",
        "width=\"500\" height=\"\" style=\"display: block; margin: 0 auto\" />\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7pJcTTDsoc_a"
      },
      "source": [
        "\n",
        "<h1>\n",
        "<summary>\n",
        "<h1 align=\"center\">\n",
        "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;\n",
        "<b>$\\color{midnightBlue}{\\underline{\\textbf{State Machines}}}$<bol><p align=\"right\">\n",
        "</summary>\n",
        "</h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z2TXhJuUF0CW"
      },
      "source": [
        "## **Setup**\n",
        "Click the Play Button. No need to expand. Do not touch this. \n",
        "<details><summary>Packages to be downloaded</summary>\n",
        "Things it needs to install:  <br>\n",
        "\n",
        " *    Verilator- the simulator  <br>\n",
        " *    PyGithub - Helps with simulation    <br>\n",
        " *    VCD - Generates waveforms from `.vcd` files  <br>\n",
        " *    Widgets - Each widget must first be generated then will be loaded when played\n",
        "</details>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AAQYti20F-u_",
        "outputId": "04b856cc-d0e5-420d-ed54-4b932ec35f84"
      },
      "outputs": [],
      "source": [
        "#@title Install VCD { form-width: \"1795px\" }\n",
        "%%bash\n",
        "git clone https://github.com/yne/vcd.git\n",
        "make -C /content/vcd\n",
        "cd /content/vcd\n",
        "make install"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Oqk7oLdHMm_R",
        "outputId": "d3dd625c-0577-4bc1-862f-8e421a39f973"
      },
      "outputs": [],
      "source": [
        "#@title Import Files from Repo\n",
        "import ipywidgets as widgets\n",
        "from ipywidgets import GridspecLayout\n",
        "from ipywidgets import AppLayout, Button, Layout, jslink, IntText, IntSlider\n",
        "import requests\n",
        "def import_text(text):\n",
        "  url = 'https://raw.githubusercontent.com/byuccl/digital_design_colab/main/State_Machine/files/%s' % text\n",
        "  resp = requests.get(url)\n",
        "  with open(text, 'wb') as f:\n",
        "    f.write(resp.content)\n",
        "def import_text_bin(text):\n",
        "  url = 'https://raw.githubusercontent.com/byuccl/digital_design_colab/main/bin/%s' % text\n",
        "  resp = requests.get(url)\n",
        "  with open(text, 'wb') as f:\n",
        "    f.write(resp.content)\n",
        "# import_text(\"tb_dataflow_sv.cpp\")\n",
        "# import_text(\"dataflow_sv3.cpp\")\n",
        "# import_text(\"tb_func2.cpp\")\n",
        "import_text_bin(\"quiz_dict01.py\")\n",
        "import_text_bin(\"tt_widget.py\")\n",
        "\n",
        "import tt_widget as tt\n",
        "# import quiz_dict01 as quiz_bot \n",
        "# from frquestion import *\n",
        "def quiz_func(a):\n",
        "  quiz_bot.quiz_func(a)\n",
        "\n",
        "!git clone https://github.com/byuccl/digital_design_colab.git"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "tp0SZ76qM_fl"
      },
      "outputs": [],
      "source": [
        "#@title Anon Simulation Widget { form-width: \"50px\" }\n",
        "import os\n",
        "import re\n",
        "import sys\n",
        "import subprocess\n",
        "from collections import defaultdict, namedtuple\n",
        "import subprocess\n",
        "import ipywidgets as widgets\n",
        "from ipywidgets import GridspecLayout\n",
        "from ipywidgets import AppLayout, Button, Layout, jslink, IntText, IntSlider\n",
        "!mkdir -p /content/tmp_code\n",
        "def vcd():\n",
        "  !vcd < /content/tmp_code/logs/vlt_dump.vcd > /content/vcd.txt\n",
        "  !sed -i '1,10d'  /content/vcd.txt \n",
        "  !cat /content/vcd.txt\n",
        "\n",
        "\n",
        "VerilogIO = namedtuple(\"VerilogIO\", \"dir nam wid\")\n",
        "'''\n",
        "        Using a namedtuple (sort of like a C-struct) to hold info on each Verilog IO.\n",
        "        This is very similar to using a class with only data members.\n",
        "          The advantages are: (1) the fields are not change-able after creation\n",
        "          (which is what I want), and (2) probably more efficient than using a class.\n",
        "        This is used by both generate() and processVmoduleHFile() so it is declared in global scope.\n",
        "'''\n",
        "\n",
        "\n",
        "def getModuleName(textSourceCode):\n",
        "  match_name = re.search(r\"module\\s{1,}\\w{1,}\\s{0,}#{0,}\\s{0,}\\(\",textSourceCode.value)\n",
        "  if match_name is None:\n",
        "      return None\n",
        "  mname = match_name.group().split(' ')[1]\n",
        "  mname = mname.split('(')[0]\n",
        "  mname = mname.split('#')[0]\n",
        "  return mname\n",
        "\n",
        "def writeJson(d, fname='/tmp/json.json', ind=2):\n",
        "    ''' Write an object to a file with indenting '''\n",
        "    import json\n",
        "    with open(fname, encoding='utf-8', mode='w') as f:\n",
        "        json.dump(d, f, indent=ind)\n",
        "\n",
        "def cd(folder):\n",
        "    ''' My wrapper for os.chdir() so I can print it desired. '''\n",
        "    if folder:\n",
        "        os.chdir(folder)\n",
        "    #print(\"##### Changing to \" + os.getcwd() + \"#####\")\n",
        "\n",
        "def getNextLine(f):\n",
        "    ''' Read file f until you get a non-comment and a non-blank link.\n",
        "        The returned line will be stripped of whitespace (including newline)\n",
        "    '''\n",
        "    while True:\n",
        "        myLine = f.readline().strip()\n",
        "        if not myLine.startswith('//') and len(myLine) > 0:\n",
        "            break\n",
        "    return myLine\n",
        "\n",
        "def processSTMHeader(tBench):\n",
        "    '''\n",
        "        Read STM file and pull out the clock definition and the list of inputs.\n",
        "        Note that for combinational circuits we are expecting a clock line\n",
        "          consisting of 'comb' (which is ignored)\n",
        "    '''\n",
        "    with open(tBench, encoding='utf-8', mode='r') as f:\n",
        "        stmClock = None\n",
        "        tmp = getNextLine(f)\n",
        "        if tmp != 'comb':\n",
        "            stmClock = tmp\n",
        "        inputs = getNextLine(f).split()\n",
        "\n",
        "    # Verify that a signal doesn't appear twice in the list (this is a user-created file after all)\n",
        "    for elmt in inputs:\n",
        "        assert inputs.count(elmt) == 1, \"Cannot have duplicate names in STM file input list. ({} appears more than once)\".format(elmt)\n",
        "    return (stmClock, inputs)\n",
        "\n",
        "def processVmoduleHFile(fname, stmClock, stmInputs):\n",
        "    '''\n",
        "        Process the verilator-produced Vmodule.h file and pull out\n",
        "        the IO definitions.  Pack them into the verilogIOs structure,\n",
        "        which is a list of lists consisting of [dir, name, size].\n",
        "        Along the way see if you can match any of the signals as\n",
        "        corresponding to the clock defined in the stimulus file.\n",
        "        Finally, make sure that all verilog signals are in the stm file\n",
        "          and the other way around.\n",
        "    '''\n",
        "\n",
        "    verilogIOs = []\n",
        "    with open(fname, encoding='utf-8', mode='r') as f:\n",
        "        verilogClock = None\n",
        "        for line in f:\n",
        "            line = line.strip()\n",
        "            if line.startswith('// LOCAL VARIABLES'): # Can skip everything after this line\n",
        "                break\n",
        "            match = re.match(r'^VL_(IN|OUT|SIG)(\\d*)\\(([^,]*),(\\d+),(\\d+)', line)\n",
        "            if match is not None:\n",
        "                varDir, varName, varSize = [match.groups()[0], match.groups()[2], int(match.groups()[3]) - int(match.groups()[4]) +1]\n",
        "                verilogIOs.append(VerilogIO(varDir, varName, varSize))\n",
        "                # If input, check that it is in STM file\n",
        "                if varName == stmClock:\n",
        "                    verilogClock = varName   # Found matching clock names between STM and Verilog header\n",
        "\n",
        "    # Check to make sure that every stm input is in the verilog file\n",
        "    #   and the other way around.\n",
        "    for si in stmInputs:\n",
        "        assert si in [f.nam for f in verilogIOs if f.dir=='IN'], \\\n",
        "            \"ERROR: input '{}' in STM file but not in Verilog design\".format(si)\n",
        "    for vi in [f.nam for f in verilogIOs if f.dir=='IN']:\n",
        "        assert vi == stmClock or vi in stmInputs, \\\n",
        "            \"ERROR: input '{}' in Verilog design but not in STM file\".format(vi)\n",
        "\n",
        "    # Make sure that if a clock was in the STM file, it was found in the Verilog\n",
        "    if stmClock != None:\n",
        "        assert verilogClock != None, \"There was a clock defined in the STM file but no corresponding clock in the Verilog file.\"\n",
        "    return (verilogClock, verilogIOs)\n",
        "from string import Template\n",
        "def generate(designFolder, verilogFile, tBenchFile,\n",
        "             draw = True, wall = True, compress = True, Hex = True, verbose = False,\n",
        "             pythonPath = '', processClockWaveform = True,\n",
        "             hscale = 1, nameOrder = ''):\n",
        "    \"\"\"\n",
        "    Generate a C++ object of verilog/systemverilog code using verilator, toggle inputs on said C++ object,\n",
        "    and portray resulting waveforms of the signals. Comments in the stm file are supported and are indicated with //\n",
        "    Comments must start at the beginning of the line and are expected to take up the whole line\n",
        "    Keyword Arguements:\n",
        "    designFolder -- str - relative path of the directory, where the .v and .stm files are\n",
        "    verilogFile -- str - the top level HDL module\n",
        "    tBenchFile -- str - the name of a .stm file of input stimulus.\n",
        "    draw -- bool - whether or not to display the waveform\n",
        "    wall -- bool whether or not to check for verilator warnings\n",
        "    compress -- bool whether or not to compress the c++ object made by verilator. (Compression effectively\n",
        "      eliminates the ability to view most internal signals  (deprecated)\n",
        "    Hex -- bool - whether to display waveform values in hexadecimal\n",
        "    verbose -- bool - control verbose mode\n",
        "    pythonPath -- str - path to directory where MaverickSimulator project can be found. If left empty, the typical\n",
        "                        PYTHONPATH/site-packages will be assumed\n",
        "    processClockWaveform -- bool -  By default, will attempt to convert the clock waveform to one with arrows.\n",
        "                                    Setting this to False will prevent this\n",
        "    hscale -- int - Will adjust the width of the ticks on the waveform diagram. This arguement is passed directly\n",
        "                    to executeSimulation()\n",
        "    \"\"\"\n",
        "    clock = None    # The name of the clock to the design (if any)\n",
        "    homeDir = os.getcwd()\n",
        "    try:\n",
        "        fileNameRoot = os.path.splitext(verilogFile)[0]\n",
        "        if not pythonPath:\n",
        "            dirs = sys.path\n",
        "            for dir in dirs:\n",
        "                if (dir.find('site-packages') != -1 ):\n",
        "                    #TODO add check to make sure path is valid\n",
        "                    pythonPath = dir + '/MaverickSimulator/src'\n",
        "                    break\n",
        "        # Adjust commandline args for verilator\n",
        "        w = ' -Wall' if wall else ' '\n",
        "        c = ' ' if compress else ' --public '\n",
        "        wv = ' --trace ' if draw else '--trace'\n",
        "\n",
        "        cd(designFolder)\n",
        "\n",
        "        # Step 1: run the verilator program\n",
        "        v = subprocess.Popen(r'verilator -cc'+ w + c + wv + verilogFile + \" -CFLAGS '-std=c++11' --exe sim___.cpp\",    #create verilator object and link to .cpp\n",
        "                             stdout = subprocess.PIPE, stderr = subprocess.STDOUT, shell = True, universal_newlines=True)\n",
        "        verbose = 0\n",
        "        if verbose:\n",
        "            print('Running verilator...')\n",
        "            print('verilator -cc'+ w + c + wv + verilogFile + \" -CFLAGS '-std=c++11' --exe sim___.cpp\")\n",
        "            output = v.stdout.read().strip()\n",
        "            if len(output) > 0:\n",
        "                print('Results of running verilator: ' + output)\n",
        "            if output.find('%Error: Command Failed') != -1:\n",
        "                return 1\n",
        "                sys.exit(\"Exiting due to verilator errors\")\n",
        "        else:\n",
        "            output = v.stdout.read().strip()\n",
        "            if output.find('%Error: Command Failed') != -1:\n",
        "                print(output)\n",
        "                os.chdir(homeDir)\n",
        "                return 1\n",
        "                sys.exit(\"Exiting due to verilator errors\")\n",
        "\n",
        "        # Step 2: Parse STM and Verilog files\n",
        "        # Open .stm file and get clock and list of inputs from the  first two uncommented lines\n",
        "        stmClock, stmInputs = processSTMHeader(tBenchFile)\n",
        "\n",
        "        # Read the IO definitions from the Vmodule.h file\n",
        "        # Add inputs, outputs, and local signals to data structure verilogIOs\n",
        "        verilogClock, verilogIOs = processVmoduleHFile('obj_dir/V'+fileNameRoot+'.h', stmClock, stmInputs)\n",
        "\n",
        "        # If verilogClock has been set that means\n",
        "        # it matched up with the one from the STM file. Otherwise, it did not.\n",
        "        # The rest of the code will use clock to know this.\n",
        "        if verilogClock != None:\n",
        "            clock = verilogClock\n",
        "\n",
        "        # Step 3:Write the Testbench__lh file\n",
        "        ios = ''\n",
        "        sg = ''\n",
        "        # Build list of IO print stmts for printIOs()\n",
        "        for nam, wid in [(f.nam, f.wid) for f in verilogIOs if f.dir!='SIG']:\n",
        "            print(str(nam) + str(wid))\n",
        "            ios += '    std::cout << \" {0} is \" << std::bitset<{1}>(top->{0}) <<  std::endl;\\n'.format(nam, wid)\n",
        "        print(ios)\n",
        "        # If needed, build list of IO print stmts for printInternalOs()\n",
        "        if not compress:\n",
        "            for nam, wid in [(f.nam, f.wid) for f in verilogIOs if f.dir=='SIG']:\n",
        "                varName = nam.replace('v__DOT__', '').replace('__DOT__', ' ')\n",
        "                sg += '   std::cout << \"{} is \" << std::bitset<{}>(top->{}) << std::endl;\\n'.format(varName, wid, nam)\n",
        "        # Now actually write the testBench file into the design directory\n",
        "        with open('TestBench___.h', encoding='utf-8', mode='w') as tb: #header file for interacting with verilator object\n",
        "            with open(\"/content/tmp_code/TBtemplate.txt\", 'r') as tbTemplate:\n",
        "                t = Template(tbTemplate.read())\n",
        "                t = t.substitute(\n",
        "                    MODULE=fileNameRoot,\n",
        "                    CLKDEF = '\\n#define CLK top->'+clock if clock else '',\n",
        "                    IOPRINTS = ios,\n",
        "                    INTERNALIOPRINTS = sg\n",
        "                    )\n",
        "                tb.write(t)\n",
        "\n",
        "        # Step 4: write the main simulation file\n",
        "        # Collect IO print code snippets (using simTemplate2.txt as pattern)\n",
        "        ios = ''\n",
        "        for inputName in stmInputs:\n",
        "            for inputWidth in [f.wid for f in verilogIOs if f.nam==inputName]:\n",
        "                with open(\"/content/tmp_code/simTemplate2.txt\", 'r') as simTemplate2:\n",
        "                    t = Template(simTemplate2.read())\n",
        "                    t = t.substitute(SIGNAME = inputName, SIGWIDTH = inputWidth)\n",
        "                    ios += t\n",
        "\n",
        "        # Now write the main simulation file for compilation (using simTemplate.txt as pattern)\n",
        "        with open('sim___.cpp', encoding='utf-8', mode='w') as sim:\n",
        "            with open(\"/content/tmp_code/simTemplate.txt\",\n",
        "                    encoding='utf-8', mode='r') as simTemplate:  #now write main.cpp file\n",
        "                t = Template(simTemplate.read())\n",
        "                t = t.substitute(\n",
        "                            NUMINS = len(stmInputs),\n",
        "                            READINPUTSCODE = ios,\n",
        "                            HASCLOCK = (0 if clock is None else 1)\n",
        "                            )\n",
        "                sim.write(t)\n",
        "\n",
        "        # Step 5: Compile the resulting program\n",
        "        print(\"Compiling\")\n",
        "        if verbose:\n",
        "            print('make -C obj_dir -j -f V'+fileNameRoot+'.mk V'+fileNameRoot+'; cd obj_dir')\n",
        "            v = subprocess.Popen(r'make -C obj_dir -j -f V'+fileNameRoot+'.mk V'+fileNameRoot+'; cd obj_dir',\n",
        "                                 stdout = subprocess.PIPE, stderr = subprocess.STDOUT, shell = True, universal_newlines=True)\n",
        "            output = v.stdout.read().strip()\n",
        "            if len(output) > 0:  print('   Results of compiling: ' + output)\n",
        "        else:\n",
        "            v = subprocess.Popen(r'make -C obj_dir -j -f V'+fileNameRoot+'.mk V'+fileNameRoot+'; cd /content/tmp_code/obj_dir',    #call makefile to g++ compile appropriate files\n",
        "                                 stdout = subprocess.PIPE, stderr = subprocess.STDOUT, shell = True, universal_newlines=True)\n",
        "\n",
        "        output = v.stdout.read().strip()\n",
        "        # Step 6: Execute it\n",
        "        # if not nameOrder:\n",
        "        #   names = [f.nam for f in verilogIOs if f.dir != 'SIG']\n",
        "        #   writeJson(names, fname=fileNameRoot+'.nmo')\n",
        "        #   nameOrder = fileNameRoot+'.nmo'\n",
        "        # cd(homeDir)\n",
        "        # ret = executeSimulation(designFolder, verilogFile, tBenchFile, draw,\n",
        "        #                     compress, Hex, verbose, clock, nameOrder,\n",
        "        #                     processClockWaveform, hscale, pythonPath)\n",
        "        # if draw is False:\n",
        "        #     return ret\n",
        "        0\n",
        "        subprocess.run([\"/content/tmp_code/obj_dir/V\" +fileNameRoot, \"/content/tmp_code\" + fileNameRoot + \".stm\", \"--trace\" ])\n",
        "        # !./tmp_code/obj_dir/VbehavLoadableReg /content/tmp_code/temp.stm --trace\n",
        "      # !vcd < /content/logs/vlt_dump.vcd\n",
        "        subprocess.run([\"vcd\", \"<\", \"/content/logs/vlt_dump.vcd\"])\n",
        "    except Exception as e:\n",
        "        os.chdir(homeDir)\n",
        "        print(str(e))\n",
        "def showWaveformClicked(self):\n",
        "    sc = cellDict[self]\n",
        "    assert sc is not None, \"Internal error with cellDict\"\n",
        "\n",
        "    if submitCodes(sc.interpreterHomeDir, sc.textSourceCode, sc.textStimulus, sc.selectHexBin.value) == False:\n",
        "        return\n",
        "    srcFileName = getModuleName(sc.textSourceCode)\n",
        "    arrow = sc.chkArrow.value\n",
        "    hex = True if sc.selectHexBin.value is 'Hex' else False\n",
        "    assert os.path.exists(sc.interpreterHomeDir+'/tmp_code/'+srcFileName+'.sv'), \"Please submit the codes before showing waveform: {} {}\".format(sc.interpreterHomeDir, srcFileName)\n",
        "    generate(sc.interpreterHomeDir+'/tmp_code', srcFileName+'.sv', srcFileName+'.stm', compress=True, Hex=hex, verbose=True, processClockWaveform=arrow)\n",
        "    if sc.showCode.value:\n",
        "        print(\"------------------------------------------------------------------------------------------\")\n",
        "        print(\"Source code for the simulation above:\")\n",
        "        print(\"------------------------------------------------------------------------------------------\")\n",
        "        print(sc.textSourceCode.value)\n",
        "        print(\"------------------------------------------------------------------------------------------\")\n",
        "\n",
        "    print(\"###########################################################################################\")\n",
        "    x = subprocess.run([\"/content/tmp_code/obj_dir/V\" +srcFileName, \"/content/tmp_code/\" + srcFileName + \".stm\", \"--trace\" ], stdout = subprocess.PIPE, stderr = subprocess.PIPE)\n",
        "    print(x.stderr + x.stdout)\n",
        "    # x = subprocess.run([\"vcd\", \"< /content/tmp_code/logs/vlt_dump.vcd\" ], stdout = subprocess.PIPE, stderr = subprocess.PIPE)\n",
        "    # print(str(x.stderr) + str(x.stdout))\n",
        "    # # os.system(\"vcd < /content/tmp_code/logs/vlt_dump.vcd\" )\n",
        "    vcd()\n",
        "class SimCell:\n",
        "  def __init__(self, textSourceCode, textStimulus, chkArrow, selectHexBin, interpreterHomeDir, showCode, contents):\n",
        "      self.textSourceCode = textSourceCode\n",
        "      self.textStimulus = textStimulus\n",
        "      self.chkArrow = chkArrow\n",
        "      self.selectHexBin = selectHexBin\n",
        "      self.interpreterHomeDir = \"/content\"\n",
        "      self.showCode = showCode\n",
        "      self.contents = contents\n",
        "def readContents(contents):\n",
        "    if contents is None:\n",
        "        code = ''\n",
        "        stim = ''\n",
        "    else:\n",
        "        print(contents)\n",
        "        contents = \"/content/\" + contents \n",
        "        with open(contents + \".sv\") as f:\n",
        "            code = f.read()\n",
        "        with open(contents + \".stm\") as f:\n",
        "            stim = f.read()\n",
        "        # with open(JTEXT+'/pgms/' + contents[:-1] + \"tm\") as f:\n",
        "        #     stim = f.read()\n",
        "    return [code, stim]\n",
        "\n",
        "cellDict = dict()\n",
        "\n",
        "def CreateWidgets(contents, ht=\"125px\", wid=\"500px\", stht='125px', stwid='500px'):\n",
        "    code, stim = readContents(contents)\n",
        "\n",
        "    srcCodeWidget = widgets.Textarea(\n",
        "                            disabled=False,\n",
        "                            value = code,\n",
        "                            layout=widgets.Layout(height=ht,width=wid),\n",
        "                            )\n",
        "\n",
        "    stimulusWidget = widgets.Textarea(\n",
        "                            value=stim,\n",
        "                            disabled=False,\n",
        "                            layout=widgets.Layout(height=stht, width=stwid),\n",
        "                            )\n",
        "\n",
        "    selectHexBin = widgets.Dropdown(options=['Binary','Hex', 'Decimal'],\n",
        "                                 value='Decimal',\n",
        "                                 description='',\n",
        "                                 disabled=False,\n",
        "                                 )\n",
        "\n",
        "    chkArrow = widgets.Checkbox(description='Show the clock arrow', value=True, indent=False)\n",
        "    showCode = widgets.Checkbox(description='Show source code below waveform', value=False, indent=False)\n",
        "    #butt_submit = widgets.Button(description='Save code')\n",
        "    butt_show_waveform = widgets.Button(description='Run simulation')\n",
        "    butt_refresh_contents = widgets.Button(description='Restore code')\n",
        "    butt_save_code = widgets.Button(description = \"Save code\")\n",
        "    return srcCodeWidget, stimulusWidget, selectHexBin, chkArrow, showCode, butt_show_waveform, butt_refresh_contents, butt_save_code\n",
        "\n",
        "def submitCodes(interpreterHomeDir, textSourceCode, textStimulus, selectHexBin):\n",
        "    print(selectHexBin)\n",
        "    if textSourceCode.value is '' or textStimulus.value is '':\n",
        "        print(\"The source code and stimulus cannot be empty! Please input again\")\n",
        "        print(\"###########################################################################################\")\n",
        "        return False\n",
        "    else:\n",
        "        with open(interpreterHomeDir + \"/tmp_code/\" + getModuleName(textSourceCode) + \".sv\", 'w') as f:\n",
        "            f.write(textSourceCode.value)\n",
        "        with open(interpreterHomeDir + \"/tmp_code/\" + getModuleName(textSourceCode) + \".stm\", 'w') as f:\n",
        "            temp_string = textStimulus.value\n",
        "            temp_string = temp_string + '\\n' + '\\n'\n",
        "            skip_two_lines = 0\n",
        "            cur_substring = \"\"\n",
        "            last_break = ''\n",
        "            binary = ['0', '1', '\\n', ' ']\n",
        "            hex = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F', ' ', '\\n']\n",
        "            if selectHexBin == 'Hex':\n",
        "                for i in textStimulus.value:\n",
        "                    if i == '\\n' and skip_two_lines !=2:\n",
        "                      skip_two_lines+=1\n",
        "                      last_break = '\\n'\n",
        "                      continue\n",
        "                    if skip_two_lines < 2:\n",
        "                      continue\n",
        "                    if hex.count(i) == 0:\n",
        "                        print(\"Invalid Hex Character, Removing...\")\n",
        "                        temp_string = temp_string.replace(i, '')\n",
        "                        continue\n",
        "                    if i != ' ' and i != '\\n':\n",
        "                      cur_substring = cur_substring + i\n",
        "                    elif i == ' ' and cur_substring:\n",
        "                      temp_string = temp_string.replace(last_break + cur_substring + i, last_break + str(int(cur_substring, 16)) + ' ')\n",
        "                      last_break = ' '\n",
        "                      cur_substring = \"\"\n",
        "                    elif i == '\\n' and cur_substring:\n",
        "                      temp_string = temp_string.replace(last_break + cur_substring + i, last_break + str(int(cur_substring, 16)) + '\\n')\n",
        "                      last_break = '\\n'\n",
        "                      cur_substring = \"\"\n",
        "                    elif i == ' ':\n",
        "                      last_break = ' '\n",
        "                    elif i == '\\n':\n",
        "                      last_break = '\\n'\n",
        "            elif selectHexBin == 'Binary':\n",
        "                  for i in textStimulus.value:\n",
        "                    if i == '\\n' and skip_two_lines !=2:\n",
        "                      skip_two_lines+=1\n",
        "                      last_break = '\\n'\n",
        "                      continue\n",
        "                    if skip_two_lines < 2:\n",
        "                      continue\n",
        "                    if binary.count(i) == 0:\n",
        "                        print(\"Invalid Hex Character, Skipping...\")\n",
        "                        continue\n",
        "                    if i != ' ' and i != '\\n':\n",
        "                      cur_substring = cur_substring + i\n",
        "                    elif i == ' ' and cur_substring:\n",
        "                      temp_string = temp_string.replace(last_break + cur_substring + i, last_break + str(int(cur_substring, 2)) + ' ')\n",
        "                      last_break = ' '\n",
        "                      cur_substring = \"\"\n",
        "                    elif i == '\\n' and cur_substring:\n",
        "                      temp_string = temp_string.replace(last_break + cur_substring + i, last_break + str(int(cur_substring, 2)) + '\\n')\n",
        "                      last_break = '\\n'\n",
        "                      cur_substring = \"\"\n",
        "                    elif i == ' ':\n",
        "                      last_break = ' '\n",
        "                    elif i == '\\n':\n",
        "                      last_break = '\\n'\n",
        "            if selectHexBin != \"Decimal\":\n",
        "              print(f\"Converted Values of STM \\n\")\n",
        "              print(temp_string)\n",
        "            f.write(temp_string[:-1])\n",
        "    return True\n",
        "\n",
        "def refreshContentsClicked(self):\n",
        "    sc = cellDict[self]\n",
        "    assert sc is not None, \"Internal error with cellDict\"\n",
        "    code, stim = readContents(sc.contents)\n",
        "    sc.textSourceCode.value = code\n",
        "    sc.textStimulus.value = stim\n",
        "\n",
        "def overwriteSavedCode(self):\n",
        "    sc = cellDict[self]\n",
        "    print(sc.contents)\n",
        "    file_location = \"/content/\" + sc.contents\n",
        "    with open(file_location + \".sv\", \"w\") as f:\n",
        "      f.write(sc.textSourceCode.value)\n",
        "    with open(file_location+\".stm\", \"w\") as f:\n",
        "      f.write(sc.textStimulus.value)\n",
        "\n",
        "def createSimulationWorkSpace(initialContents = None, ht='125px', wid='500px', stht='125px', stwid='500px'):\n",
        "\n",
        "    interpreterHomeDir = os.getcwd()\n",
        "    code_file_path = interpreterHomeDir+'/tmp_code'\n",
        "    if not os.path.exists(code_file_path):\n",
        "        os.mkdir(code_file_path)\n",
        "\n",
        "    # Create widgets for this part\n",
        "    textSourceCode, textStimulus, selectHexBin, chkArrow, showCode, btnShowWaveform, btnRestoreCode, btnSaveCode = CreateWidgets(initialContents, ht, wid, stht, stwid)\n",
        "    #print(textSourceCode.value)\n",
        "    #print(textStimulus.value)\n",
        "\n",
        "    # Register callbacks for when clicking the button\n",
        "    btnShowWaveform.on_click(showWaveformClicked)\n",
        "    btnRestoreCode.on_click(refreshContentsClicked)\n",
        "    btnSaveCode.on_click(overwriteSavedCode)\n",
        "    # Register this cell's info\n",
        "    sc = SimCell(textSourceCode, textStimulus, chkArrow, selectHexBin, interpreterHomeDir, showCode, initialContents)\n",
        "    cellDict[btnShowWaveform] = sc\n",
        "    cellDict[btnRestoreCode] = sc\n",
        "    cellDict[btnSaveCode] = sc\n",
        "\n",
        "\n",
        "    # Draw cell widgets\n",
        "    leftPart = widgets.VBox([\n",
        "                        widgets.VBox([\n",
        "                                widgets.Label('Source code area:'),\n",
        "                                textSourceCode\n",
        "                                ]),\n",
        "                        widgets.VBox([\n",
        "                                widgets.Label('Simulation code area:'),\n",
        "                                textStimulus\n",
        "                                ])\n",
        "                        ])\n",
        "    rightPart = widgets.VBox([\n",
        "                                widgets.Label(''),\n",
        "                                widgets.Label(''),\n",
        "                                widgets.Label('Select Simulation Input Type'),\n",
        "                                selectHexBin,\n",
        "                                showCode,\n",
        "                                #widgets.Label(''),\n",
        "                                btnShowWaveform,\n",
        "                                #widgets.Label(''),\n",
        "                                btnSaveCode,\n",
        "                                widgets.Label(''),\n",
        "                                widgets.Label(''),\n",
        "                                widgets.Label(''),\n",
        "                                widgets.Label(''),\n",
        "                                widgets.Label(''),\n",
        "                                btnRestoreCode\n",
        "                            ])\n",
        "\n",
        "    # Show widgets\n",
        "    display(widgets.HBox([leftPart,rightPart]))\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "xHXiV6rbNOkf"
      },
      "outputs": [],
      "source": [
        "#@title Import Simulation Files\n",
        "cd(\"/content/tmp_code\")\n",
        "import_text_bin(\"TBtemplate.txt\")\n",
        "import_text_bin(\"simTemplate.txt\")\n",
        "import_text_bin(\"simTemplate2.txt\")\n",
        "import_text(\"statemachine.sv\")\n",
        "import_text(\"statemachine.stm\")\n",
        "\n",
        "cd(\"/content\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "Y0jredmRNh7O"
      },
      "outputs": [],
      "source": [
        "#@title Grid Creation\n",
        "import ipywidgets as widgets\n",
        "from ipywidgets import GridspecLayout\n",
        "from ipywidgets import AppLayout, Button, Layout, jslink, IntText, IntSlider\n",
        "\n",
        "# function of creating button widget\n",
        "def create_expanded_button(description, button_style, width=\"100px\"):\n",
        "    return Button(\n",
        "        description=description,\n",
        "        button_style=button_style,\n",
        "        layout=Layout(height=\"auto\", width=width),\n",
        "    )\n",
        "\n",
        "\n",
        "# creates variable grid size\n",
        "def create_grid(num_input, input_string, func):\n",
        "    \"\"\"\n",
        "    - num_input = number of inputs in the function\n",
        "    - input_string = a string of all the default values and input names that are passed in (ex: AB000011011)\n",
        "    \"\"\"\n",
        "    num_row = (2**num_input) + 1\n",
        "    num_col = num_input + 2\n",
        "    grid = GridspecLayout(num_row, num_col, width=str(num_col * 117.5) + \"px\")\n",
        "\n",
        "    # creates the default values for the different input combos of the truth table\n",
        "    for i in range(0, num_row):\n",
        "        for j in range(0, num_input):\n",
        "            val = str(input_string[0])\n",
        "            grid[i, j] = create_expanded_button(val, \"info\")\n",
        "            input_string = input_string[1:]\n",
        "\n",
        "    # creates the click to check button as well as the userinput section of the table\n",
        "    for i in range(1, num_row):\n",
        "        grid[i, num_input] = widgets.BoundedIntText(\n",
        "            min=0, max=1, layout=Layout(height=\"auto\", width=\"100px\")\n",
        "        )\n",
        "        grid[0, num_col - 1] = create_expanded_button(\n",
        "            \"Click to Check\", \"warning\", width=\"150px\"\n",
        "        )\n",
        "\n",
        "    # creates the output section of the truth table to know if you're right or not\n",
        "    for i in range(1, num_row):\n",
        "        grid[i, num_col - 1] = create_expanded_button(\" \", \"warning\", width=\"150px\")\n",
        "\n",
        "    grid[0, num_input] = create_expanded_button(func, \"info\")\n",
        "    return grid\n",
        "\n",
        "\n",
        "# checks if the user input is correct\n",
        "def CheckAnswer(grid, num_inputs, input):\n",
        "    for i in range (0,len(input)):\n",
        "        if grid[i + 1, num_inputs].value == int(input[i]):\n",
        "            grid[i + 1, num_inputs + 1].button_style = \"Success\"\n",
        "            grid[i + 1, num_inputs + 1].description = \"Correct!\"\n",
        "        else:\n",
        "            grid[i + 1, num_inputs + 1].button_style = \"Danger\"\n",
        "            grid[i + 1, num_inputs + 1].description = \"Wrong! Submit again\"\n",
        "\n",
        "\n",
        "# AND gate truth table creation\n",
        "grid1_1 = create_grid(2, 'AB00011011', 'F=AB')\n",
        "\n",
        "# OR gate truth table creation\n",
        "grid1_2 = create_grid(2, 'AB00011011', 'F=A+B')\n",
        "\n",
        "# NOT gate truth table creation\n",
        "grid1_3 = create_grid(1, \"A01\", '!A')\n",
        "\n",
        "# NOR gate truth table creation\n",
        "grid1_4 = create_grid(2, 'AB00011011', 'F=NOR')\n",
        "\n",
        "# NAND gate truth table creatione\n",
        "grid1_5 = create_grid(2, 'AB00011011', 'F=NAND')\n",
        "\n",
        "# XOR gate truth table creation\n",
        "grid1_6 = create_grid(2, 'AB00011011', 'F=A^B')\n",
        "\n",
        "# XNOR gat truth table creatione\n",
        "grid1_7 = create_grid(2, 'AB00011011', 'F=~(A^B')\n",
        "\n",
        "# THIS CAN PROBABLY BE PLACED IN THE CREATE FUNCTION WITH F AS AN ARGUMENT ABCF000001010011100101110111\n",
        "\n",
        "\n",
        "# LOOK INTO HAVING THE CHECK ANSWER BUTTON DO DIFFERENT THINGS\n",
        "# DON'T LIKE THIS IMPLEMENTATION. Find a way to only need one 'on_button_clicked' function\n",
        "\n",
        "# Process when clicking the \"Check\" button\n",
        "# AND\n",
        "def on_button_clicked(self):\n",
        "    CheckAnswer(grid1_1, 2, '0001')\n",
        "\n",
        "\n",
        "# OR\n",
        "def on_button_clicked2(self):\n",
        "    CheckAnswer(grid1_2, 2, '0111')\n",
        "\n",
        "\n",
        "# NOT\n",
        "def on_button_clicked3(self):\n",
        "    CheckAnswer(grid1_3, 1, '10')\n",
        "\n",
        "\n",
        "# NOR\n",
        "def on_button_clicked4(self):\n",
        "    CheckAnswer(grid1_4, 2, '1000')\n",
        "\n",
        "\n",
        "# NAND\n",
        "def on_button_clicked5(self):\n",
        "    CheckAnswer(grid1_5, 2, '1110')\n",
        "\n",
        "\n",
        "# XOR\n",
        "def on_button_clicked6(self):\n",
        "    CheckAnswer(grid1_6, 2, '0110')\n",
        "\n",
        "\n",
        "# XNOR\n",
        "def on_button_clicked7(self):\n",
        "    CheckAnswer(grid1_7, 2, '1001')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "JjIh_NwVNv0-"
      },
      "outputs": [],
      "source": [
        "#@title Multiple Choice Creation\n",
        "from IPython.display import IFrame, display, HTML\n",
        "import ipywidgets as widgets\n",
        "from ipywidgets import GridspecLayout\n",
        "from ipywidgets import AppLayout, Button, Layout, jslink, IntText, IntSlider\n",
        "# function of creating button widget\n",
        "def create_expanded_button(description, button_style, width='400px'):\n",
        "    return Button(description=description, button_style=button_style, layout=Layout(height='auto', width=width))\n",
        "\n",
        "# function of creating grid layout\n",
        "def create_grid(A,B,C,D):\n",
        "    grid = GridspecLayout(5, 3, width='470px')\n",
        "    grid[0,0]=create_expanded_button(A,'primary')\n",
        "    grid[1,0]=create_expanded_button(B,'primary')\n",
        "    grid[2,0]=create_expanded_button(C,'primary')\n",
        "    grid[3,0]=create_expanded_button(D,'primary')  \n",
        "    grid[4,0]=create_expanded_button('Submit','Danger')  \n",
        "    return grid\n",
        "\n",
        "\n",
        "def check_answermc4(self):\n",
        "  \"\"\"\n",
        "  Used with .on_click to makesure the answer is correct\n",
        "    self: This is a button. We have added 2 new attributes to it\n",
        "      current_answer: This is the last clicked button and its description value stored as a str\n",
        "      answer: This is the correct answer from the mcdict\n",
        "\n",
        "  \"\"\"\n",
        "  if self.current_answer == 0:\n",
        "    return\n",
        "  if self.answer[0] == self.current_answer[0]:\n",
        "    self.button_style = \"Success\"\n",
        "    self.description = \"Correct!\"\n",
        "  else:\n",
        "    self.button_style = 'Danger'\n",
        "    self.description = \"Wrong, Try Again!\"\n",
        "\"\"\"\n",
        "key: The question number\n",
        "pair: This should be a list. indexes 0-3 are the choices. 4 is the answer. 5 is the question\n",
        "answer: This must be the same str value as the choice\n",
        "question: This is used in the header\n",
        "\"\"\"\n",
        "mc_dict = {\n",
        "\n",
        "    \"1\": [\"A. 0101\",\"B. 01010\", \"C. 1010\",\"D. Syntax Error\", \"A\", \"What is the value of A[5:2] where A = 9’b101010101?\"],\n",
        "    \"2\": [\"A. 11010\", \"B. 10100\", \"C. 10111\", \"D. 01000\", \"B\", \"What is the value of A << 3 where A  = 5’b11101 ?\"],\n",
        "    \"3\": [\"A. 10111\", \"B. 11101\", \"C. 101\", \"D. Syntax Error\", \"A\", \"What is the Value of {A,B} where A = 3’b101 and B = 2’11?\"],\n",
        "    \"4\": [\"A. 1010\", \"B. 111000\", \"C. 101010\", \"D. Syntax Error\", \"C\", \"What is the value of {3{2’b10}}?\"],\n",
        "    \"5\": [\"A.logic input [3:0] x\", \"B. logic [3:0] input x\", \"C. input logic x [3:0]\", \"D. input logic [3:0] x\", \"D\", \"Which signal is defined correctly?\"  ],\n",
        "    \"6\": [\"A 1’b1\", \"B. 1’b0\", \"C. An Error will be thrown\", \"D. Undefined\", \"C\", \"What is the value of x from the code above?\"],\n",
        "    \"7\": [\"A. 1’b1\", \"B. 1’b0\", \"C. 2’b11\", \"D. An Error will be thrown\", \"A\", \"What is the value of x from the above code?\"] ,\n",
        "    \"8\": [ \"A. 4'b0001\", \"B. 4'b0011\", \"C. 4'b0111\", \"D. 4'b1001\", \"D\", \"What is the value of x in the above code?\" ]\n",
        "}\n",
        "def multiple_choice4(key, dictionary):\n",
        "  \"\"\"\n",
        "  Creates a multiple choice widget that has 4 options. \n",
        "  key: This is the key to the dictionary. It will be a str of digits. \n",
        "  dictionary: the dictionary used is mc_dict. Which houses the multiple choice answers.\n",
        "  grid: The grid that has been set up and can be shown\n",
        "  header_button: sets the header_button that houses the question description\n",
        "  \"\"\"\n",
        "  answers = dictionary[key]\n",
        "  question = answers[5]\n",
        "  A = answers[0]\n",
        "  B = answers[1]\n",
        "  C = answers[2]\n",
        "  D = answers[3]\n",
        "  grid = create_grid(A,B,C,D)\n",
        "  correct_answer = answers[4]\n",
        "  setattr(grid[4,0], \"answer\", correct_answer)\n",
        "  current_answer = 0\n",
        "  setattr(grid[4,0], \"current_answer\", 0)\n",
        "  grid[4,0].button_style = \"Warning\"\n",
        "  def change_color(self):\n",
        "    current_btn = int(self.layout.grid_area[-1])\n",
        "    for i in range(0,4):\n",
        "      grid[i,0].button_style = 'primary'\n",
        "    grid[current_btn-1,0].button_style = 'info'\n",
        "    grid[4,0].current_answer = self.description\n",
        "\n",
        "  for i in range(0,4):\n",
        "    grid[i,0].on_click(change_color)\n",
        "  grid[4,0].on_click(check_answermc4)\n",
        "  header_button = create_expanded_button(question, 'info', '465px')\n",
        "  return grid, header_button\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "TBXE9hMnN6uj"
      },
      "outputs": [],
      "source": [
        "#@title Verilator Install\n",
        "!apt-get install verilator >/dev/null"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "F-3qdJGxaGg9"
      },
      "outputs": [],
      "source": [
        "# # @title Install Interactive Simulation\n",
        "# def altair_sim():\n",
        "#   with open(\"/content/tmp_code/logs/vlt_dump.vcd\", \"r\") as f:\n",
        "#       # Remove Date, Program and  Timescale\n",
        "#       for i in range(20):\n",
        "#           line = f.readline()\n",
        "#           words = line.split()\n",
        "#           try:\n",
        "#             words[0]\n",
        "#           except:\n",
        "#             line = f.readline()\n",
        "#             words = line.split()\n",
        "#             continue\n",
        "#           if words[0] == \"$date\" or words[0] == \"$timescale\" or words[0] == \"$version\":\n",
        "#               for i in range(10):\n",
        "#                   line = f.readline()\n",
        "#                   words = line.split()\n",
        "#                   if words[0] == \"$end\" or words[-1] == \"$end\":\n",
        "#                       break\n",
        "#           else:\n",
        "#               break\n",
        "#           line = f.readline()\n",
        "#       # Create the dictionary of lists for inputs\n",
        "#       signals = {}\n",
        "#       line = f.readline()\n",
        "#       words = line.split()\n",
        "#       symbols = {}\n",
        "#       for i in range(50):\n",
        "#           try:\n",
        "#             words[0]\n",
        "#           except:\n",
        "#             line = f.readline()\n",
        "#             words = line.split()\n",
        "#             continue\n",
        "#           if words[0] == \"$var\":\n",
        "#               signals[words[4]] = []\n",
        "#               symbols[words[3]] = words[4]\n",
        "\n",
        "#           elif words[0] == \"$enddefinitions\":\n",
        "#               break\n",
        "#           line = f.readline()\n",
        "#           words = line.split()\n",
        "#       k = 0\n",
        "\n",
        "#       value = 0\n",
        "#       for i in range(0, 13000):\n",
        "#           if not words:\n",
        "#               line = f.readline()\n",
        "#               words = line.split()\n",
        "#               continue\n",
        "#           elif words[0] == \"$dumpvars\":\n",
        "#               line = f.readline()\n",
        "#               words = line.split()\n",
        "#               for i in range(50):\n",
        "#                   if words[0] == \"$end\":\n",
        "#                       break\n",
        "#                   else:\n",
        "#                       lines = f.readline()\n",
        "#                       words = line.split()\n",
        "\n",
        "#           elif len(words) > 1:\n",
        "#               if words[0][0] == \"b\":\n",
        "#                   if words[0][1] == \"x\":\n",
        "#                       value = 0\n",
        "#                   else:\n",
        "#                       try:\n",
        "#                           value = int(words[0][1:-1],2)\n",
        "#                       except:\n",
        "#                           value = int(words[0][1],2)\n",
        "#                   symbol = words[1]\n",
        "#                   signals[symbols[symbol]].append(value)\n",
        "#           elif words[0][0] == \"#\" and words[0][0] != \"0\":\n",
        "#               k = k + 1\n",
        "#               for key in signals:\n",
        "#                   if len(signals[key]) < k:\n",
        "#                       try:\n",
        "#                           signals[key].append(signals[key][-1])\n",
        "#                       except:\n",
        "#                           signals[key].append(0)\n",
        "#           else:\n",
        "#               if words[0][0] == \"x\":\n",
        "#                   value = 0\n",
        "#               else:\n",
        "#                   value = int(words[0][0:-1])\n",
        "#               symbol = words[0][-1]\n",
        "#               signals[symbols[words[0][-1]]].append(value)\n",
        "#           line = f.readline()\n",
        "#           words = line.split()\n",
        "#       length_df = 0\n",
        "#       dataframe = signals\n",
        "#       for i in dataframe:\n",
        "#         if length_df < len(dataframe[i]):\n",
        "#           length_df = len(dataframe[i])\n",
        "#       for i in dataframe:\n",
        "#         if len(dataframe[i]) < length_df:\n",
        "#           dataframe[i].append(dataframe[i][-1])\n",
        "#       # Create a list of variables and their names (ignore types)\n",
        "#       # Create a key to translate the signals\n",
        "#       # Begin Cycling through the signals\n",
        "#   dataframe1 = signals\n",
        "#   df_max = 0\n",
        "#   for i in dataframe:\n",
        "#     if df_max < max(dataframe[i]):\n",
        "#       df_max = max(dataframe[i])\n",
        "#   import altair as alt\n",
        "#   import pandas as pd\n",
        "#   import numpy as np\n",
        "#   from vega_datasets import data\n",
        "#   length_df = 0\n",
        "#   for i in dataframe:\n",
        "#     if len(dataframe[i]) > length_df:\n",
        "#       length_df = len(dataframe[i])\n",
        "#   def make_waveform(dataframe):\n",
        "#     length_df = 0\n",
        "#     for i in dataframe:\n",
        "\n",
        "#       if len(dataframe[i]) > length_df:\n",
        "#         length_df = len(dataframe[i])\n",
        "\n",
        "#     source = pd.DataFrame( dataframe, index=pd.RangeIndex(length_df, name='x'))\n",
        "#     source = source.reset_index().melt('x', var_name='signals', value_name='y')\n",
        "#     scales = alt.selection_interval(bind='scales')\n",
        "\n",
        "#     multi_mouseover = alt.selection_multi(on='mouseover', toggle=True, empty='none')\n",
        "\n",
        "#     selection = alt.selection_multi(fields=['signals'], bind='legend')\n",
        "\n",
        "#     # Create a selection that chooses the nearest point & selects based on x-value\n",
        "#     nearest = alt.selection(type='multi', nearest=True, on='mouseover',\n",
        "#                             fields=['x'], empty='none')\n",
        "\n",
        "#     # The basic line\n",
        "#     line = alt.Chart(source).mark_line(interpolate='step-after').encode(\n",
        "#         x='x:Q',\n",
        "#         y='y:Q',\n",
        "#         color='signals:N'\n",
        "#     )\n",
        "\n",
        "#     # Transparent selectors across the chart. This is what tells us\n",
        "#     # the x-value of the cursor\n",
        "#     selectors = alt.Chart(source).mark_point().encode(\n",
        "#         x='x:Q',\n",
        "#         opacity=alt.value(0),\n",
        "#     ).add_selection(\n",
        "#         nearest,\n",
        "#         scales\n",
        "#     )\n",
        "\n",
        "#     # Draw points on the line, and highlight based on selection\n",
        "#     points = line.mark_point().encode(\n",
        "#         opacity=alt.condition(nearest, alt.value(1), alt.value(0))\n",
        "#     )\n",
        "\n",
        "#     # Draw text labels near the points, and highlight based on selection\n",
        "#     text = line.mark_text(align='left', dx=5, dy=-5).encode(\n",
        "#         text=alt.condition(nearest, 'y:Q', alt.value(''))\n",
        "#     )\n",
        "\n",
        "#     # Draw a rule at the location of the selection\n",
        "#     rules = alt.Chart(source).mark_rule(color='black').encode(\n",
        "#         x='x:Q',\n",
        "#     ).transform_filter(\n",
        "#         nearest\n",
        "#     )\n",
        "\n",
        "#     # Put the five layers into a chart and bind the data\n",
        "#     waveform=alt.layer(\n",
        "#         line, selectors, points, rules, text\n",
        "#     ).encode(\n",
        "#         alt.X(scale=alt.Scale(domain=(0,length_df))),\n",
        "#         alt.Y(scale=alt.Scale(domain=(0,df_max+1))),\n",
        "#         opacity=alt.condition(selection, alt.value(1), alt.value(0.2))\n",
        "#     ).properties(\n",
        "#         width=600, height=400\n",
        "#     ).add_selection(\n",
        "#         selection\n",
        "#     )\n",
        "\n",
        "#     histogram = alt.Chart(source).mark_bar().encode(\n",
        "#       alt.X('y', \n",
        "#           scale=alt.Scale(domain=(0,df_max + 1))),\n",
        "#       y='signals',\n",
        "#       color='signals:N',\n",
        "\n",
        "#     ).transform_filter(nearest).properties(\n",
        "#         width = 600, height = 200\n",
        "#     )\n",
        "#     text = histogram.mark_text(\n",
        "#         align = 'left',\n",
        "#         baseline = 'middle',\n",
        "#         dx = 3\n",
        "#     ).encode(\n",
        "#         text = 'y:Q'\n",
        "#     )\n",
        "#     histogram = histogram + text  \n",
        "#     return waveform, histogram\n",
        "\n",
        "#   waveform1, histogram1 = make_waveform(dataframe1)\n",
        "#   return waveform1, histogram1\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K9ztT21wFXN8"
      },
      "source": [
        "##State Machines"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "386EaIAioV_N"
      },
      "source": [
        "Think about a vending machine. It waits for someone to approach. It then waits for you to enter the code for the snack you want. Then it takes your money from you for the snack. Then it gives you the snack. It also has to be ready in case the user cancels their choice, takes too long or messes up the payment, and then it resets and waits for new instructions.\n",
        "\n",
        "There are 4 unique modes the vending machine can be in.\n",
        "1. Waiting for a user\n",
        "2. Entering a selectiion\n",
        "3. Waiting for payment\n",
        "4. Dispensing Food\n",
        "\n",
        "This is called a state machine. Each mode is called a state. The circuit can remember what state it is in. When certain conditions are met, the circuit will transition to a different state. The circuit does certain actions depending on what state it is in. The two big parts of a state machine are the actions and transitions. Actions are things that happen in a state and transitions are the conditions necessary to change states.\n",
        "\n",
        "We can represent this with a state graph.\n",
        "\n",
        "<img src=\"https://raw.githubusercontent.com/byuccl/digital_design_colab/main/State_Machine/media/state_machine.drawio.svg\"\n",
        "width=\"500\" height=\"300\" style=\"display: block; margin: 0 auto \" />\n",
        "<br>\n",
        "\n",
        "Each circle on the graph is a state that the machine can be in. Each arrow is a possible transition that can be made from one state to another. The label for each arrow is the variable which the transition is dependent upon. If the machine is in \"Entering a choice\" it can either move to \"Waiting for Payment\" or \"IDLE\" depending on which signal it recieves. By representing your design with a state graph, it is easy to visualize it's functionality and also find places where potential problems could arise. Additionally, it is easy to take the next step and move from a state graph to coding the hardware implementation in SystemVerilog."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "CMXlZAd58BFB"
      },
      "source": [
        "###Outputs\n",
        "\n",
        "Another thing that is useful to include in a state machine is outputs. Outputs, also called actions, are how the machine interacts with the world around it. For example, you could have a yellow LED light up while it is in the \"Waiting for Payment\" state, and a green LED light up while it is in the \"Dispensing Food\" state. Outputs also include everything the state machine does, including dispensing the food. But some outputs shouldn't be only dependent on the state. You could have a noise that plays when it switches to the \"Entering a choice\" state, but you wouldn't want it to keep playing the whole time someone is making their decision. You could make the output dependent on a stop signal from a timer in addition to the state that this is in, or maybe it only occurs on the transition.\n",
        "\n",
        "The LED outputs mentioned are know as Moore outputs. A Moore output is dependent only on the current state, and ignores all other signals. The sound output is an example of a Mealy output. Mealy outputs are dependent on the current state and another signal. These are often high as the state machine switches states. Because of this, Mealy outputs will be written next to transition lines on the State Graph, and Moore outputs will be written next to the state it is dependent on. "
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "_BX-3OmmEeYQ"
      },
      "source": [
        "###Example 2\n",
        "\n",
        "Think of a washer-dryer combo at a laundromat.\n",
        "\n",
        "It waits for someone to put in some coins. If coins are inserted, it waits for a button to be pressed to choose the service. If there are enough coins, it can be set to wash, dry or both. It then enters either the wash or dry cycle. If both were selected it will enter dry after washing is done. When dry finishes the machine goes back into idle state.\n",
        "\n",
        "It has the following states:\n",
        "1. Idle\n",
        "2. Waiting for selection.\n",
        "3. Washing\n",
        "4. Drying\n",
        "5. Done\n",
        "\n",
        "\n",
        "<img src=\"https://raw.githubusercontent.com/byuccl/digital_design_colab/main/State_Machine/media/washing_machine.drawio.svg\"\n",
        "width=\"500\" height=\"300\" style=\"display: block; margin: 0 auto \" />\n",
        "<br>\n",
        "\n",
        "The buttons and coins are used to switch it between the different states.  \n",
        "\n",
        "Though not everything is listed, this state machine also includes a few Moore outputs. For example, while in the DONE state, the beeping signal is high which drives the beep sound maker. An example of a Mealy Output would be the machine doing what it needs to switch from Washing to Drying."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "LsH3H-_Jvd2r"
      },
      "source": [
        "###Potential Mistakes\n",
        "\n",
        "\n",
        "There are some things one should be aware of when creating a state machine. There are two cases which can create a bad state machine. They are incomplete and conflicting states. Take look at the transitions out of state A in the following graphs.\n",
        "\n",
        "<img src=\"https://raw.githubusercontent.com/byuccl/digital_design_colab/main/State_Machine/media/StateGrapeTypes.drawio.svg\"\n",
        "width=\"2000\" height=\"340\" style=\"display: block; margin: 0 auto \" />\n",
        "<br>\n",
        "\n",
        "Incomplete State:\n",
        "In the second graph, there are certain conditions that will result in nothing happening. This will cause unknown behavior. For example, if both X and Y are low, there is no defined path. To check for Incomplete states, you can create a truth table of all possible values and make sure each has an outcome. An easy solution for coding is to use an else statement that sets the next state as the current state.\n",
        "\n",
        "Conflicting State:\n",
        "In this example, the same inputs can result in either state triggering which is undefined behavior. If X and Y are both high, it is told to go to both state B and C. Which one will win out is impossible to tell. This can be fixed by removing overlap and using specific logic.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "22cVX-G96gM2"
      },
      "outputs": [],
      "source": []
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Plfyj4VuRiJc"
      },
      "source": [
        "###Fixing State Diagrams\n",
        "\n",
        "\n",
        "Unfortunately, the vending machine and washer/dryer state graphs were not entirely accurate. We left several of the states incomplete in an attempt to make the graphs look less overwhelming. A complete state graph should show what happens from every combination of inputs. Here are the things we left out.  \n",
        "\n",
        "First there was no line looping back onto any of the states. If a state doesn't change for a cycle, the state diagram needs to show how that can happen.   \n",
        "For example, the IDLE state will keep looping back to the IDLE state if the start button is never pressed. Most states can loop back to themselves. Also remember that the state is updated every single clock cycle. With clock cycles being fractions of seconds, a state machine may remain in the same state for many cycles before switching.\n",
        "\n",
        "Second, multiple button presses are not accounted for. What happens if a selection is made, and the cancel button is also pressed? Which one is implemented first? In a circuit it is impossible to know. This is why you need to be careful of conflicts in your state diagram.\n",
        "\n",
        "Third, not all Mealy and Moore Outputs are shown. Often state machines will have a few outputs on every state and it would clog up the example diagram.\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "IV5Y4bIg7zBY"
      },
      "source": [
        "###Reminders for Making a State Machine\n",
        "\n",
        "1. Loop Back  \n",
        "Every clock cycle your state machine needs to be evaluated. But what if nothing changes? Then you need to tell the state machine to go to the same state again.\n",
        "\n",
        "2. Incomplete and Conflicting  \n",
        "Make sure every state is complete and does not have conflicts. Before coding you state machine. You probably want to draw it out with its different components and states.\n",
        "\n",
        "3. Moore and Mealy  \n",
        "You should consider what your Moore and Mealy outputs are.   \n",
        "As a hint here is some example code.  \n",
        " ```\n",
        " #Example Case\n",
        " STATE:\n",
        "  x <= 1;\n",
        "  ns<= STATE;\n",
        "  if(y == 1) begin\n",
        "    ns <= STATE_2;\n",
        "    z <= 1;\n",
        "```\n",
        "\n",
        "X is a Moore becaues it only relies on which state.  \n",
        "Z is Mealy because it needs to be a certain STATE and Y needs to be high for Z to go high. \n",
        "\n",
        "4. The Case   \n",
        "How does one code a state machine? By using cases.  \n",
        "```\n",
        "case(cs)\n",
        "  CASE1: Some code;\n",
        "  CASE2: Some code;\n",
        "endcase\n",
        "```\n",
        "You will use a CS and a NS variable. Current state will be used for evaluating your case statement. To change states, set Next State to the desired state. And on every clock cycle, Current state becomes Next state  \n",
        "`cs<=ns;`   \n",
        "\n",
        "5. Latches  \n",
        "If a value is in an `always_comb` block and it needs to always have a value. If there is a case where it is not given a value it will create a latch. If its in an `always_ff` it will have unknown behavior. To stop this, make sure all values have a default that is assigned to them. For `always_ff`, you can put defaults at the beginning because any later lines will override earlier lines. \n",
        "For example:\n",
        "```\n",
        "x <=0;\n",
        "if(y)\n",
        "x<=1;\n",
        "```  \n",
        "In this case, the default is `x<=0`, and in a certain case `x<=1`.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_YRCRg2gZQf8"
      },
      "source": [
        "HINTS:\n",
        "State Machine Example:  \n",
        "```\n",
        "typedef enum logic [1:0] {S0, S1, S2} statetype;\n",
        "\n",
        "statetype cs, ns;\n",
        "\n",
        "always_ff @(posedge clk) begin\n",
        "  //List all the Defaults\n",
        "  x <=0;\n",
        "  y <=0;\n",
        "  z <= 0;   \n",
        "  //Case Statement\n",
        "  case(cs) \n",
        "    S0:\n",
        "      begin\n",
        "        x<=1; //Mealy\n",
        "        ns<= S1;\n",
        "      end\n",
        "    S1:\n",
        "      begin\n",
        "        ns <= S1;\n",
        "        y<=1; //Two Moore Outputs\n",
        "        z<=1;\n",
        "        if(a) //Put if statement last\n",
        "          ns<=S2;\n",
        "      end\n",
        "    S2:\n",
        "      begin\n",
        "        ns <= S0;\n",
        "        if(b)\n",
        "          ns<=S1;\n",
        "        end\n",
        "    endcase \n",
        "end\n",
        "\n",
        "always_ff @(posedge clk) begin //This can be in the same block above\n",
        "  cs <= ns;                    //But this way is easier to read\n",
        "  if(reset)\n",
        "    cs<= S0;\n",
        "end\n",
        "      \n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jAVVCY9_utFo"
      },
      "source": [
        "\n",
        "# Safe Combination State Machine"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "0hC1l3JwIbfG"
      },
      "source": [
        "For this lab you will design a combination lock state machine.\n",
        "States:  \n",
        "\n",
        "\n",
        "\n",
        "<img src=\"https://raw.githubusercontent.com/byuccl/digital_design_colab/main/State_Machine/media/StateDiagram.svg\"\n",
        "width=\"500\" height=\"300\" style=\"display: block; margin: 0 auto \" />\n",
        "<br>\n",
        "\n",
        "Intermediate Signals:  \n",
        "CODE: If the correct code for the current state is input, then CODE is high, else, CODE is low.  \n",
        "Q: If any button is pressed, Q is high. This represents entering the code.  \n",
        "\n",
        "\n",
        "State Machine:  \n",
        "\n",
        "IDLE: The state machine will wait for BTNC to be pressed.\n",
        "\n",
        "COMBINATION_ONE: IF Q is low, nothing happens. If Q is High and Code is high, the correct code has been entered and go to next state. If Q is High and Code is Low, the incorrect code has been entered so go back to the IDLE state. In this state, LED should be given a value of `1`. \n",
        "\n",
        "COMBINATION_TWO: IF Q is low, nothing happens. If Q is High and Code is high, the correct code has been entered and go to next state. If Q is High and Code is Low, the incorrect code has been entered so go back to the IDLE state.  LED should be given a value of `2`. \n",
        "\n",
        "\n",
        "COMBINATION_THREE: IF Q is low, nothing happens. If Q is High and Code is high, the correct code has been entered and go to next state. If Q is High and Code is Low, the incorrect code has been entered so go back to the IDLE state.  LED should be given a value of `3`. \n",
        "\n",
        "OPEN: After the 3 codes have been entered, the safe will 'open' and show an LED code. If BTNC is pressed the safe will go back to IDLE state.  \n",
        "\n",
        "\n",
        "| Module Name: | mod_counter|||\n",
        "| -- --------- | ----------- |--|--|\n",
        "| Port Name      | Direction       |Width|Function|\n",
        "|reset \t|Input \t|1| Active high reset|\n",
        "|clk \t|Input \t|1| Clock used for timing|\n",
        "|btnu \t|Input \t|1| Button Up|\n",
        "|btnd \t|Input \t|1| Button Down|\n",
        "|btnc \t|Input \t|1| Button Center|\n",
        "|btnl \t|Input \t|1| Button Left|\n",
        "|btnr \t|Input \t|1| Button Right|\n",
        "|sw \t|Input \t|16 | Input used for the code|\n",
        "\n",
        "\n",
        "\n",
        " \n",
        "Specifications:\n",
        "\n",
        "Q: If btnu, btnd, btnc, btnr, or btnl are high, then Q is high.\n",
        "\n",
        "CODE:  \n",
        "Combination 1: btnd, and sw = `16'b0000000000000001`\n",
        "\n",
        "Combination 2: btnr and sw = `16'b1111001111001111`\n",
        "\n",
        "Combination 3: btnc and sw = `16'b0100101010100111`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UUCB26A_vQTz"
      },
      "source": [
        "\n",
        "## Creating a Module"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450,
          "referenced_widgets": [
            "b78145dc4c224c5fbc4509c754d7db30",
            "9da7bc7803ce4388b572acf324b06b81",
            "897dd6cfacba404da6ab873f94c93fa5",
            "fa035316384d473391f5365d0627fcd0",
            "eacafa1d5ec247e8919d6ef76260ad88",
            "dd7702028adb4fa69f9ae075f6880189",
            "cc7a75303d9f46b9bd337b259e2c83c2",
            "72a928249509454aaaf73e8071e875e0",
            "7e4663098d274fe6a94d2c0f3cd5c563",
            "cfd0a21756b44a4bafc0dc25fc54b7d9",
            "2a7d9e5a5fd14f5196d5b3b30b8f47e4",
            "e3db635b03bc4476b13093f2eeec7275",
            "26e982d3f1fc4bdf9509984a5194236e",
            "f5b43b148e144a5db8536959127a6197",
            "5ce3ae846e2546dda6b13686a487f463",
            "7d87601f148740d2bbd3bfe7b7eb7687",
            "6581a78aa7104385b7a0f5896df5ee4b",
            "7f4cfa7dd50843de924ab446f253da70",
            "7e9205f8c0b24e6bbdf5eecfb536335b",
            "6a228713ae9446f48cdc8b675722231a",
            "ecc6cae0bf244a739f0a0b737b227477",
            "ee806558373d4ad9bc601aae00c2fdda",
            "b7d94c6b1b87402cb66b1b6f9d33d03a",
            "b8ecb22e2406466db844b7a52ccd408d",
            "8b196a8754b1414d862e67959989ba82",
            "9fca6263979347908589f27450bdadfd",
            "9a1df7be24a14d71aeee6aa732d5d3ed",
            "8aa3fd5be6954e13840128b1e62708cb",
            "32b9bd65668f4c8a8a96732475876b59",
            "203f053c179b4d6382c096962ba52ece",
            "7c2d65b48c89430a964bfad24b975794",
            "a98a2dbbe9c84c01a914324e1cd15f64",
            "dcfae63c16aa4680aaf866014c6a0a47",
            "a38b1820473d4db1be0cbf483373f7f0",
            "3b95adc8fac04ae0997eda251b415508",
            "84af08b5a8454d41b54f7cb0f9a640ea",
            "14b7863989f94eb29f0cc8d6ceb22b98",
            "b3c8e1ab8c6d4d38b0cbed7476264d47",
            "47529699f14243d688559cc47d2cbda4",
            "08e3006126354636b095e3a0265ed947",
            "28774868e69443a88d07fceb4520c130",
            "d7f14ad2d79a45acb7a52ba104dd96e5",
            "ea053217c33845e7bb1424c82606e2ac",
            "4aca06b5553c4586aec19959a2880d90",
            "f9faf0b8176d460f97882aa03034c8d2",
            "384082038e7f44d4b780cb8c7e333863",
            "8bee7ccb1bc54bae9878a32f7ed4c156",
            "b437305c140b47de95b98c38ee07aaf7",
            "8befce7a9453450dbd1968c41b9a86d6",
            "29bd2304664f4429bae9ad4fdefc044f",
            "bb9b104727e748908632f1d7e5306541",
            "7fb98a9e464d4b7db56ad06448476433",
            "c71d53d2112f4b8a9338cc49c8198c18",
            "d1bec80b63da44fba7de6ff9a6ccd7ea",
            "88ecffcd0aa04bfb91d607f379595371",
            "41b6172f84de4e30afc2c82f39202ed9",
            "9f33ed2461a04f9aa7885957309f7fe3",
            "3913575702e449dbbd770e25a5e7a5e6",
            "2e51756db0f84a50b763ec66f367447a",
            "ca757bdf210c4c1dbebcf98c6266fa0d",
            "45ad6abc705f4840acecdcddc3a54ce4"
          ]
        },
        "id": "N2eL6OBHveTY",
        "outputId": "7f74a00a-447d-4a07-c7dd-b76606c136e9"
      },
      "outputs": [],
      "source": [
        "#@title\n",
        "createSimulationWorkSpace(\"tmp_code/statemachine\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "UKp9A_W1txnq"
      },
      "outputs": [],
      "source": [
        "#@title Create WaveDrom\n",
        "df2wd(\"sm\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "qsGeKCiJt0nt"
      },
      "outputs": [],
      "source": [
        "#@title Show WaveDrom\n",
        "%%wavedrom_magic -h 200 -o /content/tmp_code/sm.txt\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ej_RS56DikGK"
      },
      "source": [
        "###XDC Files"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1AXBeZbBAQ2y"
      },
      "outputs": [],
      "source": [
        "#Set this up yourself\n",
        "%%bash -c 'cat > /content/tmp_code/xdc.xdc'\n",
        "###################################################################\n",
        "# basys3_220.xdc\n",
        "#\n",
        "# This is a master constraints file for laboratory assignments used\n",
        "# at BYU for ECEN 220.\n",
        "#\n",
        "# You should uncomment those lines that define ports that you used\n",
        "# in your top-level design. You should also change the name of the\n",
        "# port in the .xdc file to match your corresponding top-level port.\n",
        "#\n",
        "###################################################################\n",
        "## Buttons\n",
        "# set_property -dict { PACKAGE_PIN U18   IOSTANDARD LVCMOS33 } [get_ports { btnc }];\n",
        "# set_property -dict { PACKAGE_PIN T18   IOSTANDARD LVCMOS33 } [get_ports { btnu }];\n",
        "# set_property -dict { PACKAGE_PIN W19   IOSTANDARD LVCMOS33 } [get_ports { btnl }];\n",
        "# set_property -dict { PACKAGE_PIN T17   IOSTANDARD LVCMOS33 } [get_ports { btnr }];\n",
        "# set_property -dict { PACKAGE_PIN U17   IOSTANDARD LVCMOS33 } [get_ports { btnd }];\n",
        "\n",
        "# ## Switches\n",
        "# set_property -dict { PACKAGE_PIN V17   IOSTANDARD LVCMOS33 } [get_ports { sw[0] }];\n",
        "# set_property -dict { PACKAGE_PIN V16   IOSTANDARD LVCMOS33 } [get_ports { sw[1] }];\n",
        "# set_property -dict { PACKAGE_PIN W16   IOSTANDARD LVCMOS33 } [get_ports { sw[2] }];\n",
        "# set_property -dict { PACKAGE_PIN W17   IOSTANDARD LVCMOS33 } [get_ports { sw[3] }];\n",
        "# set_property -dict { PACKAGE_PIN W15   IOSTANDARD LVCMOS33 } [get_ports { sw[4] }];\n",
        "# set_property -dict { PACKAGE_PIN V15   IOSTANDARD LVCMOS33 } [get_ports { sw[5] }];\n",
        "# set_property -dict { PACKAGE_PIN W14   IOSTANDARD LVCMOS33 } [get_ports { sw[6] }];\n",
        "# set_property -dict { PACKAGE_PIN W13   IOSTANDARD LVCMOS33 } [get_ports { sw[7] }];\n",
        "# set_property -dict { PACKAGE_PIN V2    IOSTANDARD LVCMOS33 } [get_ports { sw[8] }];\n",
        "# set_property -dict { PACKAGE_PIN T3    IOSTANDARD LVCMOS33 } [get_ports { sw[9] }];\n",
        "# set_property -dict { PACKAGE_PIN T2    IOSTANDARD LVCMOS33 } [get_ports { sw[10] }];\n",
        "# set_property -dict { PACKAGE_PIN R3    IOSTANDARD LVCMOS33 } [get_ports { sw[11] }];\n",
        "# set_property -dict { PACKAGE_PIN W2    IOSTANDARD LVCMOS33 } [get_ports { sw[12] }];\n",
        "# set_property -dict { PACKAGE_PIN U1    IOSTANDARD LVCMOS33 } [get_ports { sw[13] }];\n",
        "# set_property -dict { PACKAGE_PIN T1    IOSTANDARD LVCMOS33 } [get_ports { sw[14] }];\n",
        "# set_property -dict { PACKAGE_PIN R2    IOSTANDARD LVCMOS33 } [get_ports { sw[15] }];\n",
        "\n",
        "## LEDs\n",
        "# set_property -dict { PACKAGE_PIN U16   IOSTANDARD LVCMOS33 } [get_ports { led[0] }];\n",
        "# set_property -dict { PACKAGE_PIN E19   IOSTANDARD LVCMOS33 } [get_ports { led[1] }];\n",
        "# set_property -dict { PACKAGE_PIN U19   IOSTANDARD LVCMOS33 } [get_ports { led[2] }];\n",
        "# set_property -dict { PACKAGE_PIN V19   IOSTANDARD LVCMOS33 } [get_ports { led[3] }];\n",
        "# set_property -dict { PACKAGE_PIN W18   IOSTANDARD LVCMOS33 } [get_ports { led[4] }];\n",
        "# set_property -dict { PACKAGE_PIN U15   IOSTANDARD LVCMOS33 } [get_ports { led[5] }];\n",
        "# set_property -dict { PACKAGE_PIN U14   IOSTANDARD LVCMOS33 } [get_ports { led[6] }];\n",
        "# set_property -dict { PACKAGE_PIN V14   IOSTANDARD LVCMOS33 } [get_ports { led[7] }];\n",
        "# set_property -dict { PACKAGE_PIN V13   IOSTANDARD LVCMOS33 } [get_ports { led[8] }];\n",
        "# set_property -dict { PACKAGE_PIN V3    IOSTANDARD LVCMOS33 } [get_ports { led[9] }];\n",
        "# set_property -dict { PACKAGE_PIN W3    IOSTANDARD LVCMOS33 } [get_ports { led[10] }];\n",
        "# set_property -dict { PACKAGE_PIN U3    IOSTANDARD LVCMOS33 } [get_ports { led[11] }];\n",
        "# set_property -dict { PACKAGE_PIN P3    IOSTANDARD LVCMOS33 } [get_ports { led[12] }];\n",
        "# set_property -dict { PACKAGE_PIN N3    IOSTANDARD LVCMOS33 } [get_ports { led[13] }];\n",
        "# set_property -dict { PACKAGE_PIN P1    IOSTANDARD LVCMOS33 } [get_ports { led[14] }];\n",
        "# set_property -dict { PACKAGE_PIN L1    IOSTANDARD LVCMOS33 } [get_ports { led[15] }];\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_toaZpwTui3E"
      },
      "source": [
        "\n",
        "## Compiling with the F4PGA Toolchain\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQd2K_jAwbFS"
      },
      "source": [
        "### Installing the Toolchain"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_Kiqepttt8OK"
      },
      "outputs": [],
      "source": [
        "# !pip install -q condacolab\n",
        "# import condacolab\n",
        "# condacolab.install()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZQFNmbQquBYV"
      },
      "outputs": [],
      "source": [
        "!apt install -y git wget xz-utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rF1gehMvuC1L"
      },
      "outputs": [],
      "source": [
        "%%bash\n",
        "cd /content\n",
        "git clone https://github.com/chipsalliance/f4pga-examples\n",
        "cd f4pga-examples\n",
        "wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O conda_installer.sh\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4RV_Okw2uJYm"
      },
      "outputs": [],
      "source": [
        "#Creates the Conda Environment\n",
        "%%bash\n",
        "cd /content/f4pga-examples\n",
        "export F4PGA_INSTALL_DIR=~/opt/f4pga\n",
        "export FPGA_FAM=xc7\n",
        "bash conda_installer.sh -u -b -p $F4PGA_INSTALL_DIR/$FPGA_FAM/conda;\n",
        "source \"$F4PGA_INSTALL_DIR/$FPGA_FAM/conda/etc/profile.d/conda.sh\";\n",
        "conda env create -f $FPGA_FAM/environment.yml"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FBqTs5CsuLb6"
      },
      "outputs": [],
      "source": [
        "#Download F4PGA Arch Defs\n",
        "%%bash\n",
        "export F4PGA_INSTALL_DIR=~/opt/f4pga\n",
        "export FPGA_FAM=xc7\n",
        "source \"$F4PGA_INSTALL_DIR/$FPGA_FAM/conda/etc/profile.d/conda.sh\";\n",
        "conda activate xc7\n",
        "mkdir -p $F4PGA_INSTALL_DIR/xc7/install\n",
        "\n",
        "F4PGA_TIMESTAMP='20220907-210059'\n",
        "F4PGA_HASH='66a976d'\n",
        "export F4PGA_PACKAGES='install-xc7 xc7a50t_test'\n",
        "\n",
        "for PKG in $F4PGA_PACKAGES; do\n",
        "  wget -qO- https://storage.googleapis.com/symbiflow-arch-defs/artifacts/prod/foss-fpga-tools/symbiflow-arch-defs/continuous/install/${F4PGA_TIMESTAMP}/symbiflow-arch-defs-${PKG}-${F4PGA_HASH}.tar.xz | tar -xJC $F4PGA_INSTALL_DIR/${FPGA_FAM}\n",
        "done"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EzO5bK_Awg2q"
      },
      "source": [
        "### Compiling with the Toolchain"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZnnVzP55uSCL"
      },
      "outputs": [],
      "source": [
        "#This creates the Makefile\n",
        "with open(\"/content/tmp_code/Makefile\", \"w\") as f:\n",
        "  f.write(\"\"\"current_dir := ${CURDIR}\n",
        "TARGET := basys3\n",
        "\n",
        "TOP := StateMachine\n",
        "\n",
        "XDC := ${current_dir}/*.xdc\n",
        "\n",
        "SOURCES := $(wildcard ${current_dir}/*.v ${current_dir}/*.sv)\n",
        "\n",
        "include /content/f4pga-examples/common/common.mk\n",
        "\"\"\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RmnDxe2MuPcG"
      },
      "outputs": [],
      "source": [
        "#Make the project\n",
        "%%bash\n",
        "export F4PGA_INSTALL_DIR=~/opt/f4pga\n",
        "export FPGA_FAM=xc7\n",
        "export TARGET=basys3\n",
        "source \"$F4PGA_INSTALL_DIR/$FPGA_FAM/conda/etc/profile.d/conda.sh\";\n",
        "conda activate xc7\n",
        "cd /content/tmp_code\n",
        "make 2> ./error.log 1>./compile.log\n",
        "cp ./build/basys3/*.bit ./StateMachine.bit"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jkKm3WaizMYC"
      },
      "source": [
        "## Testing it on the board"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sRrGK3LkIbXK"
      },
      "source": [
        "You can use this configuration file and the program openOCD to download the bitstream to your board. You will need to download this file and the bitstream to your local machine."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1XrEe8VTuUdg"
      },
      "outputs": [],
      "source": [
        "#Create File for openocd\n",
        "with open(\"./content/StateMachine.cfg\", \"w\") as f:\n",
        "  f.write(\"\"\"interface ftdi\n",
        "ftdi_device_desc \"Digilent USB Device\"\n",
        "ftdi_vid_pid 0x0403 0x6010\n",
        "# channel 1 does not have any functionality\n",
        "ftdi_channel 0\n",
        "# just TCK TDI TDO TMS, no reset\n",
        "ftdi_layout_init 0x0088 0x008b\n",
        "reset_config none\n",
        "adapter_khz 10000\n",
        "\n",
        "source [find cpld/xilinx-xc7.cfg]\n",
        "source [find cpld/jtagspi.cfg]\n",
        "init\n",
        "\n",
        "puts [irscan xc7.tap 0x09]\n",
        "\n",
        "set xc7a35t \"0362D093\"\n",
        "set xc7a100t \"13631093\"\n",
        "set code [drscan xc7.tap 32 0]  \n",
        "puts $code\n",
        "\n",
        "if { $code == $xc7a35t} {\n",
        "    puts \"The board has an xc7a35t\"\n",
        "}\n",
        "\n",
        "if { $code == $xc7a100t} {\n",
        "    puts \"The board has an xc7a100t\"\n",
        "}\n",
        "\n",
        "puts \"Programming...\"\n",
        "pld load 0 StateMachine.bit\n",
        "exit\"\"\"\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sdL0pwYseGPK"
      },
      "outputs": [],
      "source": [
        "#@title Create Zip\n",
        "%%bash\n",
        "cd /content\n",
        "mv StateMachine/build/basys3/*.bit ./\n",
        "zip StateMachine.zip *.bit *.cfg"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.8.10 64-bit",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.10 (default, Jun 22 2022, 20:18:18) \n[GCC 9.4.0]"
    },
    "vscode": {
      "interpreter": {
        "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "08e3006126354636b095e3a0265ed947": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "14b7863989f94eb29f0cc8d6ceb22b98": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "203f053c179b4d6382c096962ba52ece": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "26e982d3f1fc4bdf9509984a5194236e": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Run simulation",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_b3c8e1ab8c6d4d38b0cbed7476264d47",
            "style": "IPY_MODEL_47529699f14243d688559cc47d2cbda4",
            "tooltip": ""
          }
        },
        "28774868e69443a88d07fceb4520c130": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "29bd2304664f4429bae9ad4fdefc044f": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2a7d9e5a5fd14f5196d5b3b30b8f47e4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "CheckboxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "CheckboxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "CheckboxView",
            "description": "Show the clock arrow",
            "description_tooltip": null,
            "disabled": false,
            "indent": false,
            "layout": "IPY_MODEL_a38b1820473d4db1be0cbf483373f7f0",
            "style": "IPY_MODEL_3b95adc8fac04ae0997eda251b415508",
            "value": true
          }
        },
        "2e51756db0f84a50b763ec66f367447a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "32b9bd65668f4c8a8a96732475876b59": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "384082038e7f44d4b780cb8c7e333863": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3913575702e449dbbd770e25a5e7a5e6": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3b95adc8fac04ae0997eda251b415508": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "41b6172f84de4e30afc2c82f39202ed9": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": "125px",
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": "500px"
          }
        },
        "45ad6abc705f4840acecdcddc3a54ce4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "47529699f14243d688559cc47d2cbda4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "4aca06b5553c4586aec19959a2880d90": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "5ce3ae846e2546dda6b13686a487f463": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d7f14ad2d79a45acb7a52ba104dd96e5",
            "placeholder": "​",
            "style": "IPY_MODEL_ea053217c33845e7bb1424c82606e2ac",
            "value": ""
          }
        },
        "6581a78aa7104385b7a0f5896df5ee4b": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_384082038e7f44d4b780cb8c7e333863",
            "placeholder": "​",
            "style": "IPY_MODEL_8bee7ccb1bc54bae9878a32f7ed4c156",
            "value": ""
          }
        },
        "6a228713ae9446f48cdc8b675722231a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Restore code",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_7fb98a9e464d4b7db56ad06448476433",
            "style": "IPY_MODEL_c71d53d2112f4b8a9338cc49c8198c18",
            "tooltip": ""
          }
        },
        "72a928249509454aaaf73e8071e875e0": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_8aa3fd5be6954e13840128b1e62708cb",
            "placeholder": "​",
            "style": "IPY_MODEL_32b9bd65668f4c8a8a96732475876b59",
            "value": ""
          }
        },
        "7c2d65b48c89430a964bfad24b975794": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "7d87601f148740d2bbd3bfe7b7eb7687": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_4aca06b5553c4586aec19959a2880d90",
            "placeholder": "​",
            "style": "IPY_MODEL_f9faf0b8176d460f97882aa03034c8d2",
            "value": ""
          }
        },
        "7e4663098d274fe6a94d2c0f3cd5c563": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_203f053c179b4d6382c096962ba52ece",
            "placeholder": "​",
            "style": "IPY_MODEL_7c2d65b48c89430a964bfad24b975794",
            "value": "Choose stimulus base:"
          }
        },
        "7e9205f8c0b24e6bbdf5eecfb536335b": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_29bd2304664f4429bae9ad4fdefc044f",
            "placeholder": "​",
            "style": "IPY_MODEL_bb9b104727e748908632f1d7e5306541",
            "value": ""
          }
        },
        "7f4cfa7dd50843de924ab446f253da70": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_b437305c140b47de95b98c38ee07aaf7",
            "placeholder": "​",
            "style": "IPY_MODEL_8befce7a9453450dbd1968c41b9a86d6",
            "value": ""
          }
        },
        "7fb98a9e464d4b7db56ad06448476433": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "84af08b5a8454d41b54f7cb0f9a640ea": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "88ecffcd0aa04bfb91d607f379595371": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "897dd6cfacba404da6ab873f94c93fa5": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "VBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_72a928249509454aaaf73e8071e875e0",
              "IPY_MODEL_7e4663098d274fe6a94d2c0f3cd5c563",
              "IPY_MODEL_cfd0a21756b44a4bafc0dc25fc54b7d9",
              "IPY_MODEL_2a7d9e5a5fd14f5196d5b3b30b8f47e4",
              "IPY_MODEL_e3db635b03bc4476b13093f2eeec7275",
              "IPY_MODEL_26e982d3f1fc4bdf9509984a5194236e",
              "IPY_MODEL_f5b43b148e144a5db8536959127a6197",
              "IPY_MODEL_5ce3ae846e2546dda6b13686a487f463",
              "IPY_MODEL_7d87601f148740d2bbd3bfe7b7eb7687",
              "IPY_MODEL_6581a78aa7104385b7a0f5896df5ee4b",
              "IPY_MODEL_7f4cfa7dd50843de924ab446f253da70",
              "IPY_MODEL_7e9205f8c0b24e6bbdf5eecfb536335b",
              "IPY_MODEL_6a228713ae9446f48cdc8b675722231a"
            ],
            "layout": "IPY_MODEL_ecc6cae0bf244a739f0a0b737b227477"
          }
        },
        "8aa3fd5be6954e13840128b1e62708cb": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "8b196a8754b1414d862e67959989ba82": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_3913575702e449dbbd770e25a5e7a5e6",
            "placeholder": "​",
            "style": "IPY_MODEL_2e51756db0f84a50b763ec66f367447a",
            "value": "Simulation code area:"
          }
        },
        "8bee7ccb1bc54bae9878a32f7ed4c156": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "8befce7a9453450dbd1968c41b9a86d6": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9a1df7be24a14d71aeee6aa732d5d3ed": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9da7bc7803ce4388b572acf324b06b81": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "VBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_eacafa1d5ec247e8919d6ef76260ad88",
              "IPY_MODEL_dd7702028adb4fa69f9ae075f6880189"
            ],
            "layout": "IPY_MODEL_cc7a75303d9f46b9bd337b259e2c83c2"
          }
        },
        "9f33ed2461a04f9aa7885957309f7fe3": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9fca6263979347908589f27450bdadfd": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "TextareaModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "TextareaModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "TextareaView",
            "continuous_update": true,
            "description": "",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_ca757bdf210c4c1dbebcf98c6266fa0d",
            "placeholder": "​",
            "rows": null,
            "style": "IPY_MODEL_45ad6abc705f4840acecdcddc3a54ce4",
            "value": "clk\nbtnu btnd btnc btnl btnr sw \n"
          }
        },
        "a38b1820473d4db1be0cbf483373f7f0": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a98a2dbbe9c84c01a914324e1cd15f64": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b3c8e1ab8c6d4d38b0cbed7476264d47": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b437305c140b47de95b98c38ee07aaf7": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b78145dc4c224c5fbc4509c754d7db30": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_9da7bc7803ce4388b572acf324b06b81",
              "IPY_MODEL_897dd6cfacba404da6ab873f94c93fa5"
            ],
            "layout": "IPY_MODEL_fa035316384d473391f5365d0627fcd0"
          }
        },
        "b7d94c6b1b87402cb66b1b6f9d33d03a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "TextareaModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "TextareaModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "TextareaView",
            "continuous_update": true,
            "description": "",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_41b6172f84de4e30afc2c82f39202ed9",
            "placeholder": "​",
            "rows": null,
            "style": "IPY_MODEL_9f33ed2461a04f9aa7885957309f7fe3",
            "value": "module StateMachine(\n  //Signals\n);\n  \nendmodule\n"
          }
        },
        "b8ecb22e2406466db844b7a52ccd408d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "bb9b104727e748908632f1d7e5306541": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "c71d53d2112f4b8a9338cc49c8198c18": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "ca757bdf210c4c1dbebcf98c6266fa0d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": "125px",
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": "500px"
          }
        },
        "cc7a75303d9f46b9bd337b259e2c83c2": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "cfd0a21756b44a4bafc0dc25fc54b7d9": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DropdownModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DropdownModel",
            "_options_labels": [
              "Binary",
              "Hex"
            ],
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "DropdownView",
            "description": "",
            "description_tooltip": null,
            "disabled": false,
            "index": 1,
            "layout": "IPY_MODEL_a98a2dbbe9c84c01a914324e1cd15f64",
            "style": "IPY_MODEL_dcfae63c16aa4680aaf866014c6a0a47"
          }
        },
        "d1bec80b63da44fba7de6ff9a6ccd7ea": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "d7f14ad2d79a45acb7a52ba104dd96e5": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "dcfae63c16aa4680aaf866014c6a0a47": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "dd7702028adb4fa69f9ae075f6880189": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "VBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_8b196a8754b1414d862e67959989ba82",
              "IPY_MODEL_9fca6263979347908589f27450bdadfd"
            ],
            "layout": "IPY_MODEL_9a1df7be24a14d71aeee6aa732d5d3ed"
          }
        },
        "e3db635b03bc4476b13093f2eeec7275": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "CheckboxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "CheckboxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "CheckboxView",
            "description": "Show source code below waveform",
            "description_tooltip": null,
            "disabled": false,
            "indent": false,
            "layout": "IPY_MODEL_84af08b5a8454d41b54f7cb0f9a640ea",
            "style": "IPY_MODEL_14b7863989f94eb29f0cc8d6ceb22b98",
            "value": false
          }
        },
        "ea053217c33845e7bb1424c82606e2ac": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "eacafa1d5ec247e8919d6ef76260ad88": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "VBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_ee806558373d4ad9bc601aae00c2fdda",
              "IPY_MODEL_b7d94c6b1b87402cb66b1b6f9d33d03a"
            ],
            "layout": "IPY_MODEL_b8ecb22e2406466db844b7a52ccd408d"
          }
        },
        "ecc6cae0bf244a739f0a0b737b227477": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ee806558373d4ad9bc601aae00c2fdda": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "LabelModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "LabelModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "LabelView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d1bec80b63da44fba7de6ff9a6ccd7ea",
            "placeholder": "​",
            "style": "IPY_MODEL_88ecffcd0aa04bfb91d607f379595371",
            "value": "Source code area:"
          }
        },
        "f5b43b148e144a5db8536959127a6197": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Save code",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_08e3006126354636b095e3a0265ed947",
            "style": "IPY_MODEL_28774868e69443a88d07fceb4520c130",
            "tooltip": ""
          }
        },
        "f9faf0b8176d460f97882aa03034c8d2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "fa035316384d473391f5365d0627fcd0": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}