| #!/usr/bin/env python3 |
| # |
| #-------------------------------------------------------- |
| # Project Manager GUI. |
| # |
| # This is a Python tkinter script that handles local |
| # project management. Much of this involves the |
| # running of ng-spice for characterization, allowing |
| # the user to determine where a circuit is failing |
| # characterization; and when the design passes local |
| # characterization, it may be submitted to the |
| # marketplace for official characterization. |
| # |
| #-------------------------------------------------------- |
| # Written by Tim Edwards |
| # efabless, inc. |
| # September 9, 2016 |
| # Version 1.0 |
| #-------------------------------------------------------- |
| |
| import io |
| import re |
| import os |
| import sys |
| import copy |
| import json |
| import time |
| import signal |
| import select |
| import datetime |
| import contextlib |
| import subprocess |
| import faulthandler |
| |
| import tkinter |
| from tkinter import ttk |
| from tkinter import filedialog |
| |
| import tksimpledialog |
| import tooltip |
| from consoletext import ConsoleText |
| from helpwindow import HelpWindow |
| from failreport import FailReport |
| from textreport import TextReport |
| from editparam import EditParam |
| from settings import Settings |
| from simhints import SimHints |
| |
| # User preferences file (if it exists) |
| prefsfile = '~/design/.profile/prefs.json' |
| |
| # Application path (path where this script is located) |
| apps_path = os.path.realpath(os.path.dirname(__file__)) |
| |
| #------------------------------------------------------ |
| # Simple dialog for confirming quit or upload |
| #------------------------------------------------------ |
| |
| class ConfirmDialog(tksimpledialog.Dialog): |
| def body(self, master, warning, seed): |
| ttk.Label(master, text=warning, wraplength=500).grid(row = 0, columnspan = 2, sticky = 'wns') |
| return self |
| |
| def apply(self): |
| return 'okay' |
| |
| #------------------------------------------------------ |
| # Simple dialog with no "OK" button (can only cancel) |
| #------------------------------------------------------ |
| |
| class PuntDialog(tksimpledialog.Dialog): |
| def body(self, master, warning, seed): |
| if warning: |
| ttk.Label(master, text=warning, wraplength=500).grid(row = 0, columnspan = 2, sticky = 'wns') |
| return self |
| |
| def buttonbox(self): |
| # Add button box with "Cancel" only. |
| box = ttk.Frame(self.obox) |
| w = ttk.Button(box, text="Cancel", width=10, command=self.cancel) |
| w.pack(side='left', padx=5, pady=5) |
| self.bind("<Escape>", self.cancel) |
| box.pack(fill='x', expand='true') |
| |
| def apply(self): |
| return 'okay' |
| |
| #------------------------------------------------------ |
| # Main class for this application |
| #------------------------------------------------------ |
| |
| class CACECharacterize(ttk.Frame): |
| """local characterization GUI.""" |
| |
| def __init__(self, parent, *args, **kwargs): |
| ttk.Frame.__init__(self, parent, *args, **kwargs) |
| self.root = parent |
| self.init_gui() |
| parent.protocol("WM_DELETE_WINDOW", self.on_quit) |
| |
| def on_quit(self): |
| """Exits program.""" |
| if not self.check_saved(): |
| warning = 'Warning: Simulation results have not been saved.' |
| confirm = ConfirmDialog(self, warning).result |
| if not confirm == 'okay': |
| print('Quit canceled.') |
| return |
| if self.logfile: |
| self.logfile.close() |
| quit() |
| |
| def on_mousewheel(self, event): |
| if event.num == 5: |
| self.datasheet_viewer.yview_scroll(1, "units") |
| elif event.num == 4: |
| self.datasheet_viewer.yview_scroll(-1, "units") |
| |
| def init_gui(self): |
| """Builds GUI.""" |
| global prefsfile |
| |
| message = [] |
| fontsize = 11 |
| |
| # Read user preferences file, get default font size from it. |
| prefspath = os.path.expanduser(prefsfile) |
| if os.path.exists(prefspath): |
| with open(prefspath, 'r') as f: |
| self.prefs = json.load(f) |
| if 'fontsize' in self.prefs: |
| fontsize = self.prefs['fontsize'] |
| else: |
| self.prefs = {} |
| |
| s = ttk.Style() |
| |
| available_themes = s.theme_names() |
| s.theme_use(available_themes[0]) |
| |
| s.configure('bg.TFrame', background='gray40') |
| s.configure('italic.TLabel', font=('Helvetica', fontsize, 'italic')) |
| s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold italic'), |
| foreground = 'brown', anchor = 'center') |
| s.configure('normal.TLabel', font=('Helvetica', fontsize)) |
| s.configure('red.TLabel', font=('Helvetica', fontsize), foreground = 'red') |
| s.configure('green.TLabel', font=('Helvetica', fontsize), foreground = 'green3') |
| s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue') |
| s.configure('hlight.TLabel', font=('Helvetica', fontsize), background='gray93') |
| s.configure('rhlight.TLabel', font=('Helvetica', fontsize), foreground = 'red', |
| background='gray93') |
| s.configure('ghlight.TLabel', font=('Helvetica', fontsize), foreground = 'green3', |
| background='gray93') |
| s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue') |
| s.configure('blue.TMenubutton', font=('Helvetica', fontsize), foreground = 'blue', |
| border = 3, relief = 'raised') |
| s.configure('normal.TButton', font=('Helvetica', fontsize), |
| border = 3, relief = 'raised') |
| s.configure('red.TButton', font=('Helvetica', fontsize), foreground = 'red', |
| border = 3, relief = 'raised') |
| s.configure('green.TButton', font=('Helvetica', fontsize), foreground = 'green3', |
| border = 3, relief = 'raised') |
| s.configure('hlight.TButton', font=('Helvetica', fontsize), |
| border = 3, relief = 'raised', background='gray93') |
| s.configure('rhlight.TButton', font=('Helvetica', fontsize), foreground = 'red', |
| border = 3, relief = 'raised', background='gray93') |
| s.configure('ghlight.TButton', font=('Helvetica', fontsize), foreground = 'green3', |
| border = 3, relief = 'raised', background='gray93') |
| s.configure('blue.TButton', font=('Helvetica', fontsize), foreground = 'blue', |
| border = 3, relief = 'raised') |
| s.configure('redtitle.TButton', font=('Helvetica', fontsize, 'bold italic'), |
| foreground = 'red', border = 3, relief = 'raised') |
| s.configure('bluetitle.TButton', font=('Helvetica', fontsize, 'bold italic'), |
| foreground = 'blue', border = 3, relief = 'raised') |
| |
| # Create the help window |
| self.help = HelpWindow(self, fontsize = fontsize) |
| |
| with io.StringIO() as buf, contextlib.redirect_stdout(buf): |
| self.help.add_pages_from_file(apps_path + '/characterize_help.txt') |
| message = buf.getvalue() |
| |
| # Set the help display to the first page |
| self.help.page(0) |
| |
| # Create the failure report window |
| self.failreport = FailReport(self, fontsize = fontsize) |
| |
| # LVS results get a text window of results |
| self.textreport = TextReport(self, fontsize = fontsize) |
| |
| # Create the settings window |
| self.settings = Settings(self, fontsize = fontsize, callback = self.callback) |
| |
| # Create the simulation hints window |
| self.simhints = SimHints(self, fontsize = fontsize) |
| |
| # Create the edit parameter window |
| self.editparam = EditParam(self, fontsize = fontsize) |
| |
| # Variables used by option menus and other stuff |
| self.origin = tkinter.StringVar(self) |
| self.cur_project = tkinter.StringVar(self) |
| self.cur_datasheet = "(no selection)" |
| self.datatop = {} |
| self.status = {} |
| self.caceproc = None |
| self.logfile = None |
| |
| # Root window title |
| self.root.title('Characterization') |
| self.root.option_add('*tearOff', 'FALSE') |
| self.pack(side = 'top', fill = 'both', expand = 'true') |
| |
| pane = tkinter.PanedWindow(self, orient = 'vertical', sashrelief='groove', sashwidth=6) |
| pane.pack(side = 'top', fill = 'both', expand = 'true') |
| self.toppane = ttk.Frame(pane) |
| self.botpane = ttk.Frame(pane) |
| |
| # Get username |
| if 'username' in self.prefs: |
| username = self.prefs['username'] |
| else: |
| username = os.environ['USER'] |
| |
| # Label with the user |
| self.toppane.title_frame = ttk.Frame(self.toppane) |
| self.toppane.title_frame.grid(column = 0, row=0, sticky = 'nswe') |
| |
| self.toppane.title_frame.title = ttk.Label(self.toppane.title_frame, text='User:', style = 'red.TLabel') |
| self.toppane.title_frame.user = ttk.Label(self.toppane.title_frame, text=username, style = 'blue.TLabel') |
| |
| self.toppane.title_frame.title.grid(column=0, row=0, ipadx = 5) |
| self.toppane.title_frame.user.grid(column=1, row=0, ipadx = 5) |
| |
| #--------------------------------------------- |
| ttk.Separator(self.toppane, orient='horizontal').grid(column = 0, row = 1, sticky = 'nswe') |
| #--------------------------------------------- |
| |
| self.toppane.title2_frame = ttk.Frame(self.toppane) |
| self.toppane.title2_frame.grid(column = 0, row = 2, sticky = 'nswe') |
| self.toppane.title2_frame.datasheet_label = ttk.Label(self.toppane.title2_frame, text="Datasheet:", |
| style = 'normal.TLabel') |
| self.toppane.title2_frame.datasheet_label.grid(column=0, row=0, ipadx = 5) |
| |
| # New datasheet select button |
| self.toppane.title2_frame.datasheet_select = ttk.Button(self.toppane.title2_frame, |
| text=self.cur_datasheet, style='normal.TButton', command=self.choose_datasheet) |
| self.toppane.title2_frame.datasheet_select.grid(column=1, row=0, ipadx = 5) |
| |
| tooltip.ToolTip(self.toppane.title2_frame.datasheet_select, |
| text = "Select new datasheet file") |
| |
| # Show path to datasheet |
| self.toppane.title2_frame.path_label = ttk.Label(self.toppane.title2_frame, text=self.cur_datasheet, |
| style = 'normal.TLabel') |
| self.toppane.title2_frame.path_label.grid(column=2, row=0, ipadx = 5, padx = 10) |
| |
| # Spacer in middle moves selection button to right |
| self.toppane.title2_frame.sep_label = ttk.Label(self.toppane.title2_frame, text=' ', |
| style = 'normal.TLabel') |
| self.toppane.title2_frame.sep_label.grid(column=3, row=0, ipadx = 5, padx = 10) |
| self.toppane.title2_frame.columnconfigure(3, weight = 1) |
| self.toppane.title2_frame.rowconfigure(0, weight=0) |
| |
| # Selection for origin of netlist |
| self.toppane.title2_frame.origin_label = ttk.Label(self.toppane.title2_frame, |
| text='Netlist from:', style = 'normal.TLabel') |
| self.toppane.title2_frame.origin_label.grid(column=4, row=0, ipadx = 5, padx = 10) |
| |
| self.origin.set('Schematic Capture') |
| self.toppane.title2_frame.origin_select = ttk.OptionMenu(self.toppane.title2_frame, |
| self.origin, 'Schematic Capture', 'Schematic Capture', 'Layout Extracted', |
| style='blue.TMenubutton', command=self.load_results) |
| self.toppane.title2_frame.origin_select.grid(column=5, row=0, ipadx = 5) |
| |
| #--------------------------------------------- |
| ttk.Separator(self.toppane, orient='horizontal').grid(column = 0, row = 3, sticky = 'news') |
| #--------------------------------------------- |
| |
| # Datasheet information goes here when datasheet is loaded. |
| self.mframe = ttk.Frame(self.toppane) |
| self.mframe.grid(column = 0, row = 4, sticky = 'news') |
| |
| # Row 4 (mframe) is expandable, the other rows are not. |
| self.toppane.rowconfigure(0, weight = 0) |
| self.toppane.rowconfigure(1, weight = 0) |
| self.toppane.rowconfigure(2, weight = 0) |
| self.toppane.rowconfigure(3, weight = 0) |
| self.toppane.rowconfigure(4, weight = 1) |
| self.toppane.columnconfigure(0, weight = 1) |
| |
| #--------------------------------------------- |
| # ttk.Separator(self, orient='horizontal').grid(column=0, row=5, sticky='ew') |
| #--------------------------------------------- |
| |
| # Add a text window below the datasheet to capture output. Redirect |
| # print statements to it. |
| |
| self.botpane.console = ttk.Frame(self.botpane) |
| self.botpane.console.pack(side = 'top', fill = 'both', expand = 'true') |
| |
| self.text_box = ConsoleText(self.botpane.console, wrap='word', height = 4) |
| self.text_box.pack(side='left', fill='both', expand='true') |
| console_scrollbar = ttk.Scrollbar(self.botpane.console) |
| console_scrollbar.pack(side='right', fill='y') |
| # attach console to scrollbar |
| self.text_box.config(yscrollcommand = console_scrollbar.set) |
| console_scrollbar.config(command = self.text_box.yview) |
| |
| # Add button bar at the bottom of the window |
| self.bbar = ttk.Frame(self.botpane) |
| self.bbar.pack(side = 'top', fill = 'x') |
| # Progress bar expands with the window, buttons don't |
| self.bbar.columnconfigure(6, weight = 1) |
| |
| # Define the "quit" button and action |
| self.bbar.quit_button = ttk.Button(self.bbar, text='Close', command=self.on_quit, |
| style = 'normal.TButton') |
| self.bbar.quit_button.grid(column=0, row=0, padx = 5) |
| |
| # Define the save button |
| self.bbar.save_button = ttk.Button(self.bbar, text='Save', command=self.save_results, |
| style = 'normal.TButton') |
| self.bbar.save_button.grid(column=1, row=0, padx = 5) |
| |
| # Define the save-as button |
| self.bbar.saveas_button = ttk.Button(self.bbar, text='Save As', command=self.save_manual, |
| style = 'normal.TButton') |
| |
| # Also a load button |
| self.bbar.load_button = ttk.Button(self.bbar, text='Load', command=self.load_manual, |
| style = 'normal.TButton') |
| |
| # Define help button |
| self.bbar.help_button = ttk.Button(self.bbar, text='Help', command=self.help.open, |
| style = 'normal.TButton') |
| self.bbar.help_button.grid(column = 4, row = 0, padx = 5) |
| |
| # Define settings button |
| self.bbar.settings_button = ttk.Button(self.bbar, text='Settings', |
| command=self.settings.open, style = 'normal.TButton') |
| self.bbar.settings_button.grid(column = 5, row = 0, padx = 5) |
| |
| # Define upload action |
| self.bbar.upload_button = ttk.Button(self.bbar, text='Submit', state = 'enabled', |
| command=self.upload_to_marketplace, style = 'normal.TButton') |
| # "Submit" button remains unplaced; upload may be done from the web side. . . |
| # self.bbar.upload_button.grid(column = 8, row = 0, padx = 5, sticky = 'ens') |
| |
| tooltip.ToolTip(self.bbar.quit_button, text = "Exit characterization tool") |
| tooltip.ToolTip(self.bbar.save_button, text = "Save current characterization state") |
| tooltip.ToolTip(self.bbar.saveas_button, text = "Save current characterization state") |
| tooltip.ToolTip(self.bbar.load_button, text = "Load characterization state from file") |
| tooltip.ToolTip(self.bbar.help_button, text = "Start help tool") |
| tooltip.ToolTip(self.bbar.settings_button, text = "Manage characterization tool settings") |
| tooltip.ToolTip(self.bbar.upload_button, text = "Submit completed design to Marketplace") |
| |
| # Inside frame with main electrical parameter display and scrollbar |
| # To make the frame scrollable, it must be a frame inside a canvas. |
| self.datasheet_viewer = tkinter.Canvas(self.mframe) |
| self.datasheet_viewer.grid(row = 0, column = 0, sticky = 'nsew') |
| self.datasheet_viewer.dframe = ttk.Frame(self.datasheet_viewer, |
| style='bg.TFrame') |
| # Place the frame in the canvas |
| self.datasheet_viewer.create_window((0,0), |
| window=self.datasheet_viewer.dframe, |
| anchor="nw", tags="self.frame") |
| |
| # Make sure the main window resizes, not the scrollbars. |
| self.mframe.rowconfigure(0, weight = 1) |
| self.mframe.columnconfigure(0, weight = 1) |
| # X scrollbar for datasheet viewer |
| main_xscrollbar = ttk.Scrollbar(self.mframe, orient = 'horizontal') |
| main_xscrollbar.grid(row = 1, column = 0, sticky = 'nsew') |
| # Y scrollbar for datasheet viewer |
| main_yscrollbar = ttk.Scrollbar(self.mframe, orient = 'vertical') |
| main_yscrollbar.grid(row = 0, column = 1, sticky = 'nsew') |
| # Attach console to scrollbars |
| self.datasheet_viewer.config(xscrollcommand = main_xscrollbar.set) |
| main_xscrollbar.config(command = self.datasheet_viewer.xview) |
| self.datasheet_viewer.config(yscrollcommand = main_yscrollbar.set) |
| main_yscrollbar.config(command = self.datasheet_viewer.yview) |
| |
| # Make sure that scrollwheel pans window |
| self.datasheet_viewer.bind_all("<Button-4>", self.on_mousewheel) |
| self.datasheet_viewer.bind_all("<Button-5>", self.on_mousewheel) |
| |
| # Set up configure callback |
| self.datasheet_viewer.dframe.bind("<Configure>", self.frame_configure) |
| |
| # Add the panes once the internal geometry is known |
| pane.add(self.toppane) |
| pane.add(self.botpane) |
| pane.paneconfig(self.toppane, stretch='first') |
| |
| # Initialize variables |
| self.sims_to_go = [] |
| |
| # Capture time of start to compare against the annotated |
| # output file timestamp. |
| self.starttime = time.time() |
| |
| # Redirect stdout and stderr to the console as the last thing to do. . . |
| # Otherwise errors in the GUI get sucked into the void. |
| self.stdout = sys.stdout |
| self.stderr = sys.stderr |
| sys.stdout = ConsoleText.StdoutRedirector(self.text_box) |
| sys.stderr = ConsoleText.StderrRedirector(self.text_box) |
| |
| if message: |
| print(message) |
| |
| def frame_configure(self, event): |
| self.update_idletasks() |
| self.datasheet_viewer.configure(scrollregion=self.datasheet_viewer.bbox("all")) |
| |
| def logstart(self): |
| # Start a logfile (or append to it, if it already exists) |
| # Disabled by default, as it can get very large. |
| # Can be enabled from Settings. |
| if self.settings.get_log() == True: |
| dataroot = os.path.splitext(self.cur_datasheet)[0] |
| if not self.logfile: |
| self.logfile = open(dataroot + '.log', 'a') |
| |
| # Print some initial information to the logfile. |
| self.logprint('-------------------------') |
| self.logprint('Starting new log file ' + datetime.datetime.now().strftime('%c'), |
| doflush=True) |
| |
| def logstop(self): |
| if self.logfile: |
| self.logprint('-------------------------', doflush=True) |
| self.logfile.close() |
| self.logfile = [] |
| |
| def logprint(self, message, doflush=False): |
| if self.logfile: |
| self.logfile.buffer.write(message.encode('utf-8')) |
| self.logfile.buffer.write('\n'.encode('utf-8')) |
| if doflush: |
| self.logfile.flush() |
| |
| def set_datasheet(self, datasheet): |
| if self.logfile: |
| self.logprint('end of log.') |
| self.logprint('-------------------------', doflush=True) |
| self.logfile.close() |
| self.logfile = None |
| |
| if not os.path.isfile(datasheet): |
| print('Error: File ' + datasheet + ' not found.') |
| return |
| |
| [dspath, dsname] = os.path.split(datasheet) |
| # Read the datasheet |
| with open(datasheet) as ifile: |
| try: |
| datatop = json.load(ifile) |
| except json.decoder.JSONDecodeError as e: |
| print("Error: Parse error reading JSON file " + datasheet + ':') |
| print(str(e)) |
| return |
| else: |
| # 'request-hash' set to '.' for local simulation |
| datatop['request-hash'] = '.' |
| try: |
| dsheet = datatop['data-sheet'] |
| except KeyError: |
| print("Error: JSON file is not a datasheet!\n") |
| else: |
| self.datatop = datatop |
| self.cur_datasheet = datasheet |
| self.create_datasheet_view() |
| self.toppane.title2_frame.datasheet_select.configure(text=dsname) |
| self.toppane.title2_frame.path_label.configure(text=datasheet) |
| |
| # Determine if there is a saved, annotated JSON file that is |
| # more recent than the netlist used for simulation. |
| self.load_results() |
| |
| # Attempt to set the datasheet viewer width to the interior width |
| # but do not set it larger than the available desktop. |
| self.update_idletasks() |
| widthnow = self.datasheet_viewer.winfo_width() |
| width = self.datasheet_viewer.dframe.winfo_width() |
| screen_width = self.root.winfo_screenwidth() |
| if width > widthnow: |
| if width < screen_width - 10: |
| self.datasheet_viewer.configure(width=width) |
| else: |
| self.datasheet_viewer.configure(width=screen_width - 10) |
| elif widthnow > screen_width: |
| self.datasheet_viewer.configure(width=screen_width - 10) |
| elif widthnow > width: |
| self.datasheet_viewer.configure(width=width) |
| |
| # Likewise for the height, up to 3/5 of the desktop height. |
| height = self.datasheet_viewer.dframe.winfo_height() |
| heightnow = self.datasheet_viewer.winfo_height() |
| screen_height = self.root.winfo_screenheight() |
| if height > heightnow: |
| if height < screen_height * 0.6: |
| self.datasheet_viewer.configure(height=height) |
| else: |
| self.datasheet_viewer.configure(height=screen_height * 0.6) |
| elif heightnow > screen_height: |
| self.datasheet_viewer.configure(height=screen_height - 10) |
| elif heightnow > height: |
| self.datasheet_viewer.configure(height=height) |
| |
| def choose_datasheet(self): |
| datasheet = filedialog.askopenfilename(multiple = False, |
| initialdir = os.path.expanduser('~/design'), |
| filetypes = (("JSON File", "*.json"),("All Files","*.*")), |
| title = "Find a datasheet.") |
| if datasheet != '': |
| self.set_datasheet(datasheet) |
| |
| def cancel_upload(self): |
| # Post a cancelation message to CACE. CACE responds by setting the |
| # status to 'canceled'. The watchprogress procedure is responsible for |
| # returning the button to 'Submit' when the characterization finishes |
| # or is canceled. |
| dspath = os.path.split(self.cur_datasheet)[0] |
| datasheet = os.path.split(self.cur_datasheet)[1] |
| designname = os.path.splitext(datasheet)[0] |
| print('Cancel characterization of ' + designname + ' (' + dspath + ' )') |
| subprocess.run([apps_path + '/cace_design_upload.py', '-cancel', |
| dspath]) |
| self.removeprogress() |
| self.bbar.upload_button.configure(text='Submit', state = 'enabled', |
| command=self.upload_to_marketplace, |
| style = 'normal.TButton') |
| # Delete the remote status file. |
| dsdir = dspath + '/ngspice/char' |
| statusname = dsdir + '/remote_status.json' |
| if os.path.exists(statusname): |
| os.remove(statusname) |
| |
| def progress_bar_setup(self, dspath): |
| # Create the progress bar at the bottom of the window to indicate |
| # the status of a challenge submission. |
| |
| # Disable the Submit button |
| self.bbar.upload_button.configure(state='disabled') |
| |
| # Start progress bar watchclock |
| dsdir = dspath + '/ngspice/char' |
| statusname = dsdir + '/remote_status.json' |
| if os.path.exists(statusname): |
| statbuf = os.stat(statusname) |
| mtime = statbuf.st_mtime |
| else: |
| if os.path.exists(dsdir): |
| # Write a simple status |
| status = {'message': 'not started', 'total': '0', 'completed': '0'} |
| with open(statusname, 'w') as f: |
| json.dump(status, f) |
| mtime = 0 |
| # Create a TTK progress bar widget in the buttonbar. |
| self.bbar.progress_label = ttk.Label(self.bbar, text="Characterization: ", |
| style = 'normal.TLabel') |
| self.bbar.progress_label.grid(column=4, row=0, ipadx = 5) |
| |
| self.bbar.progress_message = ttk.Label(self.bbar, text="(not started)", |
| style = 'blue.TLabel') |
| self.bbar.progress_message.grid(column=5, row=0, ipadx = 5) |
| self.bbar.progress = ttk.Progressbar(self.bbar, |
| orient='horizontal', mode='determinate') |
| self.bbar.progress.grid(column = 6, row = 0, padx = 5, sticky = 'nsew') |
| self.bbar.progress_text = ttk.Label(self.bbar, text="0/0", |
| style = 'blue.TLabel') |
| self.bbar.progress_text.grid(column=7, row=0, ipadx = 5) |
| |
| # Start the timer to watch the progress |
| self.watchprogress(statusname, mtime, 1) |
| |
| def check_ongoing_upload(self): |
| # Determine if an upload is ongoing when the characterization tool is |
| # started. If so, immediately go to the 'characterization running' |
| # state with progress bar. |
| dspath = os.path.split(self.cur_datasheet)[0] |
| datasheet = os.path.split(self.cur_datasheet)[1] |
| designname = os.path.splitext(datasheet)[0] |
| dsdir = dspath + '/ngspice/char' |
| statusname = dsdir + '/remote_status.json' |
| if os.path.exists(statusname): |
| with open(statusname, 'r') as f: |
| status = json.load(f) |
| if 'message' in status: |
| if status['message'] == 'in progress': |
| print('Design characterization in progress for ' + designname + ' (' + dspath + ' )') |
| self.progress_bar_setup(dspath) |
| else: |
| print("No message in status file") |
| |
| def upload_to_marketplace(self): |
| dspath = os.path.split(self.cur_datasheet)[0] |
| datasheet = os.path.split(self.cur_datasheet)[1] |
| dsheet = self.datatop['data-sheet'] |
| designname = dsheet['ip-name'] |
| |
| # Make sure a netlist has been generated. |
| if self.sim_param('check') == False: |
| print('No netlist was generated, cannot submit!') |
| return |
| |
| # For diagnostic purposes, place all of the characterization tool |
| # settings into datatop['settings'] when uploading to remote CACE. |
| runtime_settings = {} |
| runtime_settings['force-regenerate'] = self.settings.get_force() |
| runtime_settings['edit-all-params'] = self.settings.get_edit() |
| runtime_settings['keep-files'] = self.settings.get_keep() |
| runtime_settings['make-plots'] = self.settings.get_plot() |
| runtime_settings['submit-test-mode'] = self.settings.get_test() |
| runtime_settings['submit-as-schematic'] = self.settings.get_schem() |
| runtime_settings['submit-failing'] = self.settings.get_submitfailed() |
| runtime_settings['log-output'] = self.settings.get_log() |
| |
| # Write out runtime settings as a JSON file |
| with open(dspath + '/settings.json', 'w') as file: |
| json.dump(runtime_settings, file, indent = 4) |
| |
| warning = '' |
| must_confirm = False |
| if self.settings.get_schem() == True: |
| # If a layout exists but "submit as schematic" was chosen, then |
| # flag a warning and insist on confirmation. |
| if os.path.exists(dspath + '/mag/' + designname + '.mag'): |
| warning += 'Warning: layout exists but only schematic has been selected for submission' |
| must_confirm = True |
| else: |
| print('No layout in ' + dspath + '/mag/' + designname + '.mag') |
| print('Schematic only submission selection is not needed.') |
| else: |
| # Likewise, check if schematic netlist results are showing but a layout |
| # exists, which means that the existing results are not the ones that are |
| # going to be tested. |
| if self.origin.get() == 'Schematic Capture': |
| if os.path.exists(dspath + '/mag/' + designname + '.mag'): |
| warning += 'Warning: schematic results are shown but remote CACE will be run on layout results.' |
| must_confirm = True |
| |
| |
| # Make a check to see if all simulations have been made and passed. If so, |
| # then just do the upload. If not, then generate a warning dialog and |
| # require the user to respond to force an upload in spite of an incomplete |
| # simulation. Give dire warnings if any simulation has failed. |
| |
| failures = 0 |
| missed = 0 |
| for param in dsheet['electrical-params']: |
| if 'max' in param: |
| pmax = param['max'] |
| if not 'value' in pmax: |
| missed += 1 |
| elif 'score' in pmax: |
| if pmax['score'] == 'fail': |
| failures += 1 |
| if 'min' in param: |
| pmin = param['min'] |
| if not 'value' in pmin: |
| missed += 1 |
| elif 'score' in pmin: |
| if pmin['score'] == 'fail': |
| failures += 1 |
| |
| if missed > 0: |
| if must_confirm == True: |
| warning += '\n' |
| warning += 'Warning: Not all critical parameters have been simulated.' |
| if missed > 0 and failures > 0: |
| warning += '\n' |
| if failures > 0: |
| warning += 'Dire Warning: This design has errors on critical parameters!' |
| |
| # Require confirmation |
| if missed > 0 or failures > 0: |
| must_confirm = True |
| |
| if must_confirm: |
| if self.settings.get_submitfailed() == True: |
| confirm = ConfirmDialog(self, warning).result |
| else: |
| confirm = PuntDialog(self, warning).result |
| if not confirm == 'okay': |
| print('Upload canceled.') |
| return |
| print('Upload selected') |
| |
| # Save hints in file in spice/ directory. |
| hintlist = [] |
| for eparam in dsheet['electrical-params']: |
| if not 'editable' in eparam: |
| if 'hints' in eparam: |
| hintlist.append(eparam['hints']) |
| else: |
| # Must have a placeholder |
| hintlist.append({}) |
| if hintlist: |
| hfilename = dspath + '/hints.json' |
| with open(hfilename, 'w') as hfile: |
| json.dump(hintlist, hfile, indent = 4) |
| |
| print('Uploading design ' + designname + ' (' + dspath + ' )') |
| print('to marketplace and submitting for characterization.') |
| if not self.settings.get_test(): |
| self.progress_bar_setup(dspath) |
| self.update_idletasks() |
| subprocess.run([apps_path + '/cace_design_upload.py', dspath]) |
| |
| # Remove the settings file |
| os.remove(dspath + '/settings.json') |
| os.remove(dspath + '/hints.json') |
| |
| def removeprogress(self): |
| # Remove the progress bar. This is left up for a second after |
| # completion or cancelation so that the final message has time |
| # to be seen. |
| try: |
| self.bbar.progress_label.destroy() |
| self.bbar.progress_message.destroy() |
| self.bbar.progress.destroy() |
| self.bbar.progress_text.destroy() |
| except: |
| pass |
| |
| def watchprogress(self, filename, filemtime, timeout): |
| new_timeout = timeout + 1 if timeout > 0 else 0 |
| # 2 minute timeout for startup (note that all simulation files have to be |
| # made during this period. |
| if new_timeout == 120: |
| self.cancel_upload() |
| return |
| |
| # If file does not exist, then keep checking at 2 second intervals. |
| if not os.path.exists(filename): |
| self.after(2000, lambda: self.watchprogress(filename, filemtime, new_timeout)) |
| return |
| |
| # If filename file is modified, then update progress bar; |
| # otherwise, restart the clock. |
| statbuf = os.stat(filename) |
| if statbuf.st_mtime > filemtime: |
| self.after(250) # Otherwise can catch file while it's incomplete. . . |
| if self.update_progress(filename) == True: |
| self.after(1000, lambda: self.watchprogress(filename, filemtime, 0)) |
| else: |
| # Remove the progress bar when done, after letting the final |
| # message display for a second. |
| self.after(1500, self.removeprogress) |
| # And return the button to "Submit" and in an enabled state. |
| self.bbar.upload_button.configure(text='Submit', state = 'enabled', |
| command=self.upload_to_marketplace, |
| style = 'normal.TButton') |
| else: |
| self.after(1000, lambda: self.watchprogress(filename, filemtime, new_timeout)) |
| |
| def update_progress(self, filename): |
| # On first update, button changes from "Submit" to "Cancel" |
| # This ensures that the 'remote_status.json' file has been sent |
| # from the CACE with the hash value needed for the CACE to identify |
| # the right simulation and cancel it. |
| if self.bbar.upload_button.configure('text')[-1] == 'Submit': |
| self.bbar.upload_button.configure(text='Cancel', state = 'enabled', |
| command=self.cancel_upload, style = 'red.TButton') |
| |
| if not os.path.exists(filename): |
| return False |
| |
| # Update the progress bar during an CACE simulation run. |
| # Read the status file |
| try: |
| with open(filename, 'r') as f: |
| status = json.load(f) |
| except (PermissionError, FileNotFoundError): |
| # For a very short time the user does not have ownership of |
| # the file and the read will fail. This is a rare case, so |
| # just punt until the next cycle. |
| return True |
| |
| if 'message' in status: |
| self.bbar.progress_message.configure(text = status['message']) |
| |
| try: |
| total = int(status['total']) |
| except: |
| total = 0 |
| else: |
| self.bbar.progress.configure(maximum = total) |
| |
| try: |
| completed = int(status['completed']) |
| except: |
| completed = 0 |
| else: |
| self.bbar.progress.configure(value = completed) |
| |
| self.bbar.progress_text.configure(text = str(completed) + '/' + str(total)) |
| if completed > 0 and completed == total: |
| print('Notice: Design completed.') |
| print('The CACE server has finished characterizing the design.') |
| print('Go to the efabless marketplace to view submission.') |
| return False |
| elif status['message'] == 'canceled': |
| print('Notice: Design characterization was canceled.') |
| return False |
| else: |
| return True |
| |
| def topfilter(self, line): |
| # Check output for ubiquitous "Reference value" lines and remove them. |
| # This happens before logging both to the file and to the console. |
| refrex = re.compile('Reference value') |
| rmatch = refrex.match(line) |
| if not rmatch: |
| return line |
| else: |
| return None |
| |
| def spicefilter(self, line): |
| # Check for the alarmist 'tran simulation interrupted' message and remove it. |
| # Check for error or warning and print as stderr or stdout accordingly. |
| intrex = re.compile('tran simulation interrupted') |
| warnrex = re.compile('.*warning', re.IGNORECASE) |
| errrex = re.compile('.*error', re.IGNORECASE) |
| |
| imatch = intrex.match(line) |
| if not imatch: |
| ematch = errrex.match(line) |
| wmatch = warnrex.match(line) |
| if ematch or wmatch: |
| print(line, file=sys.stderr) |
| else: |
| print(line, file=sys.stdout) |
| |
| def printwarn(self, output): |
| # Check output for warning or error |
| if not output: |
| return 0 |
| |
| warnrex = re.compile('.*warning', re.IGNORECASE) |
| errrex = re.compile('.*error', re.IGNORECASE) |
| |
| errors = 0 |
| outlines = output.splitlines() |
| for line in outlines: |
| try: |
| wmatch = warnrex.match(line) |
| except TypeError: |
| line = line.decode('utf-8') |
| wmatch = warnrex.match(line) |
| ematch = errrex.match(line) |
| if ematch: |
| errors += 1 |
| if ematch or wmatch: |
| print(line) |
| return errors |
| |
| def sim_all(self): |
| if self.caceproc: |
| # Failsafe |
| if self.caceproc.poll() != None: |
| self.caceproc = None |
| else: |
| print('Simulation in progress must finish first.') |
| return |
| |
| # Create netlist if necessary, check for valid result |
| if self.sim_param('check') == False: |
| return |
| |
| # Simulate all of the electrical parameters in turn |
| self.sims_to_go = [] |
| for puniq in self.status: |
| self.sims_to_go.append(puniq) |
| |
| # Start first sim |
| if len(self.sims_to_go) > 0: |
| puniq = self.sims_to_go[0] |
| self.sims_to_go = self.sims_to_go[1:] |
| self.sim_param(puniq) |
| |
| # Button now stops the simulations |
| self.allsimbutton.configure(style = 'redtitle.TButton', text='Stop Simulations', |
| command=self.stop_sims) |
| |
| def stop_sims(self): |
| # Make sure there will be no more simulations |
| self.sims_to_go = [] |
| if not self.caceproc: |
| print("No simulation running.") |
| return |
| self.caceproc.terminate() |
| # Use communicate(), not wait() , on piped processes to avoid deadlock. |
| try: |
| self.caceproc.communicate(timeout=10) |
| except subprocess.TimeoutExpired: |
| self.caceproc.kill() |
| self.caceproc.communicate() |
| print("CACE process killed.") |
| else: |
| print("CACE process exited.") |
| # Let watchdog timer see that caceproc is gone and reset the button. |
| |
| def edit_param(self, param): |
| # Edit the conditions under which the parameter is tested. |
| if ('editable' in param and param['editable'] == True) or self.settings.get_edit() == True: |
| self.editparam.populate(param) |
| self.editparam.open() |
| else: |
| print('Parameter is not editable') |
| |
| def copy_param(self, param): |
| # Make a copy of the parameter (for editing) |
| newparam = param.copy() |
| # Make the copied parameter editable |
| newparam['editable'] = True |
| # Append this to the electrical parameter list after the item being copied |
| if 'display' in param: |
| newparam['display'] = param['display'] + ' (copy)' |
| datatop = self.datatop |
| dsheet = datatop['data-sheet'] |
| eparams = dsheet['electrical-params'] |
| eidx = eparams.index(param) |
| eparams.insert(eidx + 1, newparam) |
| self.create_datasheet_view() |
| |
| def delete_param(self, param): |
| # Remove an electrical parameter from the datasheet. This is only |
| # allowed if the parameter has been copied from another and so does |
| # not belong to the original set of parameters. |
| datatop = self.datatop |
| dsheet = datatop['data-sheet'] |
| eparams = dsheet['electrical-params'] |
| eidx = eparams.index(param) |
| eparams.pop(eidx) |
| self.create_datasheet_view() |
| |
| def add_hints(self, param, simbutton): |
| # Raise hints window and configure appropriately for the parameter. |
| # Fill in any existing hints. |
| self.simhints.populate(param, simbutton) |
| self.simhints.open() |
| |
| def sim_param(self, method): |
| if self.caceproc: |
| # Failsafe |
| if self.caceproc.poll() != None: |
| self.caceproc = None |
| else: |
| print('Simulation in progress, queued for simulation.') |
| if not method in self.sims_to_go: |
| self.sims_to_go.append(method) |
| return False |
| |
| # Get basic values for datasheet and ip-name |
| |
| dspath = os.path.split(self.cur_datasheet)[0] |
| dsheet = self.datatop['data-sheet'] |
| dname = dsheet['ip-name'] |
| |
| # Open log file, if specified |
| self.logstart() |
| |
| # Check for whether the netlist is specified to come from schematic |
| # or layout. Add a record to the datasheet depending on whether |
| # the netlist is from layout or extracted. The settings window has |
| # a checkbox to force submitting as a schematic even if layout exists. |
| |
| if self.origin.get() == 'Schematic Capture': |
| dsheet['netlist-source'] = 'schematic' |
| else: |
| dsheet['netlist-source'] = 'layout' |
| |
| if self.settings.get_force() == True: |
| dsheet['regenerate'] = 'force' |
| |
| basemethod = method.split('.')[0] |
| if basemethod == 'check': # used by submit to ensure netlist exists |
| return True |
| |
| if basemethod == 'physical': |
| print('Checking ' + method.split('.')[1]) |
| else: |
| print('Simulating method = ' + basemethod) |
| self.stat_label = self.status[method] |
| self.stat_label.configure(text='(in progress)', style='blue.TLabel') |
| # Update status now |
| self.update_idletasks() |
| |
| if dspath == '': |
| dspath = '.' |
| |
| print('Datasheet directory is = ' + dspath + '\n') |
| |
| # Instead of using the original datasheet, use the one in memory so that |
| # it accumulates results. A "save" button will update the original. |
| if not os.path.isdir(dspath + '/ngspice'): |
| os.makedirs(dspath + '/ngspice') |
| dsdir = dspath + '/ngspice' |
| if not os.path.isdir(dsdir): |
| os.makedirs(dsdir) |
| with open(dsdir + '/datasheet.json', 'w') as file: |
| json.dump(self.datatop, file, indent = 4) |
| # As soon as we call CACE, we will be watching the status of file |
| # datasheet_anno. So create it if it does not exist, else attempting |
| # to stat a nonexistant file will cause the 1st simulation to fail. |
| if not os.path.exists(dsdir + '/datasheet_anno.json'): |
| open(dsdir + '/datasheet_anno.json', 'a').close() |
| # Call cace_gensim with full set of options |
| # First argument is the root directory |
| # (Diagnostic) |
| design_path = dspath + '/spice' |
| |
| print('Calling cace_gensim.py ' + dspath + |
| ' -local -method=' + method) |
| |
| modetext = ['-local'] |
| if self.settings.get_keep() == True: |
| print(' -keep ') |
| modetext.append('-keep') |
| |
| if self.settings.get_plot() == True: |
| print(' -plot ') |
| modetext.append('-plot') |
| |
| print(' -simdir=' + dsdir + ' -datasheetdir=' + dsdir + ' -designdir=' + design_path) |
| print(' -layoutdir=' + dspath + '/mag' + ' -testbenchdir=' + dspath + '/testbench') |
| print(' -datasheet=datasheet.json') |
| |
| self.caceproc = subprocess.Popen([apps_path + '/cace_gensim.py', dspath, |
| *modetext, |
| '-method=' + method, # Call local mode w/method |
| '-simdir=' + dsdir, |
| '-datasheetdir=' + dsdir, |
| '-designdir=' + design_path, |
| '-layoutdir=' + dspath + '/mag', |
| '-testbenchdir=' + dspath + '/testbench', |
| '-datasheet=datasheet.json'], |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0) |
| |
| # Simulation finishes on its own time. Use watchdog to handle. |
| # Note that python "watchdog" is threaded, and tkinter is not thread-safe. |
| # So watchdog is done with a simple timer loop. |
| statbuf = os.stat(dsdir + '/datasheet.json') |
| checktime = statbuf.st_mtime |
| |
| filename = dsdir + '/datasheet_anno.json' |
| statbuf = os.stat(filename) |
| self.watchclock(filename, statbuf.st_mtime, checktime) |
| |
| def watchclock(self, filename, filemtime, checktime): |
| # In case simulations cleared while watchclock was pending |
| if self.caceproc == None: |
| return |
| # Poll cace_gensim to see if it finished |
| cace_status = self.caceproc.poll() |
| if cace_status != None: |
| try: |
| output = self.caceproc.communicate(timeout=1) |
| except ValueError: |
| print("CACE gensim forced stop, status " + str(cace_status)) |
| else: |
| outlines = output[0] |
| errlines = output[1] |
| for line in outlines.splitlines(): |
| print(line.decode('utf-8')) |
| for line in errlines.splitlines(): |
| print(line.decode('utf-8')) |
| print("CACE gensim exited with status " + str(cace_status)) |
| else: |
| n = 0 |
| while True: |
| self.update_idletasks() |
| # Attempt to avoid infinite loop, unsure of the cause. |
| n += 1 |
| if n > 100: |
| n = 0 |
| cace_status = self.caceproc.poll() |
| if cace_status != None: |
| break |
| self.logprint("100 lines of output", doflush=True) |
| # Something went wrong. Kill the process. |
| # self.stop_sims() |
| sresult = select.select([self.caceproc.stdout, self.caceproc.stderr], [], [], 0)[0] |
| if self.caceproc.stdout in sresult: |
| outstring = self.caceproc.stdout.readline().decode().strip() |
| self.logprint(outstring, doflush=True) |
| print(outstring) |
| elif self.caceproc.stderr in sresult: |
| # ngspice passes back simulation time on stderr. This ends in \r but no |
| # newline. '\r' ends the transmission, so return. |
| # errstring = self.topfilter(self.caceproc.stderr.readline().decode().strip()) |
| # if errstring: |
| # self.logprint(errstring, doflush=True) |
| # # Recast everything that isn't an error back into stdout. |
| # self.spicefilter(errstring) |
| ochar = str(self.caceproc.stderr.read(1).decode()) |
| if ochar == '\r': |
| print('') |
| break |
| else: |
| print(ochar, end='') |
| else: |
| break |
| |
| # If filename file is modified, then call annotate; otherwise, restart the clock. |
| statbuf = os.stat(filename) |
| if (statbuf.st_mtime > filemtime) or (cace_status != None): |
| if cace_status != None: |
| self.caceproc = None |
| else: |
| # Re-run to catch last output. |
| self.after(500, lambda: self.watchclock(filename, statbuf.st_mtime, checktime)) |
| return |
| if cace_status != 0: |
| print('Errors encountered in simulation.') |
| self.logprint('Errors in simulation, CACE status = ' + str(cace_status), doflush=True) |
| self.annotate('anno', checktime) |
| if len(self.sims_to_go) > 0: |
| puniq = self.sims_to_go[0] |
| self.sims_to_go = self.sims_to_go[1:] |
| self.sim_param(puniq) |
| else: |
| # Button goes back to original text and command |
| self.allsimbutton.configure(style = 'bluetitle.TButton', |
| text='Simulate All', command = self.sim_all) |
| elif not self.caceproc: |
| # Process terminated by "stop" |
| # Button goes back to original text and command |
| self.allsimbutton.configure(style = 'bluetitle.TButton', |
| text='Simulate All', command = self.sim_all) |
| # Just redraw everthing so that the "(in progress)" message goes away. |
| self.annotate('anno', checktime) |
| else: |
| self.after(500, lambda: self.watchclock(filename, filemtime, checktime)) |
| |
| def clear_results(self, dsheet): |
| # Remove results from the window by clearing parameter results |
| paramstodo = [] |
| if 'electrical-params' in dsheet: |
| paramstodo.extend(dsheet['electrical-params']) |
| if 'physical-params' in dsheet: |
| paramstodo.extend(dsheet['physical-params']) |
| |
| for param in paramstodo: |
| # Fill frame with electrical parameter information |
| if 'max' in param: |
| maxrec = param['max'] |
| if 'value' in maxrec: |
| maxrec.pop('value') |
| if 'score' in maxrec: |
| maxrec.pop('score') |
| if 'typ' in param: |
| typrec = param['typ'] |
| if 'value' in typrec: |
| typrec.pop('value') |
| if 'score' in typrec: |
| typrec.pop('score') |
| if 'min' in param: |
| minrec = param['min'] |
| if 'value' in minrec: |
| minrec.pop('value') |
| if 'score' in minrec: |
| minrec.pop('score') |
| if 'results' in param: |
| param.pop('results') |
| |
| if 'plot' in param: |
| plotrec = param['plot'] |
| if 'status' in plotrec: |
| plotrec.pop('status') |
| |
| # Regenerate datasheet view |
| self.create_datasheet_view() |
| |
| def annotate(self, suffix, checktime): |
| # Pull results back from datasheet_anno.json. Do NOT load this |
| # file if it predates the unannotated datasheet (that indicates |
| # simulator failure, and no results). |
| dspath = os.path.split(self.cur_datasheet)[0] |
| if dspath == '': |
| dspath = '.' |
| dsdir = dspath + '/ngspice' |
| anno = dsdir + '/datasheet_' + suffix + '.json' |
| unanno = dsdir + '/datasheet.json' |
| |
| if os.path.exists(anno): |
| statbuf = os.stat(anno) |
| mtimea = statbuf.st_mtime |
| if checktime >= mtimea: |
| # print('original = ' + str(checktime) + ' annotated = ' + str(mtimea)) |
| print('Error in simulation, no update to results.', file=sys.stderr) |
| elif statbuf.st_size == 0: |
| print('Error in simulation, no results.', file=sys.stderr) |
| else: |
| with open(anno, 'r') as file: |
| self.datatop = json.load(file) |
| else: |
| print('Error in simulation, no update to results.', file=sys.stderr) |
| |
| # Regenerate datasheet view |
| self.create_datasheet_view() |
| |
| # Close log file, if it was enabled in the settings |
| self.logstop() |
| |
| def save_results(self): |
| # Write datasheet_save with all the locally processed results. |
| dspath = os.path.split(self.cur_datasheet)[0] |
| dsdir = dspath + '/ngspice' |
| |
| if self.origin.get() == 'Layout Extracted': |
| jsonfile = dsdir + '/datasheet_lsave.json' |
| else: |
| jsonfile = dsdir + '/datasheet_save.json' |
| |
| with open(jsonfile, 'w') as ofile: |
| json.dump(self.datatop, ofile, indent = 4) |
| self.last_save = os.path.getmtime(jsonfile) |
| |
| # Create copy of datasheet without result data. This is |
| # the file appropriate to insert into the IP catalog |
| # metadata JSON file. |
| |
| datacopy = copy.copy(self.datatop) |
| dsheet = datacopy['data-sheet'] |
| if 'electrical-params' in dsheet: |
| for eparam in dsheet['electrical-params']: |
| if 'results' in eparam: |
| eparam.pop('results') |
| |
| datacopy.pop('request-hash') |
| jsonfile = dsdir + '/datasheet_compact.json' |
| with open(jsonfile, 'w') as ofile: |
| json.dump(datacopy, ofile, indent = 4) |
| |
| print('Characterization results saved.') |
| |
| def check_saved(self): |
| # Check if there is a file 'datasheet_save' and if it is more |
| # recent than 'datasheet_anno'. If so, return True, else False. |
| |
| [dspath, dsname] = os.path.split(self.cur_datasheet) |
| dsdir = dspath + '/ngspice' |
| |
| if self.origin.get() == 'Layout Extracted': |
| savefile = dsdir + '/datasheet_lsave.json' |
| else: |
| savefile = dsdir + '/datasheet_save.json' |
| |
| annofile = dsdir + '/datasheet_anno.json' |
| if os.path.exists(annofile): |
| annotime = os.path.getmtime(annofile) |
| |
| # If nothing has been updated since the characterization |
| # tool was started, then there is no new information to save. |
| if annotime < self.starttime: |
| return True |
| |
| if os.path.exists(savefile): |
| savetime = os.path.getmtime(savefile) |
| # return True if (savetime > annotime) else False |
| if savetime > annotime: |
| print("Save is more recent than sim, so no need to save.") |
| return True |
| else: |
| print("Sim is more recent than save, so need to save.") |
| return False |
| else: |
| # There is a datasheet_anno file but no datasheet_save, |
| # so there are necessarily unsaved results. |
| print("no datasheet_save, so any results have not been saved.") |
| return False |
| else: |
| # There is no datasheet_anno file, so datasheet_save |
| # is either current or there have been no simulations. |
| print("no datasheet_anno, so there are no results to save.") |
| return True |
| |
| def callback(self): |
| # Check for manual load/save-as status from settings window (callback |
| # when the settings window is closed). |
| if self.settings.get_loadsave() == True: |
| self.bbar.saveas_button.grid(column=2, row=0, padx = 5) |
| self.bbar.load_button.grid(column=3, row=0, padx = 5) |
| else: |
| self.bbar.saveas_button.grid_forget() |
| self.bbar.load_button.grid_forget() |
| |
| def save_manual(self, value={}): |
| dspath = self.cur_datasheet |
| # Set initialdir to the project where cur_datasheet is located |
| dsparent = os.path.split(dspath)[0] |
| |
| datasheet = filedialog.asksaveasfilename(multiple = False, |
| initialdir = dsparent, |
| confirmoverwrite = True, |
| defaultextension = ".json", |
| filetypes = (("JSON File", "*.json"),("All Files","*.*")), |
| title = "Select filename for saved datasheet.") |
| with open(datasheet, 'w') as ofile: |
| json.dump(self.datatop, ofile, indent = 4) |
| |
| def load_manual(self, value={}): |
| dspath = self.cur_datasheet |
| # Set initialdir to the project where cur_datasheet is located |
| dsparent = os.path.split(dspath)[0] |
| |
| datasheet = filedialog.askopenfilename(multiple = False, |
| initialdir = dsparent, |
| filetypes = (("JSON File", "*.json"),("All Files","*.*")), |
| title = "Find a datasheet.") |
| if datasheet != '': |
| try: |
| with open(datasheet, 'r') as file: |
| self.datatop = json.load(file) |
| except: |
| print('Error in file, no update to results.', file=sys.stderr) |
| |
| else: |
| # Regenerate datasheet view |
| self.create_datasheet_view() |
| |
| def load_results(self, value={}): |
| # Check if datasheet_save exists and is more recent than the |
| # latest design netlist. If so, load it; otherwise, not. |
| # NOTE: Name of .spice file comes from the project 'ip-name' |
| # in the datasheet. |
| |
| [dspath, dsname] = os.path.split(self.cur_datasheet) |
| try: |
| dsheet = self.datatop['data-sheet'] |
| except KeyError: |
| return |
| |
| if dspath == '': |
| dspath = '.' |
| |
| dsroot = dsheet['ip-name'] |
| |
| # Remove any existing results from the datasheet records |
| self.clear_results(dsheet) |
| |
| # Also must be more recent than datasheet |
| jtime = os.path.getmtime(self.cur_datasheet) |
| |
| # dsroot = os.path.splitext(dsname)[0] |
| |
| dsdir = dspath + '/spice' |
| |
| if not os.path.exists(dsdir): |
| print('Error: Cannot find directory spice/ in path ' + dspath) |
| |
| if self.origin.get() == 'Layout Extracted': |
| spifile = dsdir + '/pex/' + dsroot + '.spice' |
| savesuffix = 'lsave' |
| else: |
| spifile = dsdir + '/' + dsroot + '.spice' |
| savesuffix = 'save' |
| |
| dsdir = dspath + '/ngspice' |
| savefile = dsdir + '/datasheet_' + savesuffix + '.json' |
| |
| if os.path.exists(savefile): |
| savetime = os.path.getmtime(savefile) |
| |
| if os.path.exists(spifile): |
| spitime = os.path.getmtime(spifile) |
| |
| if os.path.exists(savefile): |
| if (savetime > spitime and savetime > jtime): |
| self.annotate(savesuffix, 0) |
| print('Characterization results loaded.') |
| # print('(' + savefile + ' timestamp = ' + str(savetime) + '; ' + self.cur_datasheet + ' timestamp = ' + str(jtime)) |
| else: |
| print('Saved datasheet is out-of-date, not loading') |
| else: |
| print('Datasheet file ' + savefile) |
| print('No saved datasheet file, nothing to pre-load') |
| else: |
| print('No netlist file ' + spifile + '!') |
| |
| # Remove outdated datasheet.json and datasheet_anno.json to prevent |
| # them from overwriting characterization document entries |
| |
| if os.path.exists(savefile): |
| if savetime < jtime: |
| print('Removing outdated save file ' + savefile) |
| os.remove(savefile) |
| |
| savefile = dsdir + '/datasheet_anno.json' |
| if os.path.exists(savefile): |
| savetime = os.path.getmtime(savefile) |
| if savetime < jtime: |
| print('Removing outdated results file ' + savefile) |
| os.remove(savefile) |
| |
| savefile = dsdir + '/datasheet.json' |
| if os.path.exists(savefile): |
| savetime = os.path.getmtime(savefile) |
| if savetime < jtime: |
| print('Removing outdated results file ' + savefile) |
| os.remove(savefile) |
| |
| def create_datasheet_view(self): |
| dframe = self.datasheet_viewer.dframe |
| |
| # Destroy the existing datasheet frame contents (if any) |
| for widget in dframe.winfo_children(): |
| widget.destroy() |
| self.status = {} # Clear dictionary |
| |
| dsheet = self.datatop['data-sheet'] |
| if 'global-conditions' in dsheet: |
| globcond = dsheet['global-conditions'] |
| else: |
| globcond = [] |
| |
| # Add basic information at the top |
| |
| n = 0 |
| dframe.cframe = ttk.Frame(dframe) |
| dframe.cframe.grid(column = 0, row = n, sticky='ewns', columnspan = 10) |
| |
| dframe.cframe.plabel = ttk.Label(dframe.cframe, text = 'Project IP name:', |
| style = 'italic.TLabel') |
| dframe.cframe.plabel.grid(column = 0, row = n, sticky='ewns', ipadx = 5) |
| dframe.cframe.pname = ttk.Label(dframe.cframe, text = dsheet['ip-name'], |
| style = 'normal.TLabel') |
| dframe.cframe.pname.grid(column = 1, row = n, sticky='ewns', ipadx = 5) |
| dframe.cframe.fname = ttk.Label(dframe.cframe, text = dsheet['foundry'], |
| style = 'normal.TLabel') |
| dframe.cframe.fname.grid(column = 2, row = n, sticky='ewns', ipadx = 5) |
| dframe.cframe.fname = ttk.Label(dframe.cframe, text = dsheet['node'], |
| style = 'normal.TLabel') |
| dframe.cframe.fname.grid(column = 3, row = n, sticky='ewns', ipadx = 5) |
| if 'decription' in dsheet: |
| dframe.cframe.pdesc = ttk.Label(dframe.cframe, text = dsheet['description'], |
| style = 'normal.TLabel') |
| dframe.cframe.pdesc.grid(column = 4, row = n, sticky='ewns', ipadx = 5) |
| |
| if 'UID' in self.datatop: |
| n += 1 |
| dframe.cframe.ulabel = ttk.Label(dframe.cframe, text = 'UID:', |
| style = 'italic.TLabel') |
| dframe.cframe.ulabel.grid(column = 0, row = n, sticky='ewns', ipadx = 5) |
| dframe.cframe.uname = ttk.Label(dframe.cframe, text = self.datatop['UID'], |
| style = 'normal.TLabel') |
| dframe.cframe.uname.grid(column = 1, row = n, columnspan = 5, sticky='ewns', ipadx = 5) |
| |
| n = 1 |
| ttk.Separator(dframe, orient='horizontal').grid(column=0, row=n, sticky='ewns', columnspan=10) |
| |
| # Title block |
| n += 1 |
| dframe.desc_title = ttk.Label(dframe, text = 'Parameter', style = 'title.TLabel') |
| dframe.desc_title.grid(column = 0, row = n, sticky='ewns') |
| dframe.method_title = ttk.Label(dframe, text = 'Method', style = 'title.TLabel') |
| dframe.method_title.grid(column = 1, row = n, sticky='ewns') |
| dframe.min_title = ttk.Label(dframe, text = 'Min', style = 'title.TLabel') |
| dframe.min_title.grid(column = 2, row = n, sticky='ewns', columnspan = 2) |
| dframe.typ_title = ttk.Label(dframe, text = 'Typ', style = 'title.TLabel') |
| dframe.typ_title.grid(column = 4, row = n, sticky='ewns', columnspan = 2) |
| dframe.max_title = ttk.Label(dframe, text = 'Max', style = 'title.TLabel') |
| dframe.max_title.grid(column = 6, row = n, sticky='ewns', columnspan = 2) |
| dframe.stat_title = ttk.Label(dframe, text = 'Status', style = 'title.TLabel') |
| dframe.stat_title.grid(column = 8, row = n, sticky='ewns') |
| |
| if not self.sims_to_go: |
| self.allsimbutton = ttk.Button(dframe, text='Simulate All', |
| style = 'bluetitle.TButton', command = self.sim_all) |
| else: |
| self.allsimbutton = ttk.Button(dframe, text='Stop Simulations', |
| style = 'redtitle.TButton', command = self.stop_sims) |
| self.allsimbutton.grid(column = 9, row=n, sticky='ewns') |
| |
| tooltip.ToolTip(self.allsimbutton, text = "Simulate all electrical parameters") |
| |
| # Make all columns equally expandable |
| for i in range(10): |
| dframe.columnconfigure(i, weight = 1) |
| |
| # Parse the file for electrical parameters |
| n += 1 |
| binrex = re.compile(r'([0-9]*)\'([bodh])', re.IGNORECASE) |
| paramstodo = [] |
| if 'electrical-params' in dsheet: |
| paramstodo.extend(dsheet['electrical-params']) |
| if 'physical-params' in dsheet: |
| paramstodo.extend(dsheet['physical-params']) |
| |
| if self.origin.get() == 'Schematic Capture': |
| isschem = True |
| else: |
| isschem = False |
| |
| for param in paramstodo: |
| # Fill frame with electrical parameter information |
| if 'method' in param: |
| p = param['method'] |
| puniq = p + '.0' |
| if puniq in self.status: |
| # This method was used before, so give it a unique identifier |
| j = 1 |
| while True: |
| puniq = p + '.' + str(j) |
| if puniq not in self.status: |
| break |
| else: |
| j += 1 |
| else: |
| j = 0 |
| paramtype = 'electrical' |
| else: |
| paramtype = 'physical' |
| p = param['condition'] |
| puniq = paramtype + '.' + p |
| j = 0 |
| |
| if 'editable' in param and param['editable'] == True: |
| normlabel = 'hlight.TLabel' |
| redlabel = 'rhlight.TLabel' |
| greenlabel = 'ghlight.TLabel' |
| normbutton = 'hlight.TButton' |
| redbutton = 'rhlight.TButton' |
| greenbutton = 'ghlight.TButton' |
| else: |
| normlabel = 'normal.TLabel' |
| redlabel = 'red.TLabel' |
| greenlabel = 'green.TLabel' |
| normbutton = 'normal.TButton' |
| redbutton = 'red.TButton' |
| greenbutton = 'green.TButton' |
| |
| if 'display' in param: |
| dtext = param['display'] |
| else: |
| dtext = p |
| |
| # Special handling: Change LVS_errors to "device check" when using |
| # schematic netlist. |
| if paramtype == 'physical': |
| if isschem: |
| if p == 'LVS_errors': |
| dtext = 'Invalid device check' |
| |
| dframe.description = ttk.Label(dframe, text = dtext, style = normlabel) |
| |
| dframe.description.grid(column = 0, row=n, sticky='ewns') |
| dframe.method = ttk.Label(dframe, text = p, style = normlabel) |
| dframe.method.grid(column = 1, row=n, sticky='ewns') |
| if 'plot' in param: |
| status_style = normlabel |
| dframe.plots = ttk.Frame(dframe) |
| dframe.plots.grid(column = 2, row=n, columnspan = 6, sticky='ewns') |
| plotrec = param['plot'] |
| if 'status' in plotrec: |
| status_value = plotrec['status'] |
| else: |
| status_value = '(not checked)' |
| dframe_plot = ttk.Label(dframe.plots, text=plotrec['filename'], |
| style = normlabel) |
| dframe_plot.grid(column = j, row = n, sticky='ewns') |
| else: |
| # For schematic capture, mark physical parameters that can't and won't be |
| # checked as "not applicable". |
| status_value = '(not checked)' |
| if paramtype == 'physical': |
| if isschem: |
| if p == 'area' or p == 'width' or p == 'height' or p == 'DRC_errors': |
| status_value = '(N/A)' |
| |
| if 'min' in param: |
| status_style = normlabel |
| pmin = param['min'] |
| if 'target' in pmin: |
| if 'unit' in param and not binrex.match(param['unit']): |
| targettext = pmin['target'] + ' ' + param['unit'] |
| else: |
| targettext = pmin['target'] |
| # Hack for use of min to change method of scoring |
| if not 'penalty' in pmin or pmin['penalty'] != '0': |
| dframe.min = ttk.Label(dframe, text=targettext, style = normlabel) |
| else: |
| dframe.min = ttk.Label(dframe, text='(no limit)', style = normlabel) |
| else: |
| dframe.min = ttk.Label(dframe, text='(no limit)', style = normlabel) |
| if 'score' in pmin: |
| if pmin['score'] != 'fail': |
| status_style = greenlabel |
| if status_value != 'fail': |
| status_value = 'pass' |
| else: |
| status_style = redlabel |
| status_value = 'fail' |
| if 'value' in pmin: |
| if 'unit' in param and not binrex.match(param['unit']): |
| valuetext = pmin['value'] + ' ' + param['unit'] |
| else: |
| valuetext = pmin['value'] |
| dframe.value = ttk.Label(dframe, text=valuetext, style=status_style) |
| dframe.value.grid(column = 3, row=n, sticky='ewns') |
| else: |
| dframe.min = ttk.Label(dframe, text='(no limit)', style = normlabel) |
| dframe.min.grid(column = 2, row=n, sticky='ewns') |
| if 'typ' in param: |
| status_style = normlabel |
| ptyp = param['typ'] |
| if 'target' in ptyp: |
| if 'unit' in param and not binrex.match(param['unit']): |
| targettext = ptyp['target'] + ' ' + param['unit'] |
| else: |
| targettext = ptyp['target'] |
| dframe.typ = ttk.Label(dframe, text=targettext, style = normlabel) |
| else: |
| dframe.typ = ttk.Label(dframe, text='(no target)', style = normlabel) |
| if 'score' in ptyp: |
| # Note: You can't fail a "typ" score, but there is only one "Status", |
| # so if it is a "fail", it must remain a "fail". |
| if ptyp['score'] != 'fail': |
| status_style = greenlabel |
| if status_value != 'fail': |
| status_value = 'pass' |
| else: |
| status_style = redlabel |
| status_value = 'fail' |
| if 'value' in ptyp: |
| if 'unit' in param and not binrex.match(param['unit']): |
| valuetext = ptyp['value'] + ' ' + param['unit'] |
| else: |
| valuetext = ptyp['value'] |
| dframe.value = ttk.Label(dframe, text=valuetext, style=status_style) |
| dframe.value.grid(column = 5, row=n, sticky='ewns') |
| else: |
| dframe.typ = ttk.Label(dframe, text='(no target)', style = normlabel) |
| dframe.typ.grid(column = 4, row=n, sticky='ewns') |
| if 'max' in param: |
| status_style = normlabel |
| pmax = param['max'] |
| if 'target' in pmax: |
| if 'unit' in param and not binrex.match(param['unit']): |
| targettext = pmax['target'] + ' ' + param['unit'] |
| else: |
| targettext = pmax['target'] |
| # Hack for use of max to change method of scoring |
| if not 'penalty' in pmax or pmax['penalty'] != '0': |
| dframe.max = ttk.Label(dframe, text=targettext, style = normlabel) |
| else: |
| dframe.max = ttk.Label(dframe, text='(no limit)', style = normlabel) |
| else: |
| dframe.max = ttk.Label(dframe, text='(no limit)', style = normlabel) |
| if 'score' in pmax: |
| if pmax['score'] != 'fail': |
| status_style = greenlabel |
| if status_value != 'fail': |
| status_value = 'pass' |
| else: |
| status_style = redlabel |
| status_value = 'fail' |
| if 'value' in pmax: |
| if 'unit' in param and not binrex.match(param['unit']): |
| valuetext = pmax['value'] + ' ' + param['unit'] |
| else: |
| valuetext = pmax['value'] |
| dframe.value = ttk.Label(dframe, text=valuetext, style=status_style) |
| dframe.value.grid(column = 7, row=n, sticky='ewns') |
| else: |
| dframe.max = ttk.Label(dframe, text='(no limit)', style = normlabel) |
| dframe.max.grid(column = 6, row=n, sticky='ewns') |
| |
| if paramtype == 'electrical': |
| if 'hints' in param: |
| simtext = '\u2022Simulate' |
| else: |
| simtext = 'Simulate' |
| else: |
| simtext = 'Check' |
| |
| simbutton = ttk.Menubutton(dframe, text=simtext, style = normbutton) |
| |
| # Generate pull-down menu on Simulate button. Most items apply |
| # only to electrical parameters (at least for now) |
| simmenu = tkinter.Menu(simbutton) |
| simmenu.add_command(label='Run', |
| command = lambda puniq=puniq: self.sim_param(puniq)) |
| simmenu.add_command(label='Stop', command = self.stop_sims) |
| if paramtype == 'electrical': |
| simmenu.add_command(label='Hints', |
| command = lambda param=param, simbutton=simbutton: self.add_hints(param, simbutton)) |
| simmenu.add_command(label='Edit', |
| command = lambda param=param: self.edit_param(param)) |
| simmenu.add_command(label='Copy', |
| command = lambda param=param: self.copy_param(param)) |
| if 'editable' in param and param['editable'] == True: |
| simmenu.add_command(label='Delete', |
| command = lambda param=param: self.delete_param(param)) |
| |
| # Attach the menu to the button |
| simbutton.config(menu=simmenu) |
| |
| # simbutton = ttk.Button(dframe, text=simtext, style = normbutton) |
| # command = lambda puniq=puniq: self.sim_param(puniq)) |
| |
| simbutton.grid(column = 9, row=n, sticky='ewns') |
| |
| if paramtype == 'electrical': |
| tooltip.ToolTip(simbutton, text = "Simulate one electrical parameter") |
| else: |
| tooltip.ToolTip(simbutton, text = "Check one physical parameter") |
| |
| # If 'pass', then just display message. If 'fail', then create a button that |
| # opens and configures the failure report window. |
| if status_value == '(not checked)': |
| bstyle=normbutton |
| stat_label = ttk.Label(dframe, text=status_value, style=bstyle) |
| else: |
| if status_value == 'fail': |
| bstyle=redbutton |
| else: |
| bstyle=greenbutton |
| if paramtype == 'electrical': |
| stat_label = ttk.Button(dframe, text=status_value, style=bstyle, |
| command = lambda param=param, globcond=globcond: |
| self.failreport.display(param, globcond, |
| self.cur_datasheet)) |
| elif p == 'LVS_errors': |
| dspath = os.path.split(self.cur_datasheet)[0] |
| datasheet = os.path.split(self.cur_datasheet)[1] |
| dsheet = self.datatop['data-sheet'] |
| designname = dsheet['ip-name'] |
| if self.origin.get() == 'Schematic Capture': |
| lvs_file = dspath + '/mag/precheck.log' |
| else: |
| lvs_file = dspath + '/mag/comp.out' |
| if not os.path.exists(lvs_file): |
| if os.path.exists(dspath + '/mag/precheck.log'): |
| lvs_file = dspath + '/mag/precheck.log' |
| elif os.path.exists(dspath + '/mag/comp.out'): |
| lvs_file = dspath + '/mag/comp.out' |
| |
| stat_label = ttk.Button(dframe, text=status_value, style=bstyle, |
| command = lambda lvs_file=lvs_file: self.textreport.display(lvs_file)) |
| else: |
| stat_label = ttk.Label(dframe, text=status_value, style=bstyle) |
| tooltip.ToolTip(stat_label, |
| text = "Show detail view of simulation conditions and results") |
| stat_label.grid(column = 8, row=n, sticky='ewns') |
| self.status[puniq] = stat_label |
| n += 1 |
| |
| for child in dframe.winfo_children(): |
| child.grid_configure(ipadx = 5, ipady = 1, padx = 2, pady = 2) |
| |
| # Check if a design submission and characterization may be in progress. |
| # If so, add the progress bar at the bottom. |
| self.check_ongoing_upload() |
| |
| if __name__ == '__main__': |
| faulthandler.register(signal.SIGUSR2) |
| options = [] |
| arguments = [] |
| for item in sys.argv[1:]: |
| if item.find('-', 0) == 0: |
| options.append(item) |
| else: |
| arguments.append(item) |
| |
| root = tkinter.Tk() |
| app = CACECharacterize(root) |
| if arguments: |
| print('Calling set_datasheet with argument ' + arguments[0]) |
| app.set_datasheet(arguments[0]) |
| |
| root.mainloop() |
