def adc_calib_obj(spec):
base_expr = 'abs((a-1.0))+abs(modelError)'
base_expr += " + abs((b - round(b,{quantize})))"
expr = base_expr.format(quantize=1.0 / 128)
new_spec = spec.copy()
new_spec.objective = parser.parse_expr(expr)
return new_spec
def dac_calib_obj(spec,out_scale):
base_expr = '{deviate}*abs((a-1.0))+{gainOut}*abs(modelError)+abs(b)'
expr = base_expr.format(gainOut=1.0/out_scale, \
deviate=0.2, \
quantize=1.0/128)
new_spec = spec.copy()
new_spec.objective = parser.parse_expr(expr)
return new_spec
def mul_assign_calib_obj(spec,in0,in1,out):
base_expr = "{out}*abs(modelError)+{in0}*abs(u)+{in1}*abs(v)+{out}*abs(w)"
expr = base_expr.format(out=1.0/out, \
in0=1.0/in0, \
in1=1.0/in1)
new_spec = spec.copy()
new_spec.objective = parser.parse_expr(expr)
return new_spec
def mkmodel(blk,terms):
variables = list(map(lambda i: "c%d" % i, range(1,len(terms)+1))) \
+ ['c0']
expr = ['c0']
for coeff,term in zip(variables,terms):
expr.append("%s*%s" % (coeff,term))
expr_text = "+".join(expr)
expr_ast = parser.parse_expr(expr_text)
return PhysicalModelSpec.make(blk,expr_ast)
def __init__(self):
rulelib.Rule.__init__(self, "flip")
self.virt.add_input('a',blocklib.BlockSignalType.ANALOG, \
unifylib.UnifyConstraint.NONE)
self.virt.set_output(blocklib.BlockSignalType.ANALOG, \
unifylib.UnifyConstraint.NONE)
e = parser.parse_expr('-a')
self.virt.add_expr("*", e)
def vga_assign_calib_obj(spec,in0,out):
base_expr = "{out}*abs(modelError) + {out}*abs(v) + {in0}*abs(u) + {deviate}*abs((a-1.0))"
#base_expr += " + abs((b - round(b,{quantize})))"
expr = base_expr.format(out=1.0/out, \
in0=1.0/in0, \
deviate=0.005, \
quantize=1.0/128)
new_spec = spec.copy()
new_spec.objective = parser.parse_expr(expr)
return new_spec
def dac_calib_obj(spec,out_scale):
subobjs = [
("abs((a-1.0))", 1, 0.02), \
("abs((b))", 1, 0.01*out_scale), \
("abs(modelError)", 1, 0.001*(out_scale)), \
("abs(noise)", 1, 0.001*out_scale)
]
new_spec = spec.copy()
new_spec.objective = MultiObjective()
for expr,prio,eps in subobjs:
new_spec.objective.add(parser.parse_expr(expr), \
priority=prio,epsilon=eps)
return new_spec
def integ_calib_obj(spec, in_scale, out_scale):
# u : this has high error... don't fit this
exprs = [("abs((a-1.0))", 2, 0.02), ("abs((b-1.0))", 2, 0.01),
("abs(modelError)", 2, 0.001), ("abs(v)", 2, 0.001),
("abs(c)", 2, 0.005), ("abs(noise)", 2, 0.0001)]
new_spec = spec.copy()
new_spec.objective = MultiObjective()
for expr, priority, epsilon in exprs:
new_spec.objective.add(parser.parse_expr(expr), \
priority=priority, \
epsilon=epsilon)
return new_spec
def fan_calib_obj(spec, idx, out):
subobjs = [ \
("abs(modelError)",2,0.0001*out), \
("abs(b{idx})",2,0.0001*out), \
("abs((1.0-a{idx}))",2,0.01), \
("abs(noise)",2,0.00001*out)]
new_spec = spec.copy()
new_spec.objective = MultiObjective()
for subobj, prio, eps in subobjs:
expr = subobj.format(idx=idx)
new_spec.objective.add(parser.parse_expr(expr), prio, eps)
return new_spec
def adc_calib_obj(spec):
subobj = [
("abs((a-1.0))", 1, 0.05), \
("abs(modelError)", 1, 0.01), \
("abs(noise)", 1, 0.01), \
("abs(b)", 1, 0.01)
]
new_spec = spec.copy()
new_spec.objective = MultiObjective()
for expr, priority, eps in subobj:
new_spec.objective.add(parser.parse_expr(expr),
priority=priority, \
epsilon=eps)
return new_spec
def vga_assign_calib_obj(spec,in0_scale,out_scale):
#("abs((u))", 1, 0.001*in0_scale), \
subobjs = [
("abs((a-1.0))", 1, 0.02), \
("abs((b))", 1, 0.005), \
("abs((v))", 1, 0.001*out_scale), \
("abs(modelError)", 1, 0.001*out_scale), \
("abs(noise)", 1, 0.001*out_scale)
]
new_spec = spec.copy()
new_spec.objective = MultiObjective()
for expr,prio,eps in subobjs:
new_spec.objective.add(parser.parse_expr(expr), \
priority=prio,epsilon=eps)
return new_spec
import hwlib.hcdc.llenums as enums
from hwlib.block import *
import ops.opparse as parser
cin= Block('cin',BlockType.ROUTE, \
[enums.NoModeType])
cin.ll_name = "chip_input"
cin.modes.add_all([['*']])
cin.inputs.add(BlockInput('x', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.IN0))
cin.outputs.add(BlockOutput('z', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.OUT0))
cin.outputs['z'].relation.bind(['_'], \
parser.parse_expr('x'))
cin.inputs['x'] \
.interval.bind(['*'],interval.Interval(-20,20))
cin.outputs['z'] \
.interval.bind(['*'],interval.Interval(-20,20))
cout= Block('cout',BlockType.ROUTE, \
[enums.NoModeType])
cout.ll_name = "chip_output"
cout.modes.add_all([['*']])
cout.inputs.add(BlockInput('x', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.IN0))
cout.outputs.add(BlockOutput('z', BlockSignalType.ANALOG, \
import hwlib.hcdc.llenums as enums
from hwlib.block import *
import ops.opparse as parser
ext_out = Block('extout',BlockType.COMPUTE, \
[enums.NoModeType])
ext_out.ll_name = "chip_output"
ext_out.modes.add_all([["*"]])
ext_out.inputs.add(BlockInput('x', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.IN0))
ext_out.outputs.add(BlockOutput('z', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.OUT0, \
extern=True))
factor = 1.2 / 2.0
NOISE = 0.01
ext_out.outputs['z'].relation.bind(["*"], \
parser.parse_expr('emit((%s*x))' % factor))
ext_out.inputs['x'] \
.interval.bind(["*"],interval.Interval(-2,2))
ext_out.outputs['z'] \
.interval.bind(["*"],interval.Interval(-2*factor,2*factor))
ext_out.outputs['z'] \
.noise.bind(['*'],NOISE)
("abs(noise)",2,0.00001*out)]
new_spec = spec.copy()
new_spec.objective = MultiObjective()
for subobj, prio, eps in subobjs:
expr = subobj.format(idx=idx)
new_spec.objective.add(parser.parse_expr(expr), prio, eps)
return new_spec
for scale in ['m', 'h']:
for idx, port in enumerate([p_out0, p_out1, p_out2]):
pat = ['_', '_', '_', scale]
pat[idx] = '+'
fan.outputs[port.name].relation.bind(pat, parser.parse_expr('x'))
spec = DeltaSpec(parser.parse_expr('a{idx}*x+b{idx}'.format(idx=idx)))
#spec.param('a{idx}'.format(idx=idx),DeltaParamType.CORRECTABLE,ideal=1.0)
spec.param('a{idx}'.format(idx=idx), DeltaParamType.GENERAL, ideal=1.0)
spec.param('b{idx}'.format(idx=idx), DeltaParamType.GENERAL, ideal=0.0)
new_spec = fan_calib_obj(spec, idx, 1.0 if scale == 'm' else 10.0)
fan.outputs[port.name].deltas.bind(pat, new_spec)
pat[idx] = '-'
fan.outputs[port.name].relation.bind(pat, parser.parse_expr('-x'))
spec = DeltaSpec(parser.parse_expr('-a{idx}*x+b{idx}'.format(idx=idx)))
#spec.param('a{idx}'.format(idx=idx),DeltaParamType.CORRECTABLE,ideal=1.0)
spec.param('a{idx}'.format(idx=idx), DeltaParamType.GENERAL, ideal=1.0)
spec.param('b{idx}'.format(idx=idx), DeltaParamType.GENERAL, ideal=0.0)
new_spec = fan_calib_obj(spec, idx, 1.0 if scale == 'm' else 10.0)
fan.outputs[port.name].deltas.bind(pat, new_spec)
import hwlib.hcdc.llenums as enums
from hwlib.block import *
import ops.opparse as parser
adc = Block('adc',BlockType.COMPUTE, \
[enums.RangeType])
adc.modes.add_all([['m'], ['h']])
LOW_NOISE = 0.01
HIGH_NOISE = 0.1
adc.inputs.add(BlockInput('x', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.IN0))
adc.outputs.add(BlockOutput('z', BlockSignalType.DIGITAL, \
ll_identifier=enums.PortType.OUT0))
adc.outputs['z'].relation.bind(['m'], \
parser.parse_expr('0.5*x'))
adc.outputs['z'].relation.bind(['h'], \
parser.parse_expr('0.05*x'))
adc.inputs['x'] \
.noise.bind(['m'],LOW_NOISE)
adc.inputs['x'] \
.noise.bind(['h'],HIGH_NOISE)
MAX_FREQ = 40000.0
adc.outputs['z'] \
.freq_limit.bind(['_'], MAX_FREQ)
dac = Block('dac',BlockType.COMPUTE, \
[HLDACSourceType,enums.RangeType])
dac.modes.add_all([
['const','m'],
['const','h'],
['dyn','m'],
['dyn','h']
])
dac.inputs.add(BlockInput('x', BlockSignalType.DIGITAL, \
ll_identifier=enums.PortType.IN0))
dac.outputs.add(BlockOutput('z', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.OUT0))
dac.outputs['z'].relation.bind(['dyn','m'], \
parser.parse_expr('2.0*x'))
dac.outputs['z'].relation.bind(['dyn','h'], \
parser.parse_expr('20.0*x'))
dac.outputs['z'].relation.bind(['const','m'], \
parser.parse_expr('2.0*c'))
dac.outputs['z'].relation.bind(['const','h'], \
parser.parse_expr('20.0*c'))
dac.outputs['z'] \
.interval.bind(['_','h'],interval.Interval(-20,20))
dac.outputs['z'] \
.interval.bind(['_','m'],interval.Interval(-2,2))
LOW_NOISE = 0.01
HIGH_NOISE = 0.1
dac.outputs['z'] \
.freq_limit.bind(['_','_','_'], MAX_FREQ)
integ.data.add(BlockData('z0', BlockDataType.CONST))
DEL = 1.0 / 128
DIGITAL_RANGE_LOWER = 128
DIGITAL_RANGE_UPPER = 127
DIGITAL_QUANTIZE = 256
integ.data['z0'] \
.interval.bind(['_','_','_'],interval.Interval(-DEL*DIGITAL_RANGE_LOWER,DEL*DIGITAL_RANGE_UPPER))
integ.data['z0'] \
.quantize.bind(['_','_','_'],Quantize(DIGITAL_QUANTIZE,QuantizeType.LINEAR))
integ.outputs['z'].relation \
.bind(['m','m','+'],parser.parse_expr('integ(x,(2.0*z0))'))
integ.outputs['z'].relation \
.bind(['h','h','+'],parser.parse_expr('integ(x,(20.0*z0))'))
integ.outputs['z'].relation \
.bind(['m','h','+'],parser.parse_expr('integ((10.0*x),(20.0*z0))'))
integ.outputs['z'].relation \
.bind(['h','m','+'],parser.parse_expr('integ((0.1*x),(2.0*z0))'))
integ.outputs['z'].relation \
.bind(['m','m','-'],parser.parse_expr('-integ(x,(2.0*z0))'))
integ.outputs['z'].relation \
.bind(['h','h','-'],parser.parse_expr('-integ(x,(20.0*z0))'))
integ.outputs['z'].relation \
import hwlib.hcdc.llenums as enums
from hwlib.block import *
import ops.opparse as parser
ext_in = Block('extin',BlockType.COMPUTE, \
[enums.NoModeType])
ext_in.modes.add_all([["*"]])
ext_in.inputs.add(BlockInput('x', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.IN0, \
extern=True))
ext_in.outputs.add(BlockOutput('z', BlockSignalType.ANALOG, \
ll_identifier=enums.PortType.OUT0))
factor = 2.0
NOISE = 0.01
ext_in.outputs['z'].relation.bind(["*"], \
parser.parse_expr('%s*extvar(x)' % factor))
ext_in.inputs['x'] \
.interval.bind(["*"],interval.Interval(-2*factor,2*factor))
ext_in.outputs['z'] \
.noise.bind(['*'],NOISE)
ext_in.outputs['z'] \
.interval.bind(["*"],interval.Interval(-2,2))
mult.outputs['z'] \
.freq_limit.bind(['h','_','_'], MAX_FREQ)
mult.data.add(BlockData('c',BlockDataType.CONST))
DLT = 1/128.0
DIGITAL_RANGE_LOWER = 128
DIGITAL_RANGE_UPPER = 127
DIGITAL_QUANTIZE = 256
mult.data['c'] \
.interval.bind(['_','_','_'],interval.Interval(-DIGITAL_RANGE_LOWER*DLT,DIGITAL_RANGE_UPPER*DLT))
mult.data['c'] \
.quantize.bind(['_','_','_'],Quantize(DIGITAL_QUANTIZE,QuantizeType.LINEAR))
mult.outputs['z'].relation \
.bind(['x','m','m'],parser.parse_expr('c*x'))
mult.outputs['z'].relation \
.bind(['x','m','h'],parser.parse_expr('10.0*c*x'))
mult.outputs['z'].relation \
.bind(['x','h','m'],parser.parse_expr('0.1*c*x'))
mult.outputs['z'].relation \
.bind(['x','h','h'],parser.parse_expr('c*x'))
mult.outputs['z'].relation \
.bind(['m','m','m'],parser.parse_expr('0.5*x*y'))
mult.outputs['z'].relation \
.bind(['h','m','h'],parser.parse_expr('0.5*x*y'))
mult.outputs['z'].relation \
.bind(['m','h','h'],parser.parse_expr('0.5*x*y'))
mult.outputs['z'].relation \
.bind(['m','m','h'],parser.parse_expr('5.0*x*y'))
mult.outputs['z'].relation \
from hwlib.block import *
import ops.opparse as parser
lut = Block('lut',BlockType.COMPUTE, \
[enums.NoModeType])
lut.modes.add_all([['*']])
lut.inputs.add(BlockInput('x', BlockSignalType.DIGITAL, \
ll_identifier=enums.PortType.NOPORT))
lut.outputs.add(BlockOutput('z', BlockSignalType.DIGITAL, \
ll_identifier=enums.PortType.NOPORT))
lut.data.add(BlockData('e', BlockDataType.EXPR, \
inputs=['y']))
func_impl = parser.parse_expr('e')
lut.outputs['z'].relation.bind(['_'], \
parser.parse_expr('f(x)',{
'f':(['y'],func_impl)
}))
lut.inputs['x'] \
.interval.bind(['*'],interval.Interval(-1,0.9921875))
lut.outputs['z'] \
.interval.bind(['*'],interval.Interval(-1,0.9921875))
lut.inputs['x'] \
.quantize.bind(['*'],Quantize(256,QuantizeType.LINEAR,scale=1.0))
lut.outputs['z'] \
.quantize.bind(['*'],Quantize(256,QuantizeType.LINEAR,scale=1.0))
lut.state.add(BlockState('source', BlockStateType.CONNECTION, \
