Adjusted io types for communication between control unit and driver. Also started testbench

Reviewed-on: #11
Reviewed-by: Adam <admag2001@gmail.com>

scripts/build_env.py

@@ -5,57 +5,61 @@ import subprocess
 def getCfFileId(std: str):
     return "08" if std == "08" else "93" ## Weird behaviour from GHDL, but all vhdl versions besides 08 have [...]93.cf
 
-def ghdlEnvExists(std, relativePath="work"):
+def ghdlEnvExists(std, lib):
     ## Check if work exists
     try:
-        os.lstat(relativePath)
+        os.lstat("work")
     except:
         return False
     ## Check that work is writable
-    if not os.access(relativePath, os.W_OK):
-        print(f"{relativePath} is write-protected, please acquire correct permissions")
+    if not os.access("work", os.W_OK):
+        print("work is write-protected, please acquire correct permissions")
         return False
     cfFileExists = False
-    filesInWork = os.listdir(relativePath)
+    filesInWork = os.listdir("work")
     cfFileId = getCfFileId(std)
     for file in filesInWork:
-        if ".cf" in file and cfFileId in file:
+        if ".cf" in file and lib in file and cfFileId in file:
             cfFileExists = True
     if not cfFileExists:
         return False
     ## Nothing bad, continue
     return True
 
-def createBuildEnv(std: str):
-    if ghdlEnvExists(std=std):
+def createBuildEnv(std: str, lib: str):
+    if ghdlEnvExists(std=std, lib=lib):
         print("Build environment already exists, exiting...")
         return -1
     ## Create build env
     print("Initializing GHDL project in current directory...")
     os.makedirs("work",exist_ok=True)
-    addAllVHDLFiles(std=std, init=True)
+    addAllVHDLFiles(std=std, lib=lib, init=True)
     return 0
 
-def addAllVHDLFiles(std: str, init=False):
+def addAllVHDLFiles(std: str, lib: str, init=False):
     ## Ensure everything is ready for adding files 
     ## (init exception to avoid one if-case in ghdlEnvExists)
-    if not ghdlEnvExists(std=std) and not init:
+    if not ghdlEnvExists(std=std, lib=lib) and not init:
        return -1
     vhdlFiles = []
     currentlyAdded = []
+    absWorkDir = os.path.join(os.getcwd(), "work")
     cfFileId = getCfFileId(std)
     ## Find already present files
     if not init:
-        cfFileName = list(filter(lambda x: ".cf" in x and cfFileId in x, os.listdir("work")))[0]
-        cfFilePath = os.path.join(os.getcwd(),f"work/{cfFileName}")
+        cfFileName = list(filter(lambda x: ".cf" in x and lib in x and cfFileId in x, os.listdir(absWorkDir)))[0]
+        cfFilePath = os.path.join(absWorkDir,cfFileName)
         currentlyAdded = getCurrentlyAddedFiles(cfFilePath)
+        print(currentlyAdded)
     ## Add files not added
     for file in os.listdir():
+        print(file)
+        print(currentlyAdded, file, file not in currentlyAdded)
         if ".vhd" in file and file not in currentlyAdded:
-            vhdlFiles.append(file)
+            vhdlFiles.append(os.path.join(os.getcwd(), file))
     if len(vhdlFiles) > 0:
         print(f"Detected new files. Adding {vhdlFiles}")
-        command = ["ghdl", "-i", "--workdir=work", "--work=work", f"--std={std}"] + vhdlFiles
+        command = ["ghdl", "-i", "--workdir=work", f"--work={lib}", f"--std={std}"] + vhdlFiles
         subprocess.run(command)
     return 0
 
@@ -64,5 +68,5 @@ def getCurrentlyAddedFiles(cfFilePath:str):
     lines = f.readlines()
     f.close()
     fileLines = filter(lambda x: "file" in x, lines) 
-    files = map(lambda x: split("\" \"",x)[1], fileLines)
+    files = map(lambda x: split("\"",x)[1], fileLines)
     return list(files)

scripts/elab.py

@@ -1,27 +1,35 @@
 import os
 import subprocess
 import build_env
+from typing import List
 
-def elabDesign(topDef: str, arch: str, lib: str, std: str):
+
+def generateIncludesForGHDL(includes: List[str]):
+    cmd = []
+    for inc in includes:
+        cmd.append(f"-P{os.path.join(os.getcwd(), f"{inc}/work")}")
+    return cmd
+
+def elabDesign(topDef: str, arch: str, lib: str, std: str, includes: List[str]):
     ## Add all source files present in pwd
-    if build_env.addAllVHDLFiles(std) == -1:
+    if build_env.addAllVHDLFiles(std, lib) == -1:
         print("Adding files failed. GHDL Build environment may be broken...")
         return -1
+    incs = generateIncludesForGHDL(includes)
     command = [
-        "ghdl", "-m", f"--workdir={lib}", f"--work={lib}", f"--std={std}",
-        "-o", f"{lib}/{topDef}-{arch}", f"{lib}.{topDef}", f"{arch}"]
+        "ghdl", "-m", "--workdir=work", f"--work={lib}", f"--std={std}"] + incs + ["-o", f"work/{topDef}-{arch}", f"work.{topDef}", f"{arch}"]
     subprocess.run(command)
 
-def runDesign(topDef: str, arch: str, lib: str, std: str):
+def runDesign(topDef: str, arch: str, lib: str, std: str, includes):
     ## elaborate first, then run
-    if elabDesign(topDef, arch, lib, std) == -1:
+    if elabDesign(topDef, arch, lib, std, includes) == -1:
         print("Elaboration failed...")
         return -1
     os.makedirs("wave",exist_ok=True)
     wavePath = os.path.join(os.getcwd(), "wave")
+    incs = generateIncludesForGHDL(includes)
     command = [ ## may add -v for verbose
-        "ghdl", "--elab-run", f"--workdir={lib}", f"--work={lib}", f"--std={std}",
-        "-o", f"{lib}/{topDef}-{arch}", f"{topDef}", f"{arch}", 
+        "ghdl", "--elab-run", f"--workdir=work", f"--work={lib}", f"--std={std}"] + incs + ["-o", f"work/{topDef}-{arch}", f"{topDef}", f"{arch}", 
         f"--wave=wave/{topDef}-{arch}.ghw" ##, "--read-wave-opt=<See"
             ]
     subprocess.run(command)

scripts/gantry.py

@@ -1,7 +1,11 @@
 import typer
 import elab as elaborate
 import build_env
+from typing import List, Optional
 from typing_extensions import Annotated
+import subprocess
+
+gantry_install_path = "/home/thesis2/exjobb-public/scripts" 
 
 app = typer.Typer()
 
@@ -17,32 +21,65 @@ def complete_vhdl_ver():
 
 @software.command(help="Initializes the GHDL build environment in a library named \"work\". Adds all files ending in \".vhd\" to the project")
 def init(
-        std: Annotated[str, typer.Option(help="Which VHDL standard to use. 87, 93, 93c, 00, 02 or 08", autocompletion=complete_vhdl_ver)] = "93c"
+        std: Annotated[str, typer.Option(help="Which VHDL standard to use. 87, 93, 93c, 00, 02 or 08", autocompletion=complete_vhdl_ver)] = "93c",
+        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from")] = "defaultLib",
         ):
-    return build_env.createBuildEnv(std)
+    return build_env.createBuildEnv(std, library)
 
 
 @software.command(help="Runs analysis and elaboration on the provided top definition and architecture using GHDL. Automatically adds new files not present in the project")
 def elab(
         topdef: Annotated[str, typer.Argument(help="Top Definition entity to synthesize")] = "",
         arch: Annotated[str, typer.Argument(help="Architecture to synthesize within the top definition provided")] = "",
-        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from")] = "work",
+        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from")] = "defaultLib",
+        includes: Annotated[Optional[List[str]], typer.Option("--include", "-i", help="Which libraries to include in compile")] = None,
         std: Annotated[str, typer.Option(help="Which VHDL standard to use. 87, 93, 93c, 00, 02 or 08", autocompletion=complete_vhdl_ver)] = "93c"
         ):
-    print(f"Elaborating {topdef} with arch {arch} in library {library}. VHDL {std}")
-    return elaborate.elabDesign(topdef, arch, library, std)
+    print(f"Elaborating {topdef} with arch {arch} in library {library}. VHDL {std}.")
+    if includes is not None:
+        print(f"Including libraries: {includes}")
+    else:
+        includes = []
+    return elaborate.elabDesign(topdef, arch, library, std, includes)
 
 @software.command(help="Simulates elaborated design in GHDL and views waves in gtkwave. Automatically runs `gantry elab` on the same top def and arch.")
 def run(
         topdef: Annotated[str, typer.Argument(help="Top Definition entity to synthesize")] = "",
         arch: Annotated[str, typer.Argument(help="Architecture to synthesize within the top definition provided")] = "",
-        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from")] = "work",
+        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from")] = "defaultLib",
+        includes: Annotated[Optional[List[str]], typer.Option("--include", "-i", help="Which libraries to include in compile")] = None,
         std: Annotated[str, typer.Option(help="Which VHDL standard to use. 87, 93, 93c, 00, 02 or 08", autocompletion=complete_vhdl_ver)] = "93c"
         ):
     print(f"Running (and synthesizing if needed) {topdef} with arch {arch} in library {library}. VHDL {std}")
-    return elaborate.runDesign(topdef, arch, library, std)
+    if includes is not None:
+        print(f"Including libraries: {includes}")
+    else:
+        includes = []
+    return elaborate.runDesign(topdef, arch, library, std, includes)
 
-@hardware.command()
+@hardware.command(help="Synthesizes the provided top level design using NXPython. Make sure you run this with NXPython.")
+def synth(
+        topdef: Annotated[str, typer.Argument(help="Top Definition entity to synthesize")] = "",
+        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from, defaults to \"work\"")] = "defaultLib"
+        ):
+    proc = subprocess.run(["source_and_run.sh", f"{gantry_install_path}/nxp_script.py", "synthDesign", library, topdef])
+
+@hardware.command(help="Places the provided top level design using NXPython. Make sure you run this with NXPython.")
+def place(
+        topdef: Annotated[str, typer.Argument(help="Top Definition entity to synthesize")] = "",
+        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from, defaults to \"work\"")] = "defaultLib"
+        ):
+    proc = subprocess.run(["source_and_run.sh", f"{gantry_install_path}/nxp_script.py", "placeDesign", library, topdef])
+
+
+@hardware.command(help="Routes the provided top level design using NXPython. Make sure you run this with NXPython.")
+def route(
+        topdef: Annotated[str, typer.Argument(help="Top Definition entity to synthesize")] = "",
+        library: Annotated[str, typer.Option("--library", "-l", help="Library to compile from, defaults to \"work\"")] = "defaultLib"
+        ):
+    proc = subprocess.run(["source_and_run.sh", f"{gantry_install_path}/nxp_script.py", "routeDesign", library, topdef])
+
+@hardware.command(help="")
 def build():
     print("Build!")
 

scripts/install_gantry.sh

@@ -1,6 +1,9 @@
 #!/bin/bash
 
 PWD=$(pwd)
+ESCAPED_PWD=$(printf '%s\n' "$PWD" | sed -e 's/[\/&]/\\&/g')
+echo $ESCAPED_PWD
+sed -i "0,/gantry_install_path =\"\"/s/gantry_install_path = \"\"/gantry_install_path = \"$ESCAPED_PWD\"/" gantry.py
 printf "#!/bin/bash \n$PWD/bin/python3 $PWD/gantry.py \$@" > "$PWD/gantry"
 chmod +x "$PWD/gantry"
 

scripts/nxp_script.py

@@ -0,0 +1,81 @@
+import os
+import subprocess
+import build_env
+import sys
+import traceback
+from nxpython import *
+
+artifact_path = ""
+
+# Evaluate whether we want the user to provide a selection of files
+def makeProject(library: str, project_name: str, path):
+    # Create an Impulse project and add all VHDL files to it
+    print(path)
+    #Createproject enters the implicitly created directory
+    print(f"Creating project \'{project_name}\'\n")
+    getProject().setTopCellName(library, project_name)
+    getProject().setVariantName("NG-MEDIUM", "LGA-625")
+    getProject().addParameters({})
+    print(path)
+    listed = list(os.listdir(path))
+    files = list(filter(lambda x: ".vhdl" in x or ".vhd" in x or ".v\0" in x, listed)) # Find VHDL and Verilog files
+    files = list(map(lambda x: os.path.join(path, x), files))
+    print(f"Adding the following files to project: {files}\n")
+    getProject().addFiles(files)
+    print("Saving project")
+    getProject().save(os.path.join(artifact_path, project_name + ".nym"))
+    return 0
+
+# Do we want the user to specify how far they want to progress wach step? What does the number mean?
+def synthDesign(library: str, project_name: str, path):
+    # Synthesize the design of the project of the provided `project_name`
+    print("Starting synthesis\n")
+    try:
+        nymFile = os.path.join(artifact_path, project_name + ".nym")
+        os.lstat(nymFile)
+        getProject().loadNative(nymFile)
+    except:
+        print("No existing project found, creating new project\n")
+        makeProject(library, project_name, path)
+        getProject().loadNative(os.path.join(artifact_path, project_name + ".nym"))
+    getProject().progress("Synthesize", 3)
+    getProject().save(os.path.join(artifact_path,  project_name + "-synth.nym"))
+    return 0
+
+def placeDesign(library: str, project_name: str, path):
+    # Place the given design. Will use a previously synthesized project if available, otherwise one will be created. 
+    print("Starting place\n")
+    try:
+        nymFile = os.path.join(artifact_path, project_name + "-synth.nym")
+        os.lstat(nymFile)
+        getProject().load(nymFile)
+    except:
+        print("No existing synthesis found, entering synthesis stage\n")
+        synthDesign(library, project_name, path)
+        getProject().load(os.path.join(artifact_path, project_name + "-synth.nym"))
+    getProject().progress("Place", 5)
+    getProject().save(os.path.join(artifact_path, project_name + "-place.nym"))
+
+def routeDesign(library: str, project_name: str, path):
+    # Route the given design. Will use a previously placed project if available, otherwise one will be created.
+    print("Starting route\n")
+    try:
+        nymFile = os.path.join(artifact_path, project_name + "-place.nym")
+        os.lstat(nymFile)
+        getProject().load(nymFile)
+    except:
+        print("No existing place found, entering place stage\n")
+        placeDesign(library, project_name, path)
+        getProject().load(os.path.join(artifact_path, project_name + "-place.nym"))
+    getProject().progress("Route", 3)
+    getProject().save(os.path.join(artifact_path, project_name + "-route.nym"))
+
+
+if __name__ == "__main__":
+    path = os.getcwd()
+    artifact_path = os.path.join(path, "syn")
+    print(f"Calling {sys.argv[1]}() with arguments {sys.argv[2]}, {sys.argv[3]}")
+    createProject(artifact_path)
+    globals()[sys.argv[1]](sys.argv[2], sys.argv[3], path)
+    getProject().createAnalyzer()
+    getProject().getAnalyzer().launch(conditions="worstcase", maximumSlack=0, searchPathsLimit=10, synthesisMode=False)

scripts/source_and_run.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+source /gsl/cad/modules/init/bash
+
+module add /gsl/cad/modules/modulefiles/nanoxplore/nxdesignsuite/24.3.0.0
+nxpython $@