def highlight_search_pattern(data, pattern):
result = check_bit_shift(data, pattern)
if result == 0:
return (True, fg.green + hex_pad(data) + fg.rs)
elif result > 0:
return (True, fg.yellow + hex_pad(data) + fg.rs)
else:
return (False, hex_pad(data))
def gbld_cur_to_reg(cls, cur):
for reg in range(256):
reg = hex_pad(reg)
if cls.gbld_reg_to_cur(reg) < cur:
pass
else:
return reg
def check_bit_shift(data, expected=0xc4):
size = num_of_bit(hex_pad(expected))
for shift in range(size):
# We choose to shift DATA (This is chosen to make manipulating OUR
# hardware more easily).
if bit_shift(data, shift, size) == expected:
return shift
return -1
def scan_phase_elink(loop_result,
phases=DCB_ELK_VALID_PHASE,
selector=scan_phase_elink_selector):
printout = [list() for _ in range(len(phases) + 1)]
good_patterns_chs = defaultdict(lambda: defaultdict(list))
for ph, chs_data in loop_result.items():
idx = int(ph, base=16)
printout[idx].append(ph)
for ch, data in chs_data.items():
num_of_frame = len(data)
mode, freq = most_common(data)
mode_display = hex_pad(mode)
shift = check_bit_shift(mode)
selector(mode_display, freq, num_of_frame, shift, idx, ph, ch,
printout, good_patterns_chs)
# Now try to find optimum phases.
common_patterns = intersect_good_pattern(good_patterns_chs)
# Local optimal: Picking the longest good phase for the first channel.
# NOTE: This algorithm should be stable.
first_ch = next(iter(good_patterns_chs))
common_patterns_freq = {
k: len(good_patterns_chs[first_ch][k])
for k in common_patterns
}
pattern = Counter(common_patterns_freq).most_common(1)[0][0]
phase_per_ch = {
ch: mid_elem(good_patterns_chs[ch][pattern])
for ch in good_patterns_chs.keys()
}
good_phase_printout = [
phase_per_ch[i] for i in sorted(phase_per_ch, reverse=True)
]
# Update printout table.
for idx, ph in enumerate(good_phase_printout):
ph = int(ph, base=16)
printout[ph][idx + 1] = fg.li_green + printout[ph][idx + 1] + fg.rs
return printout, phase_per_ch, int(pattern, base=16)
def highlight_chs(data, ch, chs):
if ch in chs:
return (True, fg.blue + hex_pad(data) + fg.rs)
else:
return (False, hex_pad(data))
def highlight_non_mode(data, mode):
if data != mode:
return (True, fg.blue + hex_pad(data) + fg.rs)
else:
return (False, hex_pad(data))
else:
elk_op = input2bool('Continue to elink phase adjustment?')
if elk_op:
print('Generating phase-scanning table, this may take awhile...')
elk_scan_raw = loop_phase_elk(daq_chs, args.gbt, args.slave)
elk_scan_tab, elk_adj, elk_pattern = scan_phase_elink(elk_scan_raw)
print(
tabulate(elk_scan_tab,
headers=['phase'] + daq_chs,
colalign=['left'] + ['right'] * len(daq_chs)))
if len(elk_adj) == len(daq_chs):
print(
'Current fixed pattern is {}, adjusting DCB and SALT phase...'.
format(hex_pad(elk_pattern)))
adj_dcb_elink_phase(elk_adj, args.gbt, args.slave)
adj_salt_elink_phase(elk_pattern, args.gbt, args.bus, args.asic)
success = True
# Adjust TFC phase #########################################################
if args.adjust_tfc_phase is not None:
tfc_op = args.adjust_tfc_phase
else:
tfc_op = input2bool('Continue to TFC phase adjustment?')
if tfc_op:
salt_tfc_mode(args.gbt, args.bus, args.asic, mode='tfc')
print('Tuning TFC phase, this may take awhile...')
success = adj_salt_tfc_phase(daq_chs, args.gbt, args.bus, args.asic)