def gen_model(real_vals, sint_vals, uint_vals, addr_bits, sint_bits, uint_bits,
real_type):
# create mixed-signal model
model = MixedSignalModel('model', build_dir=BUILD_DIR, real_type=real_type)
model.add_digital_input('addr', width=addr_bits)
model.add_digital_input('clk')
model.add_analog_output('real_out')
model.add_digital_output('sint_out', width=sint_bits)
model.add_digital_output('uint_out', width=uint_bits)
# create tables
real_table = model.make_real_table(real_vals)
sint_table = model.make_sint_table(sint_vals)
uint_table = model.make_uint_table(uint_vals)
# assign values
model.set_from_sync_rom(model.real_out,
real_table,
model.addr,
clk=model.clk)
model.set_from_sync_rom(model.sint_out,
sint_table,
model.addr,
clk=model.clk)
model.set_from_sync_rom(model.uint_out,
uint_table,
model.addr,
clk=model.clk)
# write the model
return model.compile_to_file(VerilogGenerator())
def __init__(self, filename=None, **system_values):
# set a fixed random seed for repeatability
np.random.seed(2)
module_name = Path(filename).stem
build_dir = Path(filename).parent
print(f'Running model generator for {module_name}...')
assert (all([req_val in system_values for req_val in self.required_values()])), \
f'Cannot build {module_name}, Missing parameter in config file'
m = MixedSignalModel(module_name, dt=system_values['dt'], build_dir=build_dir,
real_type=get_dragonphy_real_type())
m.add_real_param('t_del', 0)
m.add_digital_input('emu_rst')
m.add_digital_input('emu_clk')
m.add_analog_input('t_lo')
m.add_analog_input('t_hi')
m.add_analog_input('emu_dt')
m.add_analog_output('dt_req', init=m.t_del)
m.add_digital_output('clk_val')
# determine if the request was granted
m.bind_name('req_grant', m.dt_req == m.emu_dt)
# update the clock value
m.add_digital_state('prev_clk_val')
m.set_next_cycle(m.prev_clk_val, m.clk_val, clk=m.emu_clk, rst=m.emu_rst)
m.set_this_cycle(m.clk_val, if_(m.req_grant, ~m.prev_clk_val, m.prev_clk_val))
# determine arguments for formating time steps
# TODO: clean this up
dt_fmt_kwargs = dict(
range_=m.emu_dt.format_.range_,
width=m.emu_dt.format_.width,
exponent=m.emu_dt.format_.exponent
)
array_fmt_kwargs = deepcopy(dt_fmt_kwargs)
array_fmt_kwargs['real_range_hint'] = m.emu_dt.format_.range_
del array_fmt_kwargs['range_']
# determine the next period
dt_req_next_array = array([m.t_hi, m.t_lo], m.prev_clk_val, **array_fmt_kwargs)
m.bind_name('dt_req_next', dt_req_next_array, **dt_fmt_kwargs)
# increment the time request
m.bind_name('dt_req_incr', m.dt_req - m.emu_dt, **dt_fmt_kwargs)
# determine the next period
dt_req_imm_array = array([m.dt_req_incr, m.dt_req_next], m.req_grant, **array_fmt_kwargs)
m.bind_name('dt_req_imm', dt_req_imm_array, **dt_fmt_kwargs)
m.set_next_cycle(m.dt_req, m.dt_req_imm, clk=m.emu_clk, rst=m.emu_rst)
# generate the model
m.compile_to_file(VerilogGenerator())
self.generated_files = [filename]
def main():
model = MixedSignalModel('model')
model.add_analog_input('a')
model.add_digital_input('b', width=8)
model.add_digital_output('c', width=12)
model.bind_name('d', model.a + model.b)
clamped = clamp(to_sint(model.d, width=model.c.width + 1), 0, 1023)
model.set_next_cycle(model.c, to_uint(clamped, width=model.c.width))
model.compile_and_print(VerilogGenerator())
def main():
# define ports
m = MixedSignalModel('comparator')
m.add_analog_input('in_p')
m.add_analog_input('in_n')
m.add_digital_output('out', init=0)
m.add_digital_input('clk')
# define behavior
m.immediate_assign('out_async', m.in_p > m.in_n)
m.next_cycle_assign(m.out, m.out_async, clk=m.clk)
# write model
m.compile_and_print(VerilogGenerator())
def main():
ctrl = ExampleControl()
# define ports
m = MixedSignalModel('comparator', dt=ctrl.dt)
m.add_analog_input('in_p')
m.add_analog_input('in_n')
m.add_digital_output('out', init=0)
m.add_digital_input('clk')
# define behavior
m.immediate_assign('out_async', m.in_p > m.in_n)
m.next_cycle_assign(m.out, m.out_async, clk=m.clk, rst="1'b0")
# write model
ctrl.write_model(m)
def main():
print('Running model generator...')
# parse command line arguments
parser = ArgumentParser()
parser.add_argument('-o', '--output', type=str, default='build')
parser.add_argument('--dt', type=float, default=0.1e-6)
a = parser.parse_args()
# create the model
m = MixedSignalModel('osc', dt=a.dt)
m.add_digital_input('emu_clk')
m.add_digital_input('emu_rst')
m.add_digital_output('dt_req', 32)
m.add_digital_input('emu_dt', 32)
m.add_digital_input('neg_emu_dt', 32) # TODO: cleanup
m.add_digital_output('clk_val')
m.add_digital_input('t_lo', 32)
m.add_digital_input('t_hi', 32)
# determine if the request was granted
m.bind_name('req_grant', m.dt_req == m.emu_dt)
# update the clock value
m.add_digital_state('prev_clk_val')
m.set_next_cycle(m.prev_clk_val, m.clk_val, clk=m.emu_clk, rst=m.emu_rst)
m.set_this_cycle(m.clk_val, if_(m.req_grant, ~m.prev_clk_val, m.prev_clk_val))
# determine the next period
m.bind_name('dt_req_next', if_(m.prev_clk_val, m.t_lo, m.t_hi))
# increment the time request
m.bind_name('dt_req_incr', m.dt_req + m.neg_emu_dt)
# determine the next period
m.bind_name('dt_req_imm', if_(m.req_grant, m.dt_req_next, m.dt_req_incr))
m.set_next_cycle(m.dt_req, m.dt_req_imm[31:0], clk=m.emu_clk, rst=m.emu_rst)
# determine the output filename
filename = Path(a.output).resolve() / f'{m.module_name}.sv'
print(f'Model will be written to: {filename}')
# generate the model
m.compile_to_file(VerilogGenerator(), filename)
def main():
model = MixedSignalModel('model')
model.add_analog_input('a_in')
model.add_digital_output('d_out', width=8)
model.add_analog_output('a_out')
model.add_digital_input('d_in', width=8)
# DAC from 0 to 1V as the input code varies from 0-255
clamped = clamp(to_sint(model.a_in * 255, width=model.d_out.width + 1), 0,
255)
model.set_this_cycle(model.d_out, to_uint(clamped,
width=model.d_out.width))
# ADC code goes from 0-255 as input voltage goes from 0 to 1V
model.set_this_cycle(model.a_out, model.d_in / 255)
model.compile_and_print(VerilogGenerator())
def __init__(self, filename=None, **system_values):
# set a fixed random seed for repeatability
np.random.seed(3)
module_name = Path(filename).stem
build_dir = Path(filename).parent
#This is a wonky way of validating this.. :(
assert (all([req_val in system_values for req_val in self.required_values()])), \
f'Cannot build {module_name}, Missing parameter in config file'
m = MixedSignalModel(module_name,
dt=system_values['dt'],
build_dir=build_dir,
real_type=get_dragonphy_real_type())
# Random number generator seed (default generated with random.org)
m.add_digital_input('noise_seed', width=32)
# main I/O: input, output, and clock
m.add_analog_input('in_')
m.add_digital_output('out_sgn')
m.add_digital_output('out_mag', width=system_values['n'])
m.add_digital_input('clk_val')
# emulator clock and reset
m.add_digital_input('emu_clk')
m.add_digital_input('emu_rst')
# Noise controls
m.add_analog_input('noise_rms')
# determine when sampling should happen
m.add_digital_state('clk_val_prev')
m.set_next_cycle(m.clk_val_prev,
m.clk_val,
clk=m.emu_clk,
rst=m.emu_rst)
# detect a rising edge on the clock
m.bind_name('pos_edge', m.clk_val & (~m.clk_val_prev))
# delay the positive edge signal
m.add_digital_state('pos_edge_prev', init=0)
m.set_next_cycle(m.pos_edge_prev,
m.pos_edge,
clk=m.emu_clk,
rst=m.emu_rst)
# add noise
sample_noise = m.set_gaussian_noise('sample_noise',
std=m.noise_rms,
clk=m.emu_clk,
rst=m.emu_rst,
lfsr_init=m.noise_seed)
in_plus_noise = m.bind_name('in_plus_noise', m.in_ + sample_noise)
# determine out_sgn (note that the definition is opposite of the typical
# meaning; "0" means negative)
out_sgn = if_(in_plus_noise < 0, 0, 1)
m.set_next_cycle(m.out_sgn,
out_sgn,
clk=m.emu_clk,
rst=m.emu_rst,
ce=m.pos_edge_prev)
# determine out_mag
vref, n = system_values['vref'], system_values['n']
abs_val = if_(in_plus_noise < 0, -1.0 * in_plus_noise, in_plus_noise)
code_real_unclamped = (abs_val / vref) * ((2**(n - 1)) - 1)
code_real = clamp_op(code_real_unclamped, 0, (2**(n - 1)) - 1)
code_sint = to_sint(code_real, width=n + 1)
# TODO: clean this up -- since real ranges are not intervals, we need to tell MSDSL
# that the range of the signed integer is smaller
code_sint.format_ = SIntFormat(width=n + 1,
min_val=0,
max_val=(2**(n - 1)) - 1)
code_uint = to_uint(code_sint, width=n)
m.set_next_cycle(m.out_mag,
code_uint,
clk=m.emu_clk,
rst=m.emu_rst,
ce=m.pos_edge_prev)
# generate the model
m.compile_to_file(VerilogGenerator())
self.generated_files = [filename]
def __init__(self, filename=None, **system_values):
# set a fixed random seed for repeatability
np.random.seed(0)
module_name = Path(filename).stem
build_dir = Path(filename).parent
#This is a wonky way of validating this.. :(
assert (all([req_val in system_values for req_val in self.required_values()])), \
f'Cannot build {module_name}, Missing parameter in config file'
m = MixedSignalModel(module_name, dt=system_values['dt'], build_dir=build_dir,
real_type=get_dragonphy_real_type())
# Random number generator seeds (defaults generated with random.org)
m.add_digital_input('jitter_seed', width=32)
m.add_digital_input('noise_seed', width=32)
# Chunk of bits from the history; corresponding delay is bit_idx/freq_tx delay
m.add_digital_input('chunk', width=system_values['chunk_width'])
m.add_digital_input('chunk_idx', width=int(ceil(log2(system_values['num_chunks']))))
# Control code for the corresponding PI slice
m.add_digital_input('pi_ctl', width=system_values['pi_ctl_width'])
# Indicates sequencing of ADC slice within a bank (typically a static value)
m.add_digital_input('slice_offset', width=int(ceil(log2(system_values['slices_per_bank']))))
# Control codes that affect states in the slice
m.add_digital_input('sample_ctl')
m.add_digital_input('incr_sum')
m.add_digital_input('write_output')
# ADC sign and magnitude
m.add_digital_output('out_sgn')
m.add_digital_output('out_mag', width=system_values['n_adc'])
# Emulator clock and reset
m.add_digital_input('clk')
m.add_digital_input('rst')
# Noise controls
m.add_analog_input('jitter_rms')
m.add_analog_input('noise_rms')
# Create "placeholder function" that can be updated
# at runtime with the channel function
chan_func = PlaceholderFunction(
domain=system_values['func_domain'],
order=system_values['func_order'],
numel=system_values['func_numel'],
coeff_widths=system_values['func_widths'],
coeff_exps=system_values['func_exps']
)
# Check the function on a representative test case
chan = Filter.from_file(get_file('build/chip_src/adapt_fir/chan.npy'))
self.check_func_error(chan_func, chan.interp)
# Add digital inputs that will be used to reconfigure the function at runtime
wdata, waddr, we = add_placeholder_inputs(m=m, f=chan_func)
# Sample the pi_ctl code
m.add_digital_state('pi_ctl_sample', width=system_values['pi_ctl_width'])
m.set_next_cycle(m.pi_ctl_sample, m.pi_ctl, clk=m.clk, rst=m.rst, ce=m.sample_ctl)
# compute weights to apply to pulse responses
weights = []
for k in range(system_values['chunk_width']):
# create a weight value for this bit
weights.append(
m.add_analog_state(
f'weights_{k}',
range_=system_values['vref_tx']
)
)
# select a single bit from the chunk. chunk_width=1 is unfortunately
# a special case because some simulators don't support the bit-selection
# syntax on a single-bit variable
chunk_bit = m.chunk[k] if system_values['chunk_width'] > 1 else m.chunk
# write the weight value
m.set_next_cycle(
weights[-1],
if_(
chunk_bit,
system_values['vref_tx'],
-system_values['vref_tx']
),
clk=m.clk,
rst=m.rst
)
# Compute the delay due to the PI control code
delay_amt_pre = m.bind_name(
'delay_amt_pre',
m.pi_ctl_sample / ((2.0**system_values['pi_ctl_width'])*system_values['freq_rx'])
)
# Add jitter to the sampling time
if system_values['use_jitter']:
# create a signal to represent jitter
delay_amt_jitter = m.set_gaussian_noise(
'delay_amt_jitter',
std=m.jitter_rms,
lfsr_init=m.jitter_seed,
clk=m.clk,
ce=m.sample_ctl,
rst=m.rst
)
# add jitter to the delay amount (which might possibly yield a negative value)
delay_amt_noisy = m.bind_name('delay_amt_noisy', delay_amt_pre + delay_amt_jitter)
# make the delay amount non-negative
delay_amt = m.bind_name('delay_amt', if_(delay_amt_noisy >= 0.0, delay_amt_noisy, 0.0))
else:
delay_amt = delay_amt_pre
# Compute the delay due to the slice offset
t_slice_offset = m.bind_name('t_slice_offset', m.slice_offset/system_values['freq_rx'])
# Add the delay amount to the slice offset
t_samp_new = m.bind_name('t_samp_new', t_slice_offset + delay_amt)
# Determine if the new sampling time happens after the end of this period
t_one_period = m.bind_name('t_one_period', system_values['slices_per_bank']/system_values['freq_rx'])
exceeds_period = m.bind_name('exceeds_period', t_samp_new >= t_one_period)
# Save the previous sample time
t_samp_prev = m.add_analog_state('t_samp_prev', range_=system_values['slices_per_bank']/system_values['freq_rx'])
m.set_next_cycle(t_samp_prev, t_samp_new-t_one_period, clk=m.clk, rst=m.rst, ce=m.sample_ctl)
# Save whether the previous sample time exceeded one period
prev_exceeded = m.add_digital_state('prev_exceeded')
m.set_next_cycle(prev_exceeded, exceeds_period, clk=m.clk, rst=m.rst, ce=m.sample_ctl)
# Compute the sample time to use for this period
t_samp_idx = m.bind_name('t_samp_idx', concatenate([exceeds_period, prev_exceeded]))
t_samp = m.bind_name(
't_samp',
array(
[
t_samp_new, # 0b00: exceeds_period=0, prev_exceeded=0
t_samp_new, # 0b01: exceeds_period=0, prev_exceeded=1
0.0, # 0b10: exceeds_period=1, prev_exceeded=0
t_samp_prev # 0b11: exceeds_period=1, prev_exceeded=1
], t_samp_idx
)
)
# Evaluate the step response function. Note that the number of evaluation times is the
# number of chunks plus one.
f_eval = []
for k in range(system_values['chunk_width']+1):
# compute change time as an integer multiple of the TX period
chg_idx = m.bind_name(
f'chg_idx_{k}', (
system_values['slices_per_bank']*system_values['num_banks']
- (m.chunk_idx+1)*system_values['chunk_width']
+ k
)
)
# scale by TX period
t_chg = m.bind_name(f't_chg_{k}', chg_idx/system_values['freq_tx'])
# compute the kth evaluation time
t_eval = m.bind_name(f't_eval_{k}', t_samp - t_chg)
# evaluate the function (the last three inputs are used for updating the function contents)
f_eval.append(m.set_from_sync_func(f'f_eval_{k}', chan_func, t_eval, clk=m.clk, rst=m.rst,
wdata=wdata, waddr=waddr, we=we))
# Compute the pulse responses for each bit
pulse_resp = []
for k in range(system_values['chunk_width']):
pulse_resp.append(
m.bind_name(
f'pulse_resp_{k}',
weights[k]*(f_eval[k] - f_eval[k+1])
)
)
# sum up all of the pulse responses
pulse_resp_sum = m.bind_name('pulse_resp_sum', sum_op(pulse_resp))
# update the overall sample value
sample_value_pre = m.add_analog_state('analog_sample_pre', range_=5*system_values['vref_rx'])
m.set_next_cycle(
sample_value_pre,
if_(m.incr_sum, sample_value_pre + pulse_resp_sum, pulse_resp_sum),
clk=m.clk,
rst=m.rst
)
# add noise to the sample value
if system_values['use_noise']:
sample_noise = m.set_gaussian_noise(
'sample_noise',
std=m.noise_rms,
clk=m.clk,
rst=m.rst,
ce=m.write_output,
lfsr_init=m.noise_seed
)
sample_value = m.bind_name('sample_value', sample_value_pre + sample_noise)
else:
sample_value = sample_value_pre
# there is a special case in which the output should not be updated:
# when the previous cycle did not exceed the period, but this one did
# in that case the sample value should be held constant
should_write_output = m.bind_name('should_write_output',
(prev_exceeded | (~exceeds_period)) & m.write_output)
# determine out_sgn (note that the definition is opposite of the typical
# meaning; "0" means negative)
out_sgn = if_(sample_value < 0, 0, 1)
m.set_next_cycle(m.out_sgn, out_sgn, clk=m.clk, rst=m.rst, ce=should_write_output)
# determine out_mag
vref_rx, n_adc = system_values['vref_rx'], system_values['n_adc']
abs_val = m.bind_name('abs_val', if_(sample_value < 0, -1.0*sample_value, sample_value))
code_real_unclamped = m.bind_name('code_real_unclamped', (abs_val / vref_rx) * ((2**(n_adc-1))-1))
code_real = m.bind_name('code_real', clamp_op(code_real_unclamped, 0, (2**(n_adc-1))-1))
# TODO: clean this up -- since real ranges are not intervals, we need to tell MSDSL
# that the range of the signed integer is smaller
code_sint = to_sint(code_real, width=n_adc+1)
code_sint.format_ = SIntFormat(width=n_adc+1, min_val=0, max_val=(2**(n_adc-1))-1)
code_sint = m.bind_name('code_sint', code_sint)
code_uint = m.bind_name('code_uint', to_uint(code_sint, width=n_adc))
m.set_next_cycle(m.out_mag, code_uint, clk=m.clk, rst=m.rst, ce=should_write_output)
# generate the model
m.compile_to_file(VerilogGenerator())
self.generated_files = [filename]
def __init__(self, filename=None, **system_values):
# set a fixed random seed for repeatability
np.random.seed(1)
module_name = Path(filename).stem
build_dir = Path(filename).parent
#This is a wonky way of validating this.. :(
assert (all([req_val in system_values for req_val in self.required_values()])), \
f'Cannot build {module_name}, Missing parameter in config file'
# instantiate model
m = MixedSignalModel(module_name, dt=system_values['dt'], build_dir=build_dir)
# main I/O: delay code and gain
m.add_digital_input('code', width=system_values['n_bits'])
m.add_digital_input('clk_i_val')
m.add_digital_output('clk_o_val')
# timestep control: DT request and response
m.add_analog_output('dt_req')
m.add_analog_input('emu_dt')
# emulator clock and reset
m.add_digital_input('emu_clk')
m.add_digital_input('emu_rst')
# additional input: maximum timestep
# TODO: clean this up
m.add_analog_input('dt_req_max')
# jitter control
m.add_digital_input('jitter_seed', width=32)
m.add_analog_input('jitter_rms')
# compute the delay (with no jitter)
m.bind_name('delay_amt_pre', m.code * (system_values['t_per'] / (2.0 ** system_values['n_bits'])))
# add jitter to the delay amount (which might possibly yield a negative value)
m.set_gaussian_noise('t_jitter', std=m.jitter_rms, clk=m.emu_clk,
rst=m.emu_rst, lfsr_init=m.jitter_seed)
m.bind_name('delay_amt_noisy', m.delay_amt_pre + m.t_jitter)
# make the delay amount non-negative
m.bind_name('delay_amt', if_(m.delay_amt_noisy >= 0.0, m.delay_amt_noisy, 0.0))
# determine when the clock value has changed
m.add_digital_state('clk_i_val_prev')
m.set_next_cycle(m.clk_i_val_prev, m.clk_i_val, clk=m.emu_clk, rst=m.emu_rst)
m.bind_name('clk_edge', m.clk_i_val ^ m.clk_i_val_prev)
# create pointer that advances each time there is a clock edge
depth = system_values['depth']
dbits = int(ceil(log2(depth)))
m.add_digital_state('addr', width=dbits)
m.add_digital_state('next_addr', width=dbits)
m.set_this_cycle(m.next_addr, if_(m.addr == (depth-1), 0, m.addr+1))
m.set_next_cycle(m.addr, m.next_addr, clk=m.emu_clk, rst=m.emu_rst, ce=m.clk_edge)
# convenience function for formatting DT signals
def add_dt_state(*args, range_=m.emu_dt.format_.range_, width=m.emu_dt.format_.width,
exponent=m.emu_dt.format_.exponent, **kwargs):
return m.add_analog_state(*args, range_=range_, width=width, exponent=exponent, **kwargs)
# convenience function for formatting DT signals
def dt_array(*args, real_range_hint=m.emu_dt.format_.range_, width=m.emu_dt.format_.width,
exponent=m.emu_dt.format_.exponent, **kwargs):
return array(*args, real_range_hint=real_range_hint, width=width, exponent=exponent,
**kwargs)
# instantiate delay "units" that each keep track of one edge
dt_req = []
req_data = []
req_grant = []
req_valid = []
for k in range(depth):
# should load data if there is a clock edge and this slice is selected
load_data = m.bind_name(f'load_data_{k}', m.clk_edge & (k == m.addr))
# handle update of dt_req
dt_req.append(add_dt_state(f'dt_req_{k}'))
m.set_next_cycle(
dt_req[-1],
if_(load_data, m.delay_amt, dt_req[-1] - m.emu_dt),
clk=m.emu_clk,
rst=m.emu_rst
)
# handle update of req_data
req_data.append(m.add_digital_state(f'req_data_{k}'))
m.set_next_cycle(req_data[-1], m.clk_i_val, ce=load_data,
clk=m.emu_clk, rst=m.emu_rst)
# handle update of req_grant
req_grant.append(m.bind_name(f'req_grant_{k}', dt_req[-1] == m.emu_dt))
# handle update of req_valid
req_valid.append(m.add_digital_state(f'req_valid_{k}'))
m.set_next_cycle(req_valid[-1], (req_valid[-1] & (~req_grant[-1])) | load_data,
clk=m.emu_clk, rst=m.emu_rst)
# replace dt_req with dt_req_max for invalid requests
dt_req_mux = []
for k in range(depth):
dt_req_mux.append(
m.bind_name(
f'dt_req_mux_{k}',
dt_array(
[m.dt_req_max, dt_req[k]],
req_valid[k],
)
)
)
# convenience function to find the minimum DT request using a tree structure
counter = count()
def tree_min(data):
# check cases
if len(data) == 0:
raise Exception("This shouldn't happen...")
elif len(data) == 1:
return data[0]
else:
val0 = tree_min(data[:len(data)//2])
val1 = tree_min(data[len(data)//2:])
return m.bind_name(
f'dt_intern_{next(counter)}',
dt_array(
[val0, val1],
val1 < val0,
)
)
# set the "dt_req" output to the minimum time request (where invalid requests
# are replaced with "dt_req_max"
m.set_this_cycle(m.dt_req, tree_min(dt_req_mux))
# determine if the output should be set or cleared
set_out = req_grant[0] & req_valid[0] & req_data[0]
clr_out = req_grant[0] & req_valid[0] & (~req_data[0])
for k in range(1, depth):
set_out = set_out | (req_grant[k] & req_valid[k] & req_data[k])
clr_out = clr_out | (req_grant[k] & req_valid[k] & (~req_data[k]))
m.bind_name('set_out', set_out)
m.bind_name('clr_out', clr_out)
# set output, clear output, or keep it the same
m.add_digital_state('clk_o_val_prev')
m.set_next_cycle(m.clk_o_val_prev, m.clk_o_val, clk=m.emu_clk, rst=m.emu_rst)
m.set_this_cycle(m.clk_o_val, (m.clk_o_val_prev & (~m.clr_out)) | (m.set_out))
# generate the model
m.compile_to_file(VerilogGenerator())
self.generated_files = [filename]