Lab3_Seven_Segment.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dqEF46iHDX4G"
      },
      "source": [
        "<p align=\"right\">\n",
        "<img src=\"https://raw.githubusercontent.com/anon36424/digital_design_colab/main/Dataflow/media/X.svg\"\n",
        "width=\"500\" height=\"\" style=\"display: block; margin: 0 auto\" />\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jAVVCY9_utFo"
      },
      "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{Seven Segment Display}}}$<bol><p align=\"right\">\n",
        "</summary>\n",
        "</h1>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yBUsK8h1iaS3"
      },
      "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",
        "id": "AZ3SSSP2iFey"
      },
      "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",
        "id": "FS8mVZX4iZ0x"
      },
      "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/anon36424/digital_design_colab/main/SevenSegment/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/anon36424/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",
        "import_text_bin(\"frquestion.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/anon36424/digital_design_colab.git"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "SxoYTUnhiWuh"
      },
      "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": "pW2fhCmCisb3"
      },
      "outputs": [],
      "source": [
        "#@title Import Simulation Files\n",
        "cd(\"/content/tmp_code\")\n",
        "\n",
        "import_text_bin(\"TBtemplate.txt\")\n",
        "import_text_bin(\"simTemplate.txt\")\n",
        "import_text_bin(\"simTemplate2.txt\")\n",
        "import_text(\"seven_segment.sv\")\n",
        "import_text(\"seven_segment.stm\")\n",
        "import_text(\"seven_segment_top.sv\")\n",
        "import_text(\"seven_segment_top.stm\")\n",
        "import_text(\"tb_seven_segment.cpp\")\n",
        "# import_text(\"arithmetic_top.sv\")\n",
        "# import_text(\"arithmetic_top.stm\")\n",
        "cd(\"/content\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "_PRDWbuui3oR"
      },
      "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": "5ui4LCKci6Zo"
      },
      "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": "XqKmK-pzjHV4"
      },
      "outputs": [],
      "source": [
        "#@title Verilator Install\n",
        "!apt-get install verilator >/dev/null"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "FtYfBsfAjKiv"
      },
      "outputs": [],
      "source": [
        "#@title Install PyGithub\n",
        "!pip3 install PyGithub > /dev/null"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "-9vI_B1FkCAe"
      },
      "outputs": [],
      "source": [
        "#@title Seven Segment Widget\n",
        "\n",
        "import ipywidgets as widgets\n",
        "from ipywidgets import GridspecLayout\n",
        "from ipywidgets import AppLayout, Button, Layout, jslink, IntText\n",
        "#Seven Segment Display\n",
        "def create_expanded_button(description=\"\", button_style='', width='50px', height='50px'):\n",
        "    return Button(description=description, button_style=button_style, layout=Layout(height=height, width=width))\n",
        "def create_7_grid():\n",
        " grid = GridspecLayout(5,1, width='105px') #Middle Column\n",
        " grid[0,0] = create_expanded_button(button_style = \"Danger\", width = '100px')\n",
        " grid[1,0] = create_expanded_button(width = '100px', height = '65px')\n",
        " grid [2,0] = create_expanded_button(button_style = \"Danger\", width = '100px')\n",
        " grid [3,0] = create_expanded_button(width = '100px',  height= '65px')\n",
        " grid [4,0] = create_expanded_button(button_style = \"Danger\", width = '100px') \n",
        " return grid\n",
        "\n",
        "def create_7b_grid(): #Side Columns\n",
        " grid = GridspecLayout(2, 1, width='54px')\n",
        " grid[0,0] = create_expanded_button(height=\"150px\", width=\"50px\", button_style=\"Danger\")\n",
        " grid[1,0] = create_expanded_button(height=\"150px\", width=\"50px\", button_style=\"Danger\")\n",
        " return grid\n",
        "\n",
        "x = create_7b_grid() \n",
        "y = create_7_grid()\n",
        "z= create_7b_grid()\n",
        "display(widgets.HBox([x,y,z]))\n",
        "\n",
        "#Value Entry\n",
        "def cbi(): #Create Bounded Int\n",
        "  return widgets.BoundedIntText(min = 0, max = 1, layout=Layout(height=\"auto\", width=\"50px\"))\n",
        "def create_value_grid():\n",
        "  grid = GridspecLayout(2,8, width = '500px')\n",
        "  for i in range (7):\n",
        "    grid[1,i] = cbi()\n",
        "  i = 0\n",
        "  for letter in  reversed(['a','b','c','d','e','f','g']):\n",
        "    grid[0,i] = Button(description=letter, button_style = 'info',layout=Layout(height=\"auto\", width=\"50px\"))\n",
        "    i += 1\n",
        "  grid[1,7] = Button(description = \"Show\", button_style = 'primary',layout=Layout(height=\"auto\", width=\"100px\"))\n",
        "  return grid\n",
        "value_list = create_value_grid()\n",
        "def update_seven(self):\n",
        "  if(value_list[1,6].value == 1):\n",
        "    y[0,0].button_style = ''#a\n",
        "  else:\n",
        "    y[0,0].button_style = 'Danger'\n",
        "\n",
        "  #b\n",
        "  if(value_list[1,5].value == 1):\n",
        "    z[0,0].button_style = ''\n",
        "  else:\n",
        "    z[0,0].button_style = 'Danger'\n",
        "  #c\n",
        "  if(value_list[1,4].value == 1):\n",
        "    z[1,0].button_style = ''\n",
        "  else:\n",
        "    z[1,0].button_style = 'Danger'\n",
        "  #d\n",
        "  if(value_list[1,3].value == 1):\n",
        "    y[4,0].button_style = ''\n",
        "  else:\n",
        "    y[4,0].button_style = 'Danger'\n",
        "  #e\n",
        "  if(value_list[1,2].value == 1):\n",
        "    x[1,0].button_style = ''\n",
        "  else:\n",
        "    x[1,0].button_style = 'Danger'\n",
        "  #f\n",
        "  if(value_list[1,1].value == 1):\n",
        "    x[0,0].button_style = ''\n",
        "  else:\n",
        "    x[0,0].button_style = 'Danger'\n",
        "  #g\n",
        "  if(value_list[1,0].value == 1):\n",
        "    y[2,0].button_style = ''\n",
        "  else:\n",
        "    y[2,0].button_style = 'Danger'\n",
        "value_list[1,7].on_click(update_seven)\n",
        "display(value_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "9-Nmw1-xZGGs"
      },
      "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": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "#@title vcd2dataframe\n",
        "def vcd2dataframe(vcd_file):\n",
        "  with open(vcd_file, \"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",
        "      # print(signals)\n",
        "      # print(symbols)\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",
        "                  # print(line)\n",
        "                  if words[0][1] == \"x\":\n",
        "                      value = 0\n",
        "                  else:\n",
        "                      try:\n",
        "                          value = int(words[0][1:],2)\n",
        "\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",
        "        # print(length_df)\n",
        "      for i in dataframe:\n",
        "        if len(dataframe[i]) < length_df:\n",
        "          dataframe[i].append(dataframe[i][-1])\n",
        "  return dataframe\n",
        "    # print(signals)\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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "#@title dataframe to wavedrom\n",
        "def df2wd(filename):\n",
        "    dataframe = vcd2dataframe(\"/content/tmp_code/logs/vlt_dump.vcd\")\n",
        "    string_list = []\n",
        "    name_list = []\n",
        "    starting_value = 4\n",
        "    for i in dataframe:\n",
        "        value = \"\"\n",
        "        value_str = \"\"\n",
        "        last_value = \"\"\n",
        "        for j in dataframe[i]:\n",
        "            value_list = dataframe[i]\n",
        "            if last_value == str(j):\n",
        "                value = \".\"\n",
        "            else:\n",
        "                if int(j) > 2:\n",
        "                    x = starting_value\n",
        "                    starting_value += 1\n",
        "                    if starting_value >= 9:\n",
        "                        starting_value = 4\n",
        "                    value = str(x)\n",
        "                else:\n",
        "                    value = str(j)\n",
        "                last_value = str(j)\n",
        "            value_str = value_str + value\n",
        "        string_list.append(value_str)\n",
        "        name_list.append(i)\n",
        "\n",
        "    wavedrom_format = \"\"\"{ signal : [\"\"\"\n",
        "    for i in range(len(string_list)):\n",
        "        if name_list[i] == \"clk\":\n",
        "            new_line = (\n",
        "                \"\"\"{ name: \"clk\",  wave: \"p\"\"\"\n",
        "                + \".\" * (-1 + len(value_str))\n",
        "                + \"\"\"\\\", period: 2 },\"\"\"\n",
        "                + f\"\\n\"\n",
        "            )\n",
        "        elif max(dataframe[name_list[i]]) > 1:\n",
        "            int_list = dataframe[name_list[i]]\n",
        "            new_string_list = string_list[i]\n",
        "            int_string = \"\"\n",
        "            current_value = \"\"\n",
        "            last_value = \"\"\n",
        "            # Fix String List\n",
        "            new_string_list =  new_string_list.replace(\"0\", \"2\")\n",
        "            new_string_list = new_string_list.replace(\"1\", \"3\")\n",
        "            # Create a Data Set\n",
        "            for j in int_list:\n",
        "                current_value = j\n",
        "                if current_value == last_value:\n",
        "                    pass\n",
        "                else:\n",
        "                    int_string += str(current_value) + \" \"\n",
        "                last_value = current_value\n",
        "            new_line = (\n",
        "                '{ name: \"'\n",
        "                + name_list[i]\n",
        "                + \"\"\"\\\",  wave: \\\"\"\"\"\n",
        "                + new_string_list\n",
        "                + \"\"\"\\\", data:\\\" \"\"\"\n",
        "                + int_string\n",
        "                + \"\"\" \\\" },\"\"\"\n",
        "                + f\"\\n\"\n",
        "            )\n",
        "        else:\n",
        "            new_line = (\n",
        "                \"\"\"{ name: \\\"\"\"\"\n",
        "                + name_list[i]\n",
        "                + \"\"\" \\\",  wave: \\\"\"\"\"\n",
        "                + string_list[i]\n",
        "                + \"\"\"\\\" },\"\"\"\n",
        "                + f\"\\n\"\n",
        "            )\n",
        "        wavedrom_format += new_line\n",
        "    wavedrom_format += \"\"\"\n",
        "    ]}\n",
        "\"\"\"\n",
        "    filename = \"/content/tmp_code/\" + filename + \".txt\"\n",
        "    with open(filename, \"w\") as f:\n",
        "        f.write(wavedrom_format)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "#@title Install Extension\n",
        "!pip install --upgrade git+https://github.com/anon36424/nb_js_diagrammers.git\n",
        "%load_ext nb_js_diagrammers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tGwsq0_EvLO_"
      },
      "source": [
        "\n",
        "## How the Seven Segment Display Works\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u8A2ZyBixMeH"
      },
      "source": [
        "<br>\n",
        "\n",
        "![picture](https://raw.githubusercontent.com/anon36424/digital_design_colab/main/SevenSegment/media/display.jpg)  \n",
        "\n",
        "Seven Segment displays are a commonly used type of display that consist of 7 separate LED segments that can be turned on in different combinations to produce numbers and letters.\n",
        "\n",
        "![picture](https://raw.githubusercontent.com/anon36424/digital_design_colab/main/SevenSegment/media/segments.png)  \n",
        "\n",
        "<br>\n",
        "\n",
        "Each segment of the display is controlled by a different a signal which will be referred to as segment `a` through segment `g` as shown above. Using different combinations of the seven signals, you can display numbers between `0` and `9`, and letters from `A` to `F`. The 8th signal that gets sent to the display is for the dot.  \n",
        "\n",
        "<br>\n",
        "\n",
        "![picture](https://raw.githubusercontent.com/anon36424/digital_design_colab/main/SevenSegment/media/hex_segments.png)  \n",
        "\n",
        "\n",
        "\n",
        "So how exactly does this work? To keep it simple, because the LED segments share a common cathode, there needs to be a voltage drop from anode to cathode. This means that to turn on a signal, give it a value of `0` and to turn it off give it a value of `1`.\n",
        "\n",
        "Experiment with the widget below and then fill in all the values for the 16 Hex Values.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "FcsgxBTmCuXn"
      },
      "outputs": [],
      "source": [
        "#@title Seven Segment Widget\n",
        "\n",
        "display(widgets.HBox([x,y,z]))\n",
        "\n",
        "\n",
        "display(value_list)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "EZdnv3KAWtEt"
      },
      "outputs": [],
      "source": [
        "#@title Seven Segment Decoder\n",
        "#Key\n",
        "seven_segment_decode =[\n",
        " \"1000000\",#0\n",
        " \"1111001\",#1\n",
        " \"0100100\",#2\n",
        " \"0110000\",#3\n",
        " \"0011001\",#4\n",
        " \"0010010\",#5\n",
        " \"0000010\",#6\n",
        " \"1111000\",#7\n",
        " \"0000000\",#8\n",
        " \"0010000\",#9\n",
        " \"0001000\",#A\n",
        " \"0000011\",#B\n",
        " \"1000110\", #C\n",
        " \"0100001\",#D\n",
        " \"0000110\", #E\n",
        " \"0001110\"#F\n",
        "]\n",
        "\n",
        "def cbi(): #Create Bounded Int\n",
        "  return widgets.BoundedIntText(min = 0, max = 1, layout=Layout(height=\"60px\", width=\"75px\"))\n",
        "def create_expanded_button(description=\"\", button_style='info', width='150px', height='50px'):\n",
        "    return Button(description=description, button_style=button_style, layout=Layout(height=height, width=width))\n",
        "#first row\n",
        "\n",
        "def create_expanded_button_primary(description=\"\", button_style='Primary', width='150px', height='50px'):\n",
        "    return Button(description=description, button_style=button_style, layout=Layout(height=height, width=width))\n",
        "#first row\n",
        "first_row = GridspecLayout(1,3, width = '1200px')\n",
        "first_row[0,0] = create_expanded_button_primary(description = \"Hex\")\n",
        "first_row[0,1] = create_expanded_button_primary(description = \"Input\", width = '320px')\n",
        "first_row[0,2] = create_expanded_button_primary(description = \"Output\", width = '710px')\n",
        "\n",
        "#second row\n",
        "#first row\n",
        "second_row = GridspecLayout(1,3, width = '1200px')\n",
        "second_row[0,0] = create_expanded_button(description = \"Character\")\n",
        "second_row[0,1] = create_expanded_button(description = \"Binary\", width = '320px')\n",
        "second_row[0,2] = create_expanded_button(description = \"Segment [6:0]\", width = '710px')\n",
        "main_block = GridspecLayout(16,13, width = '1200px')\n",
        "\n",
        "#Third Row\n",
        "\n",
        "third_row = GridspecLayout(1, 13, width = '1200px')\n",
        "descr_list = [\"data[3]\", \"data[2]\", \"data[1]\", \"data[0]\", \"CG\", \"CF\", \"CE\", \"CD\", \"CC\", \"CB\", \"CA\"]\n",
        "third_row[0,0] = create_expanded_button(button_style = \"info\")\n",
        "third_row[0,12] = create_expanded_button(button_style = \"\")\n",
        "\n",
        "i = 1\n",
        "for l in descr_list:\n",
        "  third_row[0,i] = create_expanded_button(description = l, width = \"75px\")\n",
        "  i += 1\n",
        "\n",
        "def check_seven(self):\n",
        "  answer_value = ''\n",
        "  for i in range(5,12):\n",
        "    answer_value += str(main_block[self.row, i].value)\n",
        "  if(answer_value == seven_segment_decode[self.row]):\n",
        "    print(\"Correct\")\n",
        "    self.button_style = \"Success\"\n",
        "    self.description = \"Correct\"\n",
        "  else:\n",
        "    self.button_style = \"Danger\"\n",
        "    self.description = \"Incorrect, Try Again\"\n",
        "  print(answer_value + \" \" + seven_segment_decode[self.row])\n",
        "\n",
        "\n",
        "#First Column\n",
        "for i in range(16):\n",
        "  main_block[i,0] = create_expanded_button(description=str(hex(i))[-1])\n",
        "#Create a binary pattern\n",
        "x = 8\n",
        "for j in range(1,5):\n",
        "  z = 0\n",
        "  binary_v = '0'\n",
        "  for i in range(16):\n",
        "    z += 1\n",
        "    main_block[i,j] = create_expanded_button(description = binary_v, button_style = \"\", width = '75px')\n",
        "    if (z == x) and binary_v == '1':\n",
        "      binary_v = '0'\n",
        "      z = 0\n",
        "    elif (z == x) and binary_v =='0':\n",
        "      binary_v = '1'\n",
        "      z= 0\n",
        "  x = x/2\n",
        "for j in range (5,12):\n",
        "  for i in range (16):\n",
        "    main_block[i,j] = cbi()\n",
        "for i in range (16):\n",
        "  main_block[i,12] = create_expanded_button(description = \"Check\", button_style = 'Warning')\n",
        "  setattr(main_block[i,12], 'row', i)\n",
        "  main_block[i,12].on_click(check_seven)\n",
        "display(first_row)\n",
        "display(second_row)\n",
        "display(third_row)\n",
        "display(main_block)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mj6UYRUWxXDC"
      },
      "source": [
        "### Driving an Anode"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qGv0sWh5Dw0y"
      },
      "source": [
        "Anodes are what determines which of the 4 Seven Segment displays are lit. If the anode is `0` for a particular panel it will be on. So if `0000` is driven all the panels will be on. \n",
        "<br>\n",
        "\n",
        "![picture](https://raw.githubusercontent.com/anon36424/digital_design_colab/main/SevenSegment/media/cathode.jpg)  \n",
        "\n",
        "<br>\n",
        "\n",
        "The problem with the anodes is that they are all driven by the same exact wires to determine what segments are on. As a result, they will naturally show the same image on all four digits.   \n",
        "\n",
        "To resolve this, seven segment displays actually are often programmed to quickly switch between the four different displays faster than the human eye can distinguish, so that the 4 displays appear to show different images at the same time when in reality they are displayed one at a time.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UUCB26A_vQTz"
      },
      "source": [
        "## The Lab"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gBQwUqMtGjXs"
      },
      "source": [
        "### Seven Segment Module\n",
        "\n",
        "In this lab, given a binary value, display the equivalent Hexadecimal character.\n",
        "So if we input `0000` we want to output `0` and if we input `1100` we want to output `A`.  \n",
        "\n",
        "| Module Name: |seven_segment|||\n",
        "| ----------- | ----------- |--|--|\n",
        "| Port Name      | Direction       |Width|Function|\n",
        "| data\t|Input \t|4| data to display|\n",
        "|segment \t|Output \t|7 | Cathode signals to the display|\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "N2eL6OBHveTY"
      },
      "outputs": [],
      "source": [
        "#@title \n",
        "createSimulationWorkSpace(\"/tmp_code/seven_segment\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "on4zTTY9qxST"
      },
      "outputs": [],
      "source": [
        "#@title Verilator TestBench\n",
        "!verilator --cc seven_segment.sv \n",
        "!verilator -Wall --trace -cc seven_segment.sv --exe tb_seven_segment.cpp\n",
        "!make -C obj_dir -f Vseven_segment.mk Vseven_segment > /dev/null\n",
        "!./obj_dir/Vseven_segment"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "NlsoJ0U7i_SI"
      },
      "outputs": [],
      "source": [
        "#@title Create WaveDrom\n",
        "df2wd(\"ss\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "F_51UVEcjA3e"
      },
      "outputs": [],
      "source": [
        "#@title Show WaveDrom\n",
        "%%wavedrom_magic -h 200 -o /content/tmp_code/ss.txt\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RxOBC0JwLA9l"
      },
      "source": [
        "### The Top Module\n",
        "\n",
        "\n",
        "\n",
        "| Module Name: |seven_segment_top|||\n",
        "| ----------- | ----------- |--|--|\n",
        "| Port Name      | Direction       |Width|Function|\n",
        "| sw\t|Input \t|4| Input to drive seven-segment decoder |\n",
        "| btnc\t|Input \t|1| Will turn on digit point |\n",
        "| segment\t|Output \t|8 | Cathode signals to the display including the point|\n",
        "| anode\t|Output \t|4 | Anode signals for each of the four digits on the display|  \n",
        "\n",
        "<br>  \n",
        "This figure shows what is happening in the module. \n",
        "<br>  <br>\n",
        "\n",
        "![picture](https://raw.githubusercontent.com/anon36424/digital_design_colab/main/SevenSegment/media/seven_top.jpg)   \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "gc4uy90jPP6n"
      },
      "outputs": [],
      "source": [
        "#@title\n",
        "\n",
        "createSimulationWorkSpace(\"/tmp_code/seven_segment_top\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MiLS6w9PdTLz"
      },
      "outputs": [],
      "source": [
        "#@title Generate an XDC File\n",
        "%%bash -c 'cat > /content/tmp_code/xdc.xdc'\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",
        "##7 Segment Display\n",
        "set_property -dict { PACKAGE_PIN W7   IOSTANDARD LVCMOS33 } [get_ports {segment[0]}]\n",
        "set_property -dict { PACKAGE_PIN W6   IOSTANDARD LVCMOS33 } [get_ports {segment[1]}]\n",
        "set_property -dict { PACKAGE_PIN U8   IOSTANDARD LVCMOS33 } [get_ports {segment[2]}]\n",
        "set_property -dict { PACKAGE_PIN V8   IOSTANDARD LVCMOS33 } [get_ports {segment[3]}]\n",
        "set_property -dict { PACKAGE_PIN U5   IOSTANDARD LVCMOS33 } [get_ports {segment[4]}]\n",
        "set_property -dict { PACKAGE_PIN V5   IOSTANDARD LVCMOS33 } [get_ports {segment[5]}]\n",
        "set_property -dict { PACKAGE_PIN U7   IOSTANDARD LVCMOS33 } [get_ports {segment[6]}]\n",
        "\n",
        "#Anodes \n",
        "\n",
        "set_property -dict { PACKAGE_PIN U2   IOSTANDARD LVCMOS33 } [get_ports {anode[0]}]\n",
        "set_property -dict { PACKAGE_PIN U4   IOSTANDARD LVCMOS33 } [get_ports {anode[1]}]\n",
        "set_property -dict { PACKAGE_PIN V4   IOSTANDARD LVCMOS33 } [get_ports {anode[2]}]\n",
        "set_property -dict { PACKAGE_PIN W4   IOSTANDARD LVCMOS33 } [get_ports {anode[3]}]\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": "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\n",
        "cd 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",
        "\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 := seven_segment_top\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",
        "mkdir -p /content/Seven_Segment\n",
        "cd /content/tmp_code\n",
        "cp xdc.xdc /content/Seven_Segment/xdc.xdc\n",
        "cp Makefile /content/Seven_Segment/Makefile\n",
        "cp *.sv /content/Seven_Segment/\n",
        "conda activate xc7\n",
        "cd /content/Seven_Segment\n",
        "conda activate xc7\n",
        "make 2> ./error.log 1>./compile.log\n",
        "cp ./build/basys3/*.bit ./seven_segment_top.bit"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jkKm3WaizMYC"
      },
      "source": [
        "## Testing it on the board"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nTB0ZZKMdC25"
      },
      "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/seven_segment_top.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 seven_segment_top.bit\n",
        "exit\"\"\"\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HcTNQK0WbSN9"
      },
      "outputs": [],
      "source": [
        "#@title Make Zip\n",
        "%%bash\n",
        "cd /content\n",
        "mv /content/Seven_Segment/build/basys3/*.bit ./\n",
        "zip seven_segment.zip *.bit *.cfg"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "IQd2K_jAwbFS",
        "EzO5bK_Awg2q"
      ],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.10.6 64-bit",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.6"
    },
    "vscode": {
      "interpreter": {
        "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}