def update(self):
if self.read_callback is not None:
val = self.read_callback(
) if self.read_callback_params is None else self.read_callback(
self.read_callback_params)
if self.is_progress_bar:
val = int(val)
val_percent = (val / self.progress_bar_range) * 100
self.value_label._percentage = val_percent if val_percent <= 100.0 else 100.0
self.value_label.label.text = "%d" % val
else:
self.value_label.text = ANSI(val)
elif self.value_format_str is None:
val = rw.read_reg(self.regs[0], verbose=False)
if self.is_progress_bar:
val_percent = (val / self.progress_bar_range) * 100
self.value_label._percentage = val_percent if val_percent <= 100.0 else 100.0
self.value_label.label.text = "%d" % val
else:
self.value_label.text = ANSI(val.to_string())
else:
vals = []
for reg in self.regs:
vals.append(rw.read_reg(reg, verbose=False))
val_str = self.value_format_str % tuple(vals)
self.value_label.text = ANSI(val_str)
def get_l1a_fifo_state(self):
data_cnt = rw.read_reg("BEFE.%s.DAQ.STATUS.L1A_FIFO_DATA_CNT" %
self.gem_csc,
verbose=False)
unf = rw.read_reg("BEFE.%s.DAQ.STATUS.L1A_FIFO_IS_UNDERFLOW" %
self.gem_csc,
verbose=False)
full = rw.read_reg("BEFE.%s.DAQ.STATUS.L1A_FIFO_IS_FULL" %
self.gem_csc,
verbose=False)
afull = rw.read_reg("BEFE.%s.DAQ.STATUS.L1A_FIFO_IS_NEAR_FULL" %
self.gem_csc,
verbose=False)
empty = rw.read_reg("BEFE.%s.DAQ.STATUS.L1A_FIFO_IS_EMPTY" %
self.gem_csc,
verbose=False)
if 0xdeaddead in [data_cnt, unf, full, afull, empty]:
return color_string("BUS_ERROR", rw.RegVal.STATE_BAD)
if unf == 1:
return color_string("%d UNDERFLOW" % data_cnt, rw.RegVal.STATE_BAD)
elif full == 1:
return color_string("%d FULL" % data_cnt, rw.RegVal.STATE_BAD)
elif afull == 1:
return color_string("%d NEAR FULL" % data_cnt,
rw.RegVal.STATE_WARN)
elif empty == 1:
return color_string("%d EMPTY" % data_cnt, rw.RegVal.STATE_GOOD)
else:
return color_string("%d" % data_cnt, rw.RegVal.STATE_GOOD)
def __init__(self, config={}, verbose=False):
# check if it's CSC or GEM firmware
fw_flavor = rw.read_reg("BEFE.SYSTEM.RELEASE.FW_FLAVOR")
if fw_flavor == 0xdeaddead:
exit()
self.gem_csc = fw_flavor.to_string(use_color=False)
self.is_csc = True if "CSC" in self.gem_csc else False
if verbose:
print("%s DAQ configuration:" % self.gem_csc)
for config_name in self.config_names:
if config_name in config:
self.config[config_name] = config[config_name]
elif utils.config_exists("CONFIG_DAQ_" + config_name):
self.config[config_name] = utils.get_config("CONFIG_DAQ_" +
config_name)
elif utils.config_exists("CONFIG_" + config_name):
self.config[config_name] = utils.get_config("CONFIG_" +
config_name)
else:
raise Exception("ERROR: config %s not found" % config_name)
if verbose:
print(" %s = %d" % (config_name, self.config[config_name]))
def get_ldaq_state(self):
big_evt = rw.read_reg("BEFE.%s.DAQ.STATUS.SPY.ERR_BIG_EVENT" %
self.gem_csc,
verbose=False)
eoe_not_found = rw.read_reg(
"BEFE.%s.DAQ.STATUS.SPY.ERR_EOE_NOT_FOUND" % self.gem_csc,
verbose=False)
if 0xdeaddead in [big_evt, eoe_not_found]:
return color_string("BUS_ERROR", rw.RegVal.STATE_BAD)
status = ""
if big_evt == 1:
status += color_string("EVENT_TOO_BIG", rw.RegVal.STATE_BAD) + " "
if eoe_not_found == 1:
status += color_string("EOE_NOT_FOUND", rw.RegVal.STATE_BAD) + " "
if len(status) == 0:
status = color_string("NORMAL", rw.RegVal.STATE_GOOD)
return status
def get_input_status(self, params):
idx = params["idx"]
in_mask = rw.read_reg('BEFE.%s.DAQ.CONTROL.INPUT_ENABLE_MASK' %
self.gem_csc,
verbose=False)
in_ovf = rw.read_reg("BEFE.%s.DAQ.%s%d.STATUS.INPUT_FIFO_HAD_OFLOW" %
(self.gem_csc, self.dmb_oh, idx),
verbose=False)
in_unf = rw.read_reg("BEFE.%s.DAQ.%s%d.STATUS.INPUT_FIFO_HAD_UFLOW" %
(self.gem_csc, self.dmb_oh, idx),
verbose=False)
evt_ovf = rw.read_reg("BEFE.%s.DAQ.%s%d.STATUS.EVENT_FIFO_HAD_OFLOW" %
(self.gem_csc, self.dmb_oh, idx),
verbose=False)
evt_size_err = rw.read_reg("BEFE.%s.DAQ.%s%d.STATUS.EVT_SIZE_ERR" %
(self.gem_csc, self.dmb_oh, idx),
verbose=False)
evt_64b_err = rw.read_reg(
"BEFE.%s.DAQ.%s%d.STATUS.EVT_64BIT_ALIGN_ERR" %
(self.gem_csc, self.dmb_oh, idx),
verbose=False) if self.is_csc else 0
if 0xdeaddead in [
in_mask, in_ovf, in_unf, evt_ovf, evt_size_err, evt_64b_err
]:
return color_string("BUS_ERROR", rw.RegVal.STATE_BAD)
if (in_mask >> idx) & 1 == 0:
return "DISABLED"
status = ""
if in_ovf == 1:
status += color_string("IN_OVF ", rw.RegVal.STATE_BAD)
if in_unf == 1:
status += color_string("IN_UNF ", rw.RegVal.STATE_BAD)
if evt_ovf == 1:
status += color_string("EVT_OVF ", rw.RegVal.STATE_BAD)
if evt_size_err == 1:
status += color_string("SIZE_ERR ", rw.RegVal.STATE_BAD)
if evt_64b_err == 1:
status += color_string("64BIT_ERR ", rw.RegVal.STATE_BAD)
if len(status) == 0:
status = color_string("OK", rw.RegVal.STATE_GOOD)
return status
def init_container(self):
# configuration section
state = TopStatusItem("State", None, read_callback=self.get_state)
input_en_mask = TopStatusItem(
"Input Enable Mask",
"BEFE.%s.DAQ.CONTROL.INPUT_ENABLE_MASK" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_input_en_mask)
ignore_daqlink = TopStatusItem(
"Ignore DAQLink",
"BEFE.%s.DAQ.CONTROL.IGNORE_DAQLINK" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_ignore_daqlink)
wait_for_resync = TopStatusItem(
"Wait For Resync",
"BEFE.%s.DAQ.CONTROL.RESET_TILL_RESYNC" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_wait_for_resync)
freeze_on_error = TopStatusItem(
"Freeze on Error",
"BEFE.%s.DAQ.CONTROL.FREEZE_ON_ERROR" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_freeze_on_error)
if self.is_csc:
gen_local_l1a = TopStatusItem(
"Generate Internal L1A",
"BEFE.%s.DAQ.CONTROL.L1A_REQUEST_EN" % self.gem_csc,
reg_val_bad="self != %d" % int(not self.cfg_use_tcds))
spy_skip_empty = TopStatusItem(
"Local DAQ Skip Empty",
"BEFE.%s.DAQ.CONTROL.SPY.SPY_SKIP_EMPTY_EVENTS" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_spy_skip_empty)
tts_override = TopStatusItem(
"TTS Override", "BEFE.%s.DAQ.CONTROL.TTS_OVERRIDE" % self.gem_csc)
fed_id = TopStatusItem("FED ID",
"BEFE.%s.DAQ.CONTROL.FED_ID" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_fed_id)
board_id = TopStatusItem("RUI ID" if self.is_csc else "Board ID",
"BEFE.SYSTEM.CTRL.BOARD_ID",
reg_val_bad="self != %d" % self.cfg_board_id)
dav_timeout = TopStatusItem(
"DAV Timeout", "BEFE.%s.DAQ.CONTROL.DAV_TIMEOUT" % self.gem_csc)
# spy_config = TopStatusItem("Local DAQ", ["BEFE.%s.DAQ.CONTROL.SPY.SPY_PRESCALE" % self.gem_csc, "BEFE.%s.DAQ.CONTROL.SPY.SPY_SKIP_EMPTY_EVENTS" % self.gem_csc],
# reg_val_bad=["self != %d" % self.cfg_spy_prescale, "self != %d" % self.cfg_spy_skip_empty],
# value_format_str="Prescale %s, %s")
spy_prescale = TopStatusItem(
"Local DAQ Prescale",
"BEFE.%s.DAQ.CONTROL.SPY.SPY_PRESCALE" % self.gem_csc,
reg_val_bad="self != %d" % self.cfg_spy_prescale)
config_items = []
if self.is_csc:
config_items = [
state, input_en_mask, ignore_daqlink, wait_for_resync,
freeze_on_error, gen_local_l1a, tts_override, fed_id, board_id,
dav_timeout, spy_prescale, spy_skip_empty
]
if self.is_gem:
config_items = [
state, input_en_mask, ignore_daqlink, wait_for_resync,
freeze_on_error, tts_override, fed_id, board_id, dav_timeout,
spy_prescale
]
self.sec_config = TopSection("Configuration",
config_items,
height=None)
# state section
self.sec_state = TopSection(
"State",
[
TopStatusItem("Reset",
"BEFE.%s.DAQ.CONTROL.RESET" % self.gem_csc,
reg_val_bad="self == 1"),
TopStatusItem("Enabled",
"BEFE.%s.DAQ.CONTROL.DAQ_ENABLE" % self.gem_csc,
reg_val_bad="self == 0"),
TopStatusItem("L1A Enabled",
"BEFE.%s.TTC.CTRL.L1A_ENABLE" % self.gem_csc),
TopStatusItem("BC0 Locked",
"BEFE.%s.TTC.STATUS.BC0.LOCKED" % self.gem_csc),
TopStatusItem("Events Sent",
"BEFE.%s.DAQ.STATUS.EVT_SENT" % self.gem_csc),
TopStatusItem(
"LDAQ Events Sent",
"BEFE.%s.DAQ.STATUS.SPY.SPY_EVENTS_SENT" % self.gem_csc),
TopStatusItem("L1A ID",
"BEFE.%s.DAQ.STATUS.L1AID" % self.gem_csc),
TopStatusItem(
"DAQLink Ready",
"BEFE.%s.DAQ.STATUS.DAQ_LINK_RDY" % self.gem_csc),
TopStatusItem("TTS State",
"BEFE.%s.DAQ.STATUS.TTS_STATE" % self.gem_csc),
TopStatusItem(
"TTS Warning Cnt",
"BEFE.%s.DAQ.STATUS.TTS_WARN_CNT" % self.gem_csc),
TopStatusItem(
"Backpressure",
"BEFE.%s.DAQ.STATUS.DAQ_BACKPRESSURE" % self.gem_csc),
TopStatusItem(
"Backpressure Cnt",
"BEFE.%s.DAQ.STATUS.DAQ_BACKPRESSURE_CNT" % self.gem_csc),
TopStatusItem(
"Max DAV Timer",
"BEFE.%s.DAQ.STATUS.MAX_DAV_TIMER" % self.gem_csc),
TopStatusItem(
"L1A FIFO Had Overflow",
"BEFE.%s.DAQ.STATUS.L1A_FIFO_HAD_OVERFLOW" % self.gem_csc),
TopStatusItem(
"L1A FIFO Had Underflow",
"BEFE.%s.DAQ.STATUS.L1A_FIFO_HAD_OVERFLOW" % self.gem_csc),
TopStatusItem(
"L1A FIFO Near Full Cnt",
"BEFE.%s.DAQ.STATUS.L1A_FIFO_NEAR_FULL_CNT" %
self.gem_csc),
TopStatusItem(
"L1A FIFO Had Overflow",
"BEFE.%s.DAQ.STATUS.L1A_FIFO_HAD_OVERFLOW" % self.gem_csc),
TopStatusItem(
"Out FIFO Had Overflow",
"BEFE.%s.DAQ.STATUS.DAQ_OUTPUT_FIFO_HAD_OVERFLOW" %
self.gem_csc),
TopStatusItem(
"Out FIFO Near Full Cnt",
"BEFE.%s.DAQ.STATUS.DAQ_FIFO_NEAR_FULL_CNT" %
self.gem_csc),
TopStatusItem(
"LDAQ FIFO Had Overflow",
"BEFE.%s.DAQ.STATUS.SPY.ERR_SPY_FIFO_HAD_OFLOW" %
self.gem_csc),
TopStatusItem(
"LDAQ FIFO Near Full Cnt",
"BEFE.%s.DAQ.STATUS.SPY.SPY_FIFO_AFULL_CNT" %
self.gem_csc),
TopStatusItem(
"LDAQ Status", None, read_callback=self.get_ldaq_state),
TopStatusItem("L1A Rate",
"BEFE.%s.TTC.L1A_RATE" % self.gem_csc),
TopStatusItem(
"Output Datarate",
"BEFE.%s.DAQ.STATUS.DAQ_WORD_RATE" % self.gem_csc),
TopStatusItem(
"Local DAQ Datarate",
"BEFE.%s.DAQ.STATUS.SPY.SPY_WORD_RATE" % self.gem_csc),
# TopStatusItem("L1A FIFO Status", None, read_callback=self.get_l1a_fifo_state),
TopStatusItem("L1A Rate",
"BEFE.%s.TTC.L1A_RATE" % self.gem_csc,
is_progress_bar=True,
progress_bar_range=100000),
TopStatusItem(
"Output Datarate",
"BEFE.%s.DAQ.STATUS.DAQ_WORD_RATE" % self.gem_csc,
is_progress_bar=True,
progress_bar_range=100000000),
TopStatusItem(
"Local DAQ Datarate",
"BEFE.%s.DAQ.STATUS.SPY.SPY_WORD_RATE" % self.gem_csc,
is_progress_bar=True,
progress_bar_range=62500000),
TopStatusItem(
"L1A FIFO Data Cnt",
"BEFE.%s.DAQ.STATUS.L1A_FIFO_DATA_CNT" % self.gem_csc,
is_progress_bar=True,
progress_bar_range=8192),
TopStatusItem(
"DAQ FIFO Data Cnt",
"BEFE.%s.DAQ.STATUS.DAQ_FIFO_DATA_CNT" % self.gem_csc,
is_progress_bar=True,
progress_bar_range=8192),
])
# input section
num_inputs = 0
if self.is_csc:
num_inputs = rw.read_reg(
"BEFE.CSC_FED.CSC_SYSTEM.RELEASE.NUM_OF_DMBS", verbose=False)
elif self.is_gem:
num_inputs = rw.read_reg("BEFE.GEM.GEM_SYSTEM.RELEASE.NUM_OF_OH",
verbose=False)
else:
raise ValueError("It's not GEM nor CSC hmm")
if num_inputs == 0xdeaddead:
num_inputs = 0
col_titles = [
"TTS State", "Status", "EvN", "Bitrate", "In Warn", "Evt Warn",
"In FIFO", "Evt FIFO"
]
rows = []
for input in range(num_inputs):
si_tts_state = TopStatusItem(
None, "BEFE.%s.DAQ.%s%d.STATUS.TTS_STATE" %
(self.gem_csc, self.dmb_oh, input))
si_input_status = TopStatusItem(
None,
None,
read_callback=self.get_input_status,
read_callback_params={"idx": input})
si_evn = TopStatusItem(
None, "BEFE.%s.DAQ.%s%d.COUNTERS.EVN" %
(self.gem_csc, self.dmb_oh, input))
if self.is_csc:
si_data_rate = TopStatusItem(
None, "BEFE.%s.DAQ.%s%d.COUNTERS.DATA_WORD_RATE" %
(self.gem_csc, self.dmb_oh, input))
elif self.is_gem:
si_data_rate = TopStatusItem(
None, "BEFE.%s.DAQ.%s%d.COUNTERS.VFAT_BLOCK_RATE" %
(self.gem_csc, self.dmb_oh, input))
si_infifo_warn_cnt = TopStatusItem(
None, "BEFE.%s.DAQ.%s%d.COUNTERS.INPUT_FIFO_NEAR_FULL_CNT" %
(self.gem_csc, self.dmb_oh, input))
si_evtfifo_warn_cnt = TopStatusItem(
None, "BEFE.%s.DAQ.%s%d.COUNTERS.EVT_FIFO_NEAR_FULL_CNT" %
(self.gem_csc, self.dmb_oh, input))
si_infifo_data_cnt = TopStatusItem(
None,
"BEFE.%s.DAQ.%s%d.COUNTERS.INPUT_FIFO_DATA_CNT" %
(self.gem_csc, self.dmb_oh, input),
is_progress_bar=True,
progress_bar_range=16384)
si_evtfifo_data_cnt = TopStatusItem(
None,
"BEFE.%s.DAQ.%s%d.COUNTERS.EVT_FIFO_DATA_CNT" %
(self.gem_csc, self.dmb_oh, input),
is_progress_bar=True,
progress_bar_range=4096)
row = [
si_tts_state,
si_input_status,
si_evn,
si_data_rate,
si_infifo_warn_cnt,
si_evtfifo_warn_cnt,
si_infifo_data_cnt,
si_evtfifo_data_cnt,
]
rows.append(row)
self.sec_inputs = TopTableSection("Inputs", col_titles, rows)
# register sections
self.sections = [self.sec_config, self.sec_state, self.sec_inputs]
# setup the overal layout
col1 = [self.sec_config.container, self.sec_state.container]
col2 = [self.sec_inputs.container]
# col3 = [self.sec_ttc.container]
self.container = VSplit([HSplit(col1),
HSplit(col2)]) #, HSplit(col3)])
if evt_ovf == 1:
status += color_string("EVT_OVF ", rw.RegVal.STATE_BAD)
if evt_size_err == 1:
status += color_string("SIZE_ERR ", rw.RegVal.STATE_BAD)
if evt_64b_err == 1:
status += color_string("64BIT_ERR ", rw.RegVal.STATE_BAD)
if len(status) == 0:
status = color_string("OK", rw.RegVal.STATE_GOOD)
return status
if __name__ == "__main__":
rw.parse_xml()
fw_flavor = rw.read_reg("BEFE.SYSTEM.RELEASE.FW_FLAVOR")
if fw_flavor == 0xdeaddead:
exit()
gem_csc = fw_flavor.to_string(use_color=False)
cont_oh = HSplit(
[
Label(text="OH stuff")
# Frame(body=Label(text="Left frame\ncontent")),
# Dialog(title="The custom window", body=Label("hello\ntest")),
# textfield,
],
height=D(),
)