Fixed video, kbd and buzzer
This commit is contained in:
@@ -0,0 +1,189 @@
|
||||
#!/usr/bin/env python3
|
||||
#
|
||||
# This script reads A-Z80 instruction timing data from a spreadsheet text file
|
||||
# 'Timings.csv' (which is a TAB-delimited text file exported from 'Timings.xlsm')
|
||||
# and generates a Verilog include file defining the control block execution matrix.
|
||||
# Token keywords in the timing spreadsheet are substituted using a list of keys
|
||||
# defined in 'timing_macros.i'.
|
||||
#
|
||||
#-------------------------------------------------------------------------------
|
||||
# Copyright (C) 2014,2016 Goran Devic
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the GNU General Public License as published by the Free
|
||||
# Software Foundation; either version 2 of the License, or (at your option)
|
||||
# any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful, but WITHOUT
|
||||
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
# more details.
|
||||
#-------------------------------------------------------------------------------
|
||||
import string
|
||||
import sys
|
||||
import csv
|
||||
import os
|
||||
|
||||
# Input file (exported from 'Timings.xlsm'):
|
||||
fname = "Timings.csv"
|
||||
|
||||
# Input file containing macro substitution keys
|
||||
kname = "timing_macros.i"
|
||||
|
||||
# Set this to 1 if you want abbreviated matrix (no-action lines removed)
|
||||
abbr = 1
|
||||
|
||||
# Set this to 0 if you want to strip all comments from the resulting file
|
||||
comment = 1
|
||||
|
||||
# Set this to 1 if you want debug $display() printout on each PLA line
|
||||
debug = 0
|
||||
|
||||
# Print this string in front of every line that starts with "ctl_". This helps
|
||||
# formatting the output to be more readable.
|
||||
ctl_prefix = "\n"+" "*19
|
||||
|
||||
# Read in the content of the macro substitution file
|
||||
macros = []
|
||||
with open(kname, 'r') as f:
|
||||
for line in f:
|
||||
if len(line.strip())>0 and line[0]!='/':
|
||||
# Wrap up non-starting //-style comments into /* ... */ so the
|
||||
# line can be concatenated while preserving comments
|
||||
i = line.find("//")
|
||||
if i>0:
|
||||
if comment==1:
|
||||
macros.append( line.rstrip().replace("//", "/*", 1) + " */" )
|
||||
else:
|
||||
macros.append( line.rstrip()[0:i] )
|
||||
else:
|
||||
macros.append(line.rstrip())
|
||||
|
||||
# List of errors / keys and macros that did not match. We stash them as we go
|
||||
# and then print at the end so it is easier to find them
|
||||
errors = []
|
||||
|
||||
# Returns a substitution string given the section name (key) and the macro token
|
||||
# This is done by simply traversing macro substitution list of lines, finding a
|
||||
# section that starts with a :key and copying the substitution lines verbatim.
|
||||
def getSubst(key, token):
|
||||
subst = []
|
||||
multiline = False
|
||||
validset = False
|
||||
if key=="Comments": # Special case: ignore "Comments" column!
|
||||
return ""
|
||||
for l in macros:
|
||||
if multiline==True:
|
||||
# Multiline copies lines until a char at [0] is not a space
|
||||
if len(l.strip())==0 or l[0]!=' ':
|
||||
return '\n' + "\n".join(subst).rstrip()
|
||||
else:
|
||||
subst.append(l.rstrip())
|
||||
lx = l.split(' ') # Split the string and then ignore (duplicate)
|
||||
lx = list(filter(None, lx)) # spaces in the list left by the split()
|
||||
if l.startswith(":"): # Find and recognize a matching set (key) section
|
||||
if validset: # Error if there is a new section going from the macthing one
|
||||
break # meaning we did not find our macro in there
|
||||
if l[1:]==key:
|
||||
validset = True
|
||||
elif validset and lx[0]==token:
|
||||
if len(lx)==1:
|
||||
return ""
|
||||
if lx[1]=='\\': # Multi-line macro state starts with '\' character
|
||||
multiline = True
|
||||
continue
|
||||
lx.pop(0)
|
||||
s = " ".join(lx)
|
||||
return ' ' + s.strip()
|
||||
err = "{0} not in {1}".format(token, key)
|
||||
if err not in errors:
|
||||
errors.append(err)
|
||||
return " --- {0} ?? {1} --- ".format(token, key)
|
||||
|
||||
# Read the content of a file and using the csv reader and remove any quotes from the input fields
|
||||
content = [] # Content of the spreadsheet timing file
|
||||
with open(fname, 'r') as csvFile:
|
||||
reader = csv.reader(csvFile, delimiter='\t', quotechar='"')
|
||||
for row in reader:
|
||||
content.append('\t'.join(row))
|
||||
|
||||
# The first line is special: it contains names of sets for our macro substitutions
|
||||
tkeys = {} # Spreadsheet table column keys
|
||||
tokens = content.pop(0).split('\t')
|
||||
for col in range(len(tokens)):
|
||||
if len(tokens[col])==0:
|
||||
continue
|
||||
tkeys[col] = tokens[col]
|
||||
|
||||
# Process each line separately (stateless processor)
|
||||
imatrix = [] # Verilog execution matrix code
|
||||
for line in content:
|
||||
col = line.split('\t') # Split the string into a list of columns
|
||||
col_clean = list(filter(None, col)) # Removed all empty fields (between the separators)
|
||||
if len(col_clean)==0: # Ignore completely empty lines
|
||||
continue
|
||||
|
||||
if col_clean[0].startswith('//') and comment==1:
|
||||
imatrix.append(col_clean[0]) # Optionally print comment lines
|
||||
|
||||
if col_clean[0].startswith("#end"): # Print the end of a condition
|
||||
imatrix.append("end\n")
|
||||
|
||||
if col_clean[0].startswith('#if'): # Print the start of a condition
|
||||
s = col_clean[0]
|
||||
tag = s.find(":")
|
||||
condition = s[4:tag]
|
||||
imatrix.append("if ({0}) begin".format(condition.strip()))
|
||||
if debug and len(s[tag:])>1: # Print only in debug and there is something to print
|
||||
imatrix.append(" $display(\"{0}\");".format(s[4:]))
|
||||
|
||||
# We recognize 2 kinds of timing statements based on the starting characters:
|
||||
# "#0".. common timings using M and T cycles (M being optional)
|
||||
# "#always" timing that does not depend on M and T cycles (ex. ALU operations)
|
||||
if col_clean[0].startswith('#0') or col_clean[0].startswith('#always'):
|
||||
# M and T states are hard-coded in the table at the index 1 and 2
|
||||
if col_clean[0].startswith('#0'):
|
||||
if col[1]=='?': # M is optional, use '?' to skip it
|
||||
state = " if (T{0}) begin".format(col[2])
|
||||
else:
|
||||
state = " if (M{0} & T{1}) begin".format(col[1], col[2])
|
||||
else:
|
||||
state = " begin"
|
||||
|
||||
# Loop over all other columns and perform verbatim substitution
|
||||
action = ""
|
||||
for i in range(3,len(col)):
|
||||
# There may be multiple tokens separated by commas
|
||||
tokList = col[i].strip().split(',')
|
||||
tokList = list(filter(None, tokList)) # Filter out empty lines
|
||||
for token in tokList:
|
||||
token = token.strip()
|
||||
if i in tkeys and len(token)>0:
|
||||
macro = getSubst(tkeys[i], token)
|
||||
if macro.strip().startswith("ctl_"):
|
||||
action += ctl_prefix
|
||||
action += macro
|
||||
if state.find("ERROR")>=0:
|
||||
print ("{0} {1}".format(state, action))
|
||||
break
|
||||
|
||||
# Complete and write out a line
|
||||
if abbr and len(action)==0:
|
||||
continue
|
||||
imatrix.append("{0}{1} end".format(state, action))
|
||||
|
||||
# Create a file containing the logic matrix code
|
||||
with open('exec_matrix.vh', 'w') as file:
|
||||
if comment==1:
|
||||
file.write("// Automatically generated by genmatrix.py\n\n")
|
||||
# If there were errors, print them first (and output to the console)
|
||||
if len(errors)>0:
|
||||
for error in errors:
|
||||
print (error)
|
||||
file.write(error + "\n")
|
||||
file.write("-" * 80 + "\n")
|
||||
for item in imatrix:
|
||||
file.write("{}\n".format(item))
|
||||
|
||||
# Touch a file that includes 'exec_matrix.vh' to ensure it will recompile correctly
|
||||
os.utime("execute.v", None)
|
||||
Reference in New Issue
Block a user