def initialize(self):
tb = self.config.testbed
SCREEN_VERSION = 11
self.SCREEN_VERSION = SCREEN_VERSION
# sql databse
# all dictionaries below are keyed by {uutid: {'j2g': {}, 'm2g': {}, 'g2m': {}}}
self.widths_avg = {} # dictionary to story the average width
self.widths_min = {} # minimum window width
self.widths_dist = {} # window width distribution
#log file
self.lf = self.config.logfile
self.lvdsArgs = {}
self.errorCount = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
self.uut_ser_dict = {}
# Making uut list
from copy import copy
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n" % len(self.uutSnList))
self.info("######## SCREEN VERSION %s ###########" % SCREEN_VERSION)
for sn in self.uutSnList:
self.info("UUT %s INFO: %s : %s\n"
%(sn, self.uutDict[sn]["id"], self.uutDict[sn]["slot"]))
self.lvdsArgs[self.uutDict[sn]["id"]] = {}
self.errorCount[sn] = 0
slot = self.uutDict[sn]["slot"]
uut_slot = int(slot)
if (self.config.flags.VERBOSE and self.config.flags.DEBUG):
# we log the mike-debug shell ONLY when -dv are both present
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
UUT_dbg = "UUT_slot%s_mike_debug" % slot
self.uut_ser_dict[UUT_dbg] = self.uutDict[sn]['mike_debug']
dbg_obj = self.uut_ser_dict[UUT_dbg]
#----- dbg window logger ---------------------
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug, dbg=True)
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
self.info("Debug log started.....")
def initialize(self):
# create aliases
tb = self.config.testbed
self.DiCon = tb['DiCon_SW']
self.VOAREFTX = tb["VOA_Line_Ref_Tx"]
self.PROGCD = tb["ProgCD"]
self.dBox = self.PROGCD.dBox
self.OSA = tb["OSA"]
self.VOAASE = tb["VOA_ASE"]
self.VOAOUT = tb["VOA_Out"]
self.REFRX = tb["ReferenceRx_Mike"]
self.REFRX_ber = tb["ReferenceRx"]
self.DAQ = tb["DAQ"]
self.PWAV = tb['PWAV']
self.PDIR = tb['PDIR']
self.UUT_LINE_OUTPUT_SW = tb['UUT_LINE_OUTPUT_SW']
self.UUT_CLIENT_OUTPUT_SW = tb['UUT_CLIENT_OUTPUT_SW']
self.refsn = self.REFRX.SN
refsn = self.refsn
#log file
self.lf = self.config.logfile
#sql database
self.lineRxBerArgs = {}
self.errorCount = {}
# test type:
self.UUT_TEST_TYPE = self.config.UUT_TEST_TYPE
for voa in self.config.voaOutList:
tb[voa].state = "ON"
time.sleep(5) # time to settle all instrument
# initial OSNR setting to have a good eye
self.init_osnr = self.config.init_osnr
# step 1: set ProgCD SW6 to CNT to disable light from coming in.
if self.PROGCD.__class__ == instruments.GP700:
pass
else:
self.PROGCD.dBox.set_switch(6, 'cnt')
# step 2. Disable VOAs
self.info("Enabling VOA's ...")
varAtt = self.config.varAtt
for i in range(len(varAtt['voa'])):
tb[varAtt['voa'][i]].state = "ON"
tb[varAtt['voa'][i]].attenuation = varAtt['att'][i]
tb[varAtt['voa'][i]].wavelength = varAtt['wl'][i]
# Making uut list
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: slot%s : %s \n"
%(self.uutDict[sn]["slot"], sn))
self.lineRxBerArgs[self.uutDict[sn]["id"]] = {}
self.errorCount[sn] = 0
refsn = self.REFRX.SN
self.errorCount[refsn] = 0
self.tdc_channel_dict = self.config.tdc_params
self.dicon_sw_dict = self.config.dicon_sw_dict
self.card_type_str = self.config.default_card_type
self.tdc_type = self.config.default_tdc_type
tdc_type = self.tdc_type
self.RxLOSThr = -24.0
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
try:
cd_list = self.config.cdlist.split(',')
self.cdTestList = []
for cd in cd_list:
self.cdTestList.append(int(cd))
self.diagnostic("### CD list: %s" % self.cdTestList)
except:
self.cdTestList = self.config.cdTestList
self.diagnostic("### CD list: %s" % self.cdTestList)
try:
tmp_list = self.config.osnrlist.split(',')
self.osnrList = []
for osnr in tmp_list:
osnr_pq = PQ("%s dB" % osnr)
self.osnrList.append(osnr_pq)
self.diagnostic("### OSNR list: %s" % self.osnrList)
except:
self.osnrList = self.config.osnrList
self.diagnostic("### OSNR list: %s" % self.osnrList)
self.diagnostic("Setting RxLOSThr on REF to %s" % self.RxLOSThr)
self.REFRX.RxLOSThr = self.RxLOSThr
demod_settle_time = 14000
self.diagnostic("Extending REFRX (%s) demod settle time to %s msec" % (self.REFRX.SN, demod_settle_time))
self.REFRX.extend_demod_settle_time(demod_settle_time)
#----- reference dbg window logger ---------------------
# get a logger for the reference Mike-Debug shell
refsn_mike_debug = "ReferenceRx_mike_debug"
refsn_dbg_obj = self.config.testbed[refsn_mike_debug]
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
refsn_dbg_logger, refsn_mike_debug_log_name = Diag.getLogger(basepath, refsn_mike_debug, dbg=True)
self.diag[refsn_mike_debug] = Diag.DiagResponse()
self.diag[refsn_mike_debug].log = refsn_dbg_logger
self.diag[refsn_mike_debug].dsp = refsn_dbg_obj
self.diag[refsn_mike_debug].logname = refsn_mike_debug_log_name
self.info("Starting Reference mike-debug shell logging...")
refsn_t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[refsn_mike_debug].log, refsn_dbg_obj))
self.diag[refsn_mike_debug].t_id = refsn_t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Reference mike debug log started.....")
self.info("Setting REF TDC to Auto-Cont mode...")
self.REFRX.set_tdc_auto_mode('Cont')
if 1: #self.config.flags.DEBUG:
self.info("Dumping out REF TDC setting...")
raw_info = self.REFRX.show_tdc_state()
self.info("%s" % raw_info)
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
obj = uut_dict['obj']
self.uut_ser_dict[slot] = self.uutDict[sn]['mike']
self.uut_ser_dict[UUT_ber] = self.uutDict[sn]['obj']
self.uut_ser_dict[UUT_dbg] = self.uutDict[sn]['mike_debug'] #config.testbed[UUT_dbg]
self.lineRxBerArgs[self.uutDict[sn]["id"]] = []
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
dbg_obj = self.uut_ser_dict[UUT_dbg]
self.info("Setting UUT TDC to Auto-Cont mode...")
ser_obj.set_tdc_auto_mode('Cont')
if 1: # self.config.flags.DEBUG:
self.info("Dumping out UUT TDC setting...")
raw_info = ser_obj.show_tdc_state()
self.info("%s" % raw_info)
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
#----- dbg window logger ---------------------
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug, dbg=True)
self.diagnostic("Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Debug log started.....")
self.uutDict[sn]['obj'] = ser_obj
self.info("Setting UUT (slot%s:%s) for %s..." % (slot, sn,
self.UUT_TEST_TYPE))
self.info("Setting REFERENCE card (%s) for %s..." % (self.REFRX.SN, 'Tx'))
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.REFRX.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
self.info("REF TxChan: %s" % self.REFRX.ModChan)
self.diagnostic("Setting RxLOSThr on UUT to %s" % self.RxLOSThr)
ser_obj.RxLOSThr = self.RxLOSThr
# XXX: the following is experimental...
self.diagnostic("Extending UUT(%s) demod settle time to %s msec" % (sn, demod_settle_time))
ser_obj.extend_demod_settle_time(demod_settle_time)
self.errorCount[sn] = 0
if index == 0: # do the setting only once.
# step3: set DiCon switch
# SW3-SW5 are connected to P1 with the following mapping
# SW1 & SW2 are UUT slot number dependent, so deal with them later.
# P1:1 -> SW3, P1:2 -> SW4, P1:3 -> SW5
# SW3-SW5 = ITU Channel H. Assume H is connected to port 0, 1
pdir_mod_name = "%s" % (self.PDIR.sw_mod)
pdir_name = self.PDIR.name
pdir_3_index = "%s:3" % pdir_name
pdir_3_pos = self.dicon_sw_dict[tdc_type][pdir_3_index]
self.info("Setting %s to position %d" % (pdir_3_index, pdir_3_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_3_pos, 3)
pwav_name = self.PWAV.name
pwav_mod_name = "%s" % (self.PWAV.sw_mod)
pwav_pos = self.dicon_sw_dict[tdc_type][pwav_name]#self.config.pwav_pos
self.info("Setting %s:1, %s:2, %s:3 to position %d" % \
(pwav_name, pwav_name, pwav_name, pwav_pos))
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 1)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 2)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 3)
pdir_1_index = "%s:1" % pdir_name
pdir_2_index = "%s:2" % pdir_name
pdir_1_pos = self.dicon_sw_dict[tdc_type][pdir_1_index]
pdir_2_pos = self.dicon_sw_dict[tdc_type][pdir_2_index] #self.config.pdir_2_pos
self.info("Setting %s to %d and %s to %d" % (pdir_1_index,
pdir_1_pos, pdir_2_index, pdir_2_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_1_pos, 1)
self.DiCon.set_switch(pdir_mod_name, pdir_2_pos, 2)
index += 1
#self.info("Configuring UUT and RefRx.....\n")
#chn, pwr, losth, pminterval = self.config.refParams
if (tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))
def initialize(self):
# create aliases
tb = self.config.testbed
self.DiCon = tb['DiCon_SW']
self.VOAREFTX = tb["VOA_Line_Ref_Tx"]
self.PROGCD = tb["ProgCD"]
self.dBox = self.PROGCD.dBox
self.OSA = tb["OSA"]
self.VOAASE = tb["VOA_ASE"]
self.VOAOUT = tb["VOA_Out"]
self.REFRX = tb["ReferenceRx_Mike"]
self.REFRX_ber = tb["ReferenceRx"]
self.DAQ = tb["DAQ"]
self.PWAV = tb['PWAV']
self.PDIR = tb['PDIR']
self.UUT_LINE_OUTPUT_SW = tb['UUT_LINE_OUTPUT_SW']
self.UUT_CLIENT_OUTPUT_SW = tb['UUT_CLIENT_OUTPUT_SW']
self.refsn = self.REFRX.SN
refsn = self.refsn
#log file
self.lf = self.config.logfile
self.temperature = self.DAQ.temperature
#sql database
self.vadjArgs = {}
self.errorCount = {}
# test type:
self.UUT_TEST_TYPE = self.config.UUT_TEST_TYPE
for voa in self.config.voaOutList:
tb[voa].state = "ON"
time.sleep(5) # time to settle all instrument
# initial OSNR setting to have a good eye
self.init_osnr = self.config.init_osnr
# step 1: set ProgCD SW6 to CNT to disable light from coming in.
if self.PROGCD.__class__ == instruments.GP700:
pass
else:
self.PROGCD.dBox.set_switch(6, 'cnt')
# step 2. Disable VOAs
self.info("Enabling VOA's ...")
varAtt = self.config.varAtt
for i in range(len(varAtt['voa'])):
tb[varAtt['voa'][i]].state = "ON"
tb[varAtt['voa'][i]].attenuation = varAtt['att'][i]
tb[varAtt['voa'][i]].wavelength = varAtt['wl'][i]
# Making uut list
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: slot%s : %s \n"
%(self.uutDict[sn]["slot"], sn))
self.vadjArgs[self.uutDict[sn]["id"]] = {}
self.errorCount[sn] = 0
refsn = self.REFRX.SN
self.errorCount[refsn] = 0
self.tdc_channel_dict = self.config.tdc_params
self.dicon_sw_dict = self.config.dicon_sw_dict
self.card_type_str = self.config.default_card_type
self.tdc_type = self.config.default_tdc_type
tdc_type = self.tdc_type
self.RxLOSThr = -24.0
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
self.diagnostic("Setting RxLOSThr on REF to %s" % self.RxLOSThr)
self.REFRX.RxLOSThr = self.RxLOSThr
demod_settle_time = 14000
self.diagnostic("Extending REFRX (%s) demod settle time to %s msec" % (self.REFRX.SN, demod_settle_time))
self.REFRX.extend_demod_settle_time(demod_settle_time)
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
obj = uut_dict['obj']
self.uut_ser_dict[slot] = self.config.testbed[UUT_ser]
self.uut_ser_dict[UUT_ber] = self.config.testbed[UUT_ber]
self.vadjArgs[self.uutDict[sn]["id"]] = []
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
self.diag_logger[sn] = Diag.getLogger(basepath, sn)
self.diag[sn] = Diag.DiagResponse()
self.diag[sn].log = self.diag_logger[sn]
self.diag[sn].dsp = ser_obj
refsn_uut = "%s_%s" % (refsn, sn)
self.diag_logger[refsn_uut] = Diag.getLogger(basepath, refsn_uut)
self.diag[refsn_uut] = Diag.DiagResponse()
self.diag[refsn_uut].log = self.diag_logger[refsn_uut]
self.diag[refsn_uut].dsp = self.REFRX
self.uutDict[sn]['obj'] = ser_obj
self.info("Setting UUT (slot%s:%s) for %s..." % (slot, sn,
self.UUT_TEST_TYPE))
self.info("Setting REFERENCE card (%s) for %s..." % (self.REFRX.SN, 'Tx'))
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.REFRX.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
self.info("REF TxChan: %s" % self.REFRX.ModChan)
self.diagnostic("Setting RxLOSThr on UUT to %s" % self.RxLOSThr)
ser_obj.RxLOSThr = self.RxLOSThr
# XXX: the following is experimental...
self.diagnostic("Extending UUT(%s) demod settle time to %s msec" % (sn, demod_settle_time))
ser_obj.extend_demod_settle_time(demod_settle_time)
self.errorCount[sn] = 0
if index == 0: # do the setting only once.
# step3: set DiCon switch
# SW3-SW5 are connected to P1 with the following mapping
# SW1 & SW2 are UUT slot number dependent, so deal with them later.
# P1:1 -> SW3, P1:2 -> SW4, P1:3 -> SW5
# SW3-SW5 = ITU Channel H. Assume H is connected to port 0, 1
pdir_mod_name = "%s" % (self.PDIR.sw_mod)
pdir_name = self.PDIR.name
pdir_3_index = "%s:3" % pdir_name
pdir_3_pos = self.dicon_sw_dict[tdc_type][pdir_3_index]
self.info("Setting %s to position %d" % (pdir_3_index, pdir_3_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_3_pos, 3)
pwav_name = self.PWAV.name
pwav_mod_name = "%s" % (self.PWAV.sw_mod)
pwav_pos = self.dicon_sw_dict[tdc_type][pwav_name]#self.config.pwav_pos
self.info("Setting %s:1, %s:2, %s:3 to position %d" % \
(pwav_name, pwav_name, pwav_name, pwav_pos))
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 1)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 2)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 3)
pdir_1_index = "%s:1" % pdir_name
pdir_2_index = "%s:2" % pdir_name
pdir_1_pos = self.dicon_sw_dict[tdc_type][pdir_1_index]
pdir_2_pos = self.dicon_sw_dict[tdc_type][pdir_2_index] #self.config.pdir_2_pos
self.info("Setting %s to %d and %s to %d" % (pdir_1_index,
pdir_1_pos, pdir_2_index, pdir_2_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_1_pos, 1)
self.DiCon.set_switch(pdir_mod_name, pdir_2_pos, 2)
index += 1
#self.info("Configuring UUT and RefRx.....\n")
#chn, pwr, losth, pminterval = self.config.refParams
if (tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))
def initialize(self):
# create aliases
tb = self.config.testbed
self.tdc_channel_dict = self.config.tdc_params
#log file
self.lf = self.config.logfile
#sql database
self.errorCount = {}
# Making uut list
from copy import copy
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: %s : %s : %s\n"
%(sn, self.uutDict[sn]["id"], self.uutDict[sn]["slot"]))
self.errorCount[sn] = 0
self.uutRefSnList = self.uutSnList# + [refsn]
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
#----- reference dbg window logger ---------------------
# get a logger for the reference Mike-Debug shell
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
demod_settle_time = 14000
reacq_settle_time = 180
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
obj = uut_dict['obj']
self.uut_ser_dict[slot] = self.uutDict[sn]['mike']
self.uut_ser_dict[UUT_ber] = self.uutDict[sn]['obj']
self.uut_ser_dict[UUT_dbg] = self.uutDict[sn]['mike_debug'] #config.testbed[UUT_dbg]
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
dbg_obj = self.uut_ser_dict[UUT_dbg]
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
#----- dbg window logger ---------------------
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug, dbg=True)
self.diagnostic("UUT Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Debug log started.....")
self.uutDict[sn]['obj'] = ser_obj
self.errorCount[sn] = 0
self.tdc_type = ser_obj.get_tdc_type()
tdc_type = self.tdc_type
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
# set TDC to manual dispersion of 0
self.info("Setting TDC to manual dispersion of 0")
ser_obj.set_tdc_fixed(0.0)
self.info("Dumping out UUT TDC setting...")
raw_info = ser_obj.show_tdc_state()
self.info("%s" % raw_info)
# do a demod acq and wait for 3 minutes..
self.diagnostic("Extending UUT(%s)demod settle time to %s msec" % (sn,demod_settle_time))
ser_obj.extend_demod_settle_time(demod_settle_time)
self.info("Enabling LINE PRBS...")
ber_obj.enable_line_prbs()
self.diagnostic("Forcing demod reacquistion on UUT %s..." % sn)
self.info("Wait for %s seconds for loops to settle..." % reacq_settle_time)
ser_obj.force_demod_reacq()
time.sleep(reacq_settle_time)
## initializing Ref and UUT
if (self.tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))
def initialize(self):
# create aliases
tb = self.config.testbed
self.DiCon = tb['DiCon_SW']
self.VOAREFTX = tb["VOA_Line_Ref_Tx"]
self.PROGCD = tb["ProgCD"]
self.dBox = self.PROGCD.dBox
self.OSA = tb["OSA"]
self.VOAASE = tb["VOA_ASE"]
self.VOAOUT = tb["VOA_Out"]
self.REFRX = tb["ReferenceRx_Mike"]
self.REFRX_ber = tb["ReferenceRx"]
self.DAQ = tb["DAQ"]
self.PWAV = tb['PWAV']
self.PDIR = tb['PDIR']
self.UUT_LINE_OUTPUT_SW = tb['UUT_LINE_OUTPUT_SW']
self.UUT_CLIENT_OUTPUT_SW = tb['UUT_CLIENT_OUTPUT_SW']
#self.TP = tb['InnoCor']
self.refsn = self.REFRX.SN
refsn = self.refsn
self.M1 = tb['M1']
self.RxLOSThr = -24.0
# ShelfController instance
self.SC = tb['SC']
#log file
self.lf = self.config.logfile
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
#sql database
self.errorCount = {}
self.clientChkArgs = {}
# test type:
self.UUT_TEST_TYPE = self.config.UUT_TEST_TYPE
# step 1: set ProgCD SW6 to CNT to disable light from coming in.
if self.PROGCD.__class__ == instruments.GP700:
pass
else:
self.info("Disabling ProgCD output...")
self.dBox.set_switch(6, 'cnt')
# step 2. Disable VOAs
self.info("Disabling VOA's ...")
varAtt = self.config.varAtt
for i in range(len(varAtt['voa'])):
tb[varAtt['voa'][i]].state = "ON"
tb[varAtt['voa'][i]].attenuation = varAtt['att'][i]
tb[varAtt['voa'][i]].wavelength = varAtt['wl'][i]
# Making uut list
from copy import copy
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: slot%s : %s\n" %(self.uutDict[sn]["slot"], sn))
self.clientChkArgs[self.uutDict[sn]["id"]] = {}
self.errorCount[sn] = 0
self.uutRefSnList = self.uutSnList# + [refsn]
self.tdc_channel_dict = self.config.tdc_params
self.dicon_sw_dict = self.config.dicon_sw_dict
self.card_type_str = self.config.default_card_type
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
#----- reference dbg window logger ---------------------
# get a logger for the reference Mike-Debug shell
refsn_mike_debug = "ReferenceRx_mike_debug"
refsn_dbg_obj = self.config.testbed[refsn_mike_debug]
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
refsn_dbg_logger, refsn_mike_debug_log_name = Diag.getLogger(basepath, refsn_mike_debug, dbg=True)
self.diag[refsn_mike_debug] = Diag.DiagResponse()
self.diag[refsn_mike_debug].log = refsn_dbg_logger
self.diag[refsn_mike_debug].dsp = refsn_dbg_obj
self.diag[refsn_mike_debug].logname = refsn_mike_debug_log_name
self.info("Starting Reference mike-debug shell logging...")
refsn_t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[refsn_mike_debug].log, refsn_dbg_obj))
self.diag[refsn_mike_debug].t_id = refsn_t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Reference mike debug log started.....")
self.rel_dict = {}
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
self.rel_dict[slot] = {}
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
self.uut_ser_dict[slot] = self.uutDict[sn]['mike']
self.uut_ser_dict[UUT_ber] = self.uutDict[sn]['obj']
self.uut_ser_dict[UUT_dbg] = self.uutDict[sn]['mike_debug'] #config.testbed[UUT_dbg]
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
dbg_obj = self.uut_ser_dict[UUT_dbg]
self.rel_dict[slot]['is_2_1'], self.rel_dict[slot]['release'] = ber_obj.is_2_1_release()
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
sn_logger, sn_log_name = Diag.getLogger(basepath, sn)
self.diag[sn] = Diag.DiagResponse()
self.diag[sn].log = sn_logger
self.diag[sn].dsp = ser_obj
self.diag[sn].logname = sn_log_name
refsn_uut = "%s_%s" % (refsn, sn)
refsn_logger, refsn_log_name = Diag.getLogger(basepath, refsn_uut)
self.diag[refsn_uut] = Diag.DiagResponse()
self.diag[refsn_uut].log = refsn_logger
self.diag[refsn_uut].dsp = self.REFRX
self.diag[refsn_uut].logname = refsn_log_name
#----- dbg window logger ---------------------
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug, dbg=True)
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
self.diagnostic("Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Debug log started.....")
obj = uut_dict['obj']
self.clientChkArgs[self.uutDict[sn]["id"]] = []
ser_obj = self.uut_ser_dict[slot]
self.uutDict[sn]['obj'] = ser_obj
self.info("Setting UUT (slot%s:%s) for %s..." % (slot, sn,
self.UUT_TEST_TYPE))
self.info("Setting REFERENCE card (%s) for %s..." % (self.REFRX.SN, 'Rx'))
tdc_lof_timeout = '3600.0'
self.errorCount[sn] = 0
self.tdc_type = self.config.default_tdc_type
tdc_type = self.tdc_type
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.REFRX.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
self.info("REF TxChan: %s" % self.REFRX.ModChan)
self.diagnostic("Setting RxLOSThr on UUT to %s" % self.RxLOSThr)
ser_obj.RxLOSThr = self.RxLOSThr
if index == 0: # do the setting only once.
# step3: set DiCon switch
pdir_mod_name = "%s" % (self.PDIR.sw_mod)
pdir_name = self.PDIR.name
pdir_3_index = "%s:3" % pdir_name
pdir_3_pos = self.dicon_sw_dict[tdc_type][pdir_3_index]
self.info("Setting %s to position %d" % (pdir_3_index, pdir_3_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_3_pos, 3)
pwav_name = self.PWAV.name
pwav_mod_name = "%s" % (self.PWAV.sw_mod)
pwav_pos = self.dicon_sw_dict[tdc_type][pwav_name]
self.info("Setting %s:1, %s:2, %s:3 to position %d" % \
(pwav_name, pwav_name, pwav_name, pwav_pos))
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 1)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 2)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 3)
pdir_1_index = "%s:1" % pdir_name
pdir_2_index = "%s:2" % pdir_name
pdir_1_pos = self.dicon_sw_dict[tdc_type][pdir_1_index]
pdir_2_pos = self.dicon_sw_dict[tdc_type][pdir_2_index]
self.info("Setting %s to %d and %s to %d" % (pdir_1_index,
pdir_1_pos, pdir_2_index, pdir_2_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_1_pos, 1)
self.DiCon.set_switch(pdir_mod_name, pdir_2_pos, 2)
index += 1
# initializing Ref and UUT
if (self.tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))
def initialize(self):
#test status and parameters
self.resetState = True
self.resetCount = 0
self.maxResets = self.config.maxresets
self.passing = True
self.abort = False
self.debugMode = self.config.debugmode
# reading initial UUT params
(min_chn, max_chn, odd_chn, even_chn, pwr, clpwr, cltxminpwr, cltxmaxpwr, losth, pminterval,
rxpwr, rxmintol, rxmaxtol, clrxpwr, clrxmintol, clrxmaxtol, linetxmintol, linetxmaxtol) = self.config.uutParams
tdcType = self.config.tdcType
self.linemaxberr = self.config.lineberrlimit
self.clientmaxberr = self.config.clientberrlimit
self.uut_type = int(self.config.uuttype)
self.tagNameList = self.config.tagNameList
#initialize testbed
tb = self.config.testbed
#sql database
self.burnInTestArgs = {}
self.modTemps = {}
#data file
pathname = self.get_pathname(self.config.dataFileName)
self.df = file(pathname, "w")
#log file
self.lf = self.config.logfile
# Making uut list
from copy import copy
self.uutDict = copy(self.config.uut_dict) #dict from stratatestrunner
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
#Setting up the UUT test info
for sn in self.uutSnList: #only one UUT
self.burnInTestArgs[self.uutDict[sn]["id"]] = []
uut_slot = self.uutDict[sn]['slot']
self.SLOT = int(uut_slot)
self.serialno = sn
#Setting up the UUT
self.uut_ser_dict = {}
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s" % slot
UUT_ser_mike = "UUT_slot%s_mike" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
self.uut860 = self.uutDict[sn]['obj']
self.uutdsp = self.uutDict[sn]['mike']
self.dbg_obj = self.uutDict[sn]['mike_debug']
self.uut_ser_dict[UUT_ser] = self.uut860
self.uut_ser_dict[UUT_ser_mike] = self.uutdsp
#create logging
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
self.diag = {}
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug)
self.diagnostic("Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = self.dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, self.dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
self.info("Debug log started.....")
# cal tag checks
for tag_name in self.tagNameList:
xml_obj, upload_status = self.uutdsp.read_tag_from_mike(tag_name)
if not upload_status:
self.error("Upload failed for tag %s" % tag_name)
self.passing = False
uutid = self.uutDict[self.uutSnList[0]]["id"]
return self.failed("Tags are missing.", uutid)
else:
self.info("Tag: %s" % tag_name)
self.info("%s" % xml_obj.__str__())
xml_file_name = "%s.xml" % tag_name
self.save_object(xml_obj, xml_file_name)
#verify the tdc type
uut_tdc_type = self.uutdsp.get_tdc_type()
self.info("UUT TDC Type: %s" % (int(uut_tdc_type),))
if (int(tdcType) != int(uut_tdc_type)):
self.info("Part number from the command line does not match the UUT TDC Type of %s." % (uut_tdc_type,))
while(1):
status = upper(self.user_input("\nDo you want to (c)ontinue or (a)bort the BurnIn[c/a]?:"))
if status == "A":
raise TestSuiteAbort, "Suite aborted."
break
elif status == "C":
self.info("Operator selected to continue the test.\n")
break
# make the DB connection.
card_conn_list = list(database.TitanBurnIn.select((database.TitanBurnIn.q.slot==self.SLOT)))
i = 0
while i < len(card_conn_list):
if card_conn_list[i].tb == tb.name:
card_conn = card_conn_list[i]
self.db = card_conn
break
else:
i += 1
if (i >= len(card_conn_list)):
#if environment variable IDTYPE == UUID, then use UUID for database entry id, else implicit auto-increment integer is used.
if (("IDTYPE" in os.environ.keys()) and (os.environ["IDTYPE"]=="UUID")):
database.TitanBurnIn(
id = (commands.getoutput('uuidgen -t')).strip(),
tb = str(tb.name),
sn = str(sn),
slot = int(self.SLOT),
startTime = datetime.datetime(2000,1,1,0,0),
endTime = datetime.datetime(2000,1,1,0,0),
runs = int(0),
currentRun = int(0),
lastUpdate = datetime.datetime(2000,1,1,0,0),
msg = str(''),
status = int(2)
)
else:
database.TitanBurnIn(
tb = str(tb.name),
sn = str(sn),
slot = int(self.SLOT),
startTime = datetime.datetime(2000,1,1,0,0),
endTime = datetime.datetime(2000,1,1,0,0),
runs = int(0),
currentRun = int(0),
lastUpdate = datetime.datetime(2000,1,1,0,0),
msg = str(''),
status = int(2)
)
card_conn_list = list(database.TitanBurnIn.select((database.TitanBurnIn.q.slot==self.SLOT)))
i = 0
while i < len(card_conn_list):
if card_conn_list[i].tb == tb.name:
card_conn = card_conn_list[i]
self.db = card_conn
break
else:
i += 1
db_info = {}
db_info['sn'] = sn
db_info['startTime'] = datetime.datetime.fromtimestamp(timelib.now())
db_info['endTime'] = None
db_info['status'] = 2
self._update_uut_db(db_info)
# keep looping until a valid response is given
while (1):
status = upper(self.user_input("\nDo you want to start or continue the BurnIn[s/c]?:"))
if status == "S" or status == "C":
break
totalHrs, interval = self.config.totalhrs
if status == "S":
# if start a new burnin session, ask for how long to run range
# (1-48) hours
self.db.msg = '' # clear the old meassages.
self.db.msg += "Start Burn In Test for Line Card %s in Slot:%s ...\n" % (sn, self.SLOT)
while (1):
totalHrs = int(self.user_input("\nHow long do you want to run BurnIn test?[2-48]?:"))
if totalHrs > 1 and totalHrs < 49:
if totalHrs != 48:
# prompt for password.
password_ok = self.check_password()
if not password_ok:
return self.abort("Test Engineering password not verified!")
totalHrsToRun = totalHrs
totalHrs = PQ(totalHrs, "h")
break
self.numCheckIter = int(totalHrs/interval)
self.info("Test to run for %s" %(totalHrs,))
self.lf.write("Test to run for %s" %(totalHrs,))
self.db.msg += "Test to run for %s\n" % (totalHrs,)
self.db.currentRun = 0
db_info['runs'] = totalHrsToRun
self._update_uut_db(db_info)
else:
synctime = self.db.currentRun
totalHrsToRun = self.db.runs
totalHrs = PQ(totalHrsToRun, "h")
syncTimeInHrs = PQ(synctime, "h")
self.info("Test already ran for %s" %(syncTimeInHrs,))
self.lf.write("\n\nTest already ran for %s" %(syncTimeInHrs,))
previousData = self.db.msg
for line in previousData.split("\n"):
if line.find("Initial") >= 0:
self.info("Previous Run: %s" % line)
self.lf.write("\n\nPrevious Run: %s\n" % line)
else:
if line.find("Iter") >= 0:
self.info("Previous Run: %s" % line)
self.lf.write("\n\nPrevious Run: %s\n" % line)
if syncTimeInHrs > totalHrs:
self.numCheckIter = 1
else:
timeLeftInHrs = PQ(round(totalHrs - syncTimeInHrs), "h")
self.numCheckIter = int(timeLeftInHrs/interval)
if round(totalHrs - syncTimeInHrs) <= 0:
self.numCheckIter = int(1)
self.info("Test to run for %s more" %(timeLeftInHrs,))
self.lf.write("\n\nTest to run for %s more" %(timeLeftInHrs,))
self.db.msg += "\n\nTest to run for %s more \n" % (timeLeftInHrs,)
db_info['runs'] = totalHrsToRun
self._update_uut_db(db_info)
#getting initial UUT state
startTime = time.time()
while((self.resetState == True) and (self.resetCount <= self.maxResets)):
#set up uut
self.setup_uut()
# check uut initial state
try:
uut_client_sync = self.uut860.get_client_sync()
self.info("mr 0x3e802 = %s" % uut_client_sync)
if uut_client_sync == '0':
uut_client_state = [0, 1, 0, 1, 0.0, 0, 0]
clientlostsync = 0
clientSecondsInSyncCurrent = int(time.time() - startTime)
clientSecondsOutOfSyncCurrent = 0
clientSecondsSinceReset = int(time.time() - startTime)
clientber = 0.0
clientPreFECBER = 0
clientberr = 0
else:
uut_client_state = [1, 0, 0, 0, 0.0, 0, 0]
clientlostsync = int(uut_client_state[0])
clientSecondsInSyncCurrent = uut_client_state[1]
clientSecondsOutOfSyncCurrent = uut_client_state[2]
clientSecondsSinceReset = uut_client_state[3]
clientber = uut_client_state[4]
clientPreFECBER = uut_client_state[5]
clientberr = uut_client_state[6]
except:
self.info("Got exception!")
uut_client_state = [1, 0, 0, 0, 0.0, 0, 0]
clientlostsync = int(uut_client_state[0])
clientSecondsInSyncCurrent = uut_client_state[1]
clientSecondsOutOfSyncCurrent = uut_client_state[2]
clientSecondsSinceReset = uut_client_state[3]
clientber = uut_client_state[4]
clientPreFECBER = uut_client_state[5]
clientberr = uut_client_state[6]
#lost sync determination
if (clientlostsync == 1):
self.resetState = self.uut860.get_4011_soft_reset_status()
if self.resetState == True:
self.info("UUT was reset.\n")
self.lf.write("\n\nUUT was reset.\n")
self.df.write("\n\nUUT was reset.\n")
self.db.msg += ("\n\nUUT was reset.\n")
time.sleep(30)
self.resetCount +=1
else:
self.resetState = False
#failure determination
if (self.resetCount > self.maxResets):
self.passing = False #uut was reset
self.failed("UUT was reset more than %s times." % self.maxResets)
if (clientlostsync == 1) and (self.resetState == False):
self.passing = False #uut is out of sync
self.failed("UUT was out of sync.")
#initial status output
self.info("Initial: LostSync: %s SecondsInSync: %s ResetCount: %s" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
self.lf.write("\n\nInitial: LostSync: %s SecondsInSync: %s ResetCount: %s\n" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
self.df.write("\n\nInitial: LostSync: %s SecondsInSync: %s ResetCount: %s\n" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
self.db.msg += ("\n\nInitial: LostSync: %s SecondsInSync: %s ResetCount: %s\n" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
#update database
self._update_uut_db(db_info)
def initialize(self):
# create aliases
tb = self.config.testbed
self.band_type = self.config.band_type
self.dicon_band_sw_dict = self.config.dicon_band_sw_dict
if 'P_FIBER_SPOOL_SEL' in self.config.testbed.keys():
try:
if self.band_type == 'L':
# the ProgCD for L-Band has a different address.
self.info("### Configurien for L-band configuration...")
self.PROGCD = tb["ProgCD_L"]
except:
self.info("### Configuring for C-band configuration...")
self.PROGCD = tb["ProgCD"]
self.DiCon_L = tb['DiCon_SW_L']
self.P_EDFA_SEL = tb['P_EDFA_SEL']
self.P_REF_SEL = tb['P_REF_SEL']
self.P_FILTER_SEL = tb['P_FILTER_SEL']
self.P_FIBER_SPOOL_SEL = tb['P_FIBER_SPOOL_SEL']
p_edfa_sel_name = self.P_EDFA_SEL.name
p_edfa_sel_mod_name = self.P_EDFA_SEL.sw_mod
p_ref_sel_mod_name = self.P_REF_SEL.sw_mod
p_filter_sel_mod_name = self.P_FILTER_SEL.sw_mod
p_fiber_spool_sel_mod_name = self.P_FIBER_SPOOL_SEL.sw_mod
# configuration is such that 1 is for L-band, 2 is for C-band
p_band_sw_pos = self.dicon_band_sw_dict[self.band_type][p_edfa_sel_name]
self.info("Setting all BAND_TYPE switches to position: %s" % p_band_sw_pos)
self.info("Setting %s to %s" % (p_edfa_sel_mod_name, p_band_sw_pos))
self.DiCon_L.set_switch(p_edfa_sel_mod_name, p_band_sw_pos, 1)
self.DiCon_L.set_switch(p_edfa_sel_mod_name, p_band_sw_pos, 2)
self.DiCon_L.set_switch(p_edfa_sel_mod_name, p_band_sw_pos, 3)
self.info("Setting %s to %s" % (p_ref_sel_mod_name, p_band_sw_pos))
self.DiCon_L.set_switch(p_ref_sel_mod_name, p_band_sw_pos, 1)
self.DiCon_L.set_switch(p_ref_sel_mod_name, p_band_sw_pos, 2)
self.DiCon_L.set_switch(p_ref_sel_mod_name, p_band_sw_pos, 3)
self.info("Setting %s to %s" % (p_filter_sel_mod_name, p_band_sw_pos))
self.DiCon_L.set_switch(p_filter_sel_mod_name, p_band_sw_pos, 1)
self.DiCon_L.set_switch(p_filter_sel_mod_name, p_band_sw_pos, 2)
self.DiCon_L.set_switch(p_filter_sel_mod_name, p_band_sw_pos, 3)
self.info("Setting %s to %s" % (p_fiber_spool_sel_mod_name, p_band_sw_pos))
self.DiCon_L.set_switch(p_fiber_spool_sel_mod_name, p_band_sw_pos, 1)
self.DiCon_L.set_switch(p_fiber_spool_sel_mod_name, p_band_sw_pos, 2)
self.DiCon_L.set_switch(p_fiber_spool_sel_mod_name, p_band_sw_pos, 3)
self.REFRX = tb["ReferenceRx_L_Band_Mike"]
self.REFRX_ber = tb["ReferenceRx_L_Band"]
else:
self.PROGCD = tb["ProgCD"]
self.REFRX = tb["ReferenceRx_Mike"]
self.REFRX_ber = tb["ReferenceRx"]
self.dBox = self.PROGCD.dBox
self.DiCon = tb['DiCon_SW']
self.VOAREFTX = tb["VOA_Line_Ref_Tx"]
#self.PROGCD = tb["ProgCD"]
self.OSA = tb["OSA"]
self.VOAASE = tb["VOA_ASE"]
self.VOAOUT = tb["VOA_Out"]
self.DAQ = tb["DAQ"]
self.PWAV = tb['PWAV']
self.PDIR = tb['PDIR']
self.UUT_LINE_OUTPUT_SW = tb['UUT_LINE_OUTPUT_SW']
self.UUT_CLIENT_OUTPUT_SW = tb['UUT_CLIENT_OUTPUT_SW']
self.refsn = self.REFRX.SN
refsn = self.refsn
self.RxLOSThr = -24.0
#log file
self.lf = self.config.logfile
#sql database
self.lineTxBerArgs = {}
self.errorCount = {}
# test type:
self.UUT_TEST_TYPE = self.config.UUT_TEST_TYPE
self.init_osnr = self.config.init_osnr
# step 1: set ProgCD SW6 to CNT to disable light from coming in.
self.PROGCD.dBox.set_switch(6, 'cnt')
# step 2. Disable VOAs
self.info("Disabling VOA's ...")
varAtt = self.config.varAtt
for i in range(len(varAtt['voa'])):
tb[varAtt['voa'][i]].state = "OFF"
tb[varAtt['voa'][i]].attenuation = varAtt['att'][i]
tb[varAtt['voa'][i]].wavelength = varAtt['wl'][i]
# Making uut list
from copy import copy
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: %s : %s : %s\n"
%(sn, self.uutDict[sn]["id"], self.uutDict[sn]["slot"]))
self.lineTxBerArgs[self.uutDict[sn]["id"]] = {}
self.errorCount[sn] = 0
self.uutRefSnList = self.uutSnList# + [refsn]
self.tdc_channel_dict = self.config.tdc_params
self.dicon_sw_dict = self.config.dicon_sw_dict
self.card_type_str = self.config.default_card_type
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
self.diagnostic("Setting RxLOSThr on REF to %s" % self.RxLOSThr)
self.REFRX.RxLOSThr = self.RxLOSThr
demod_settle_time = 14000
self.diagnostic("Extending REFRX (%s) demod settle time to %s msec" % (self.REFRX.SN, demod_settle_time))
self.REFRX.extend_demod_settle_time(demod_settle_time)
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
if self.band_type == 'L':
UUT_ser = "UUT_slot%s_L_mike" % slot
UUT_ber = "UUT_slot%s_L" % slot
else:
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
obj = uut_dict['obj']
self.uut_ser_dict[slot] = self.config.testbed[UUT_ser]
self.uut_ser_dict[UUT_ber] = self.config.testbed[UUT_ber]
#self.uut_ser_dict[UUT_ber] = self.config.testbed[UUT_ber]
self.lineTxBerArgs[self.uutDict[sn]["id"]] = []
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
#self.diagnostic("Making 4400 to act like a 4040...")
#ber_obj.set_4400_to_4040()
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
self.diag_logger[sn] = Diag.getLogger(basepath, sn)
self.diag[sn] = Diag.DiagResponse()
self.diag[sn].log = self.diag_logger[sn]
self.diag[sn].dsp = ser_obj
refsn_uut = "%s_%s" % (refsn, sn)
self.diag_logger[refsn_uut] = Diag.getLogger(basepath, refsn_uut)
self.diag[refsn_uut] = Diag.DiagResponse()
self.diag[refsn_uut].log = self.diag_logger[refsn_uut]
self.diag[refsn_uut].dsp = self.REFRX
self.uutDict[sn]['obj'] = ser_obj
self.info("Setting UUT (slot%s:%s) for %s..." % (slot, sn,
self.UUT_TEST_TYPE))
self.info("Setting REFERENCE card (%s) for %s..." % (self.REFRX.SN, 'Rx'))
#if self.UUT_TEST_TYPE == 'Tx':
# #ser_obj.set_uut_for_tx_tests()
# # 1. set LOF timeout
# tdc_lof_timeout = '6000.0'
# #tdc_lof_timeout = '1.0'
# self.info("Setting LOF timeout value %s for TDC..." % tdc_lof_timeout)
# ser_obj.set_tdc_lof_timeout(tdc_lof_timeout)
#if index == 0: # we only set the reference once
# self.REFRX.set_ref_for_tx_tests(self.card_type_str)
#else:
#ser_obj.set_uut_for_rx_tests()
#if index == 0:
#self.REFRX.set_ref_for_rx_tests(self.card_type_str)
self.errorCount[sn] = 0
self.tdc_type = self.config.default_tdc_type
tdc_type = self.tdc_type
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.REFRX.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
self.info("REF TxChan: %s" % self.REFRX.ModChan)
self.diagnostic("Setting RxLOSThr on UUT(%s) to %s" % (sn,self.RxLOSThr))
ser_obj.RxLOSThr = self.RxLOSThr
# XXX: the following is experimental...
self.diagnostic("Extending UUT(%s)demod settle time to %s msec" % (sn,demod_settle_time))
ser_obj.extend_demod_settle_time(demod_settle_time)
if index == 0: # do the setting only once.
# step3: set DiCon switch
# SW3-SW5 are connected to P1 with the following mapping
# SW1 & SW2 are UUT slot number dependent, so deal with them later.
# P1:1 -> SW3, P1:2 -> SW4, P1:3 -> SW5
# SW3-SW5 = ITU Channel H. Assume H is connected to port 0, 1
pdir_name = self.PDIR.name
pdir_mod_name = "%s" % (self.PDIR.sw_mod)
pdir_3_index = "%s:3" % pdir_name
pdir_3_pos = self.dicon_sw_dict[tdc_type][pdir_3_index]
self.info("Setting %s to position %d" % (pdir_3_index, pdir_3_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_3_pos, 3)
pwav_name = self.PWAV.name
pwav_mod_name = "%s" % (self.PWAV.sw_mod)
pwav_pos = self.dicon_sw_dict[tdc_type][pwav_name]#self.config.pwav_pos
self.info("Setting %s:1, %s:2, %s:3 to position %d" % \
(pwav_name, pwav_name, pwav_name, pwav_pos))
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 1)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 2)
self.DiCon.set_switch(pwav_mod_name, pwav_pos, 3)
pdir_1_index = "%s:1" % pdir_name
pdir_2_index = "%s:2" % pdir_name
pdir_1_pos = self.dicon_sw_dict[tdc_type][pdir_1_index]
pdir_2_pos = self.dicon_sw_dict[tdc_type][pdir_2_index] #self.config.pdir_2_pos
self.info("Setting %s to %d and %s to %d" % (pdir_1_index,
pdir_1_pos, pdir_2_index, pdir_2_pos))
self.DiCon.set_switch(pdir_mod_name, pdir_1_pos, 1)
self.DiCon.set_switch(pdir_mod_name, pdir_2_pos, 2)
index += 1
## initializing Ref and UUT
if (self.tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))
def initialize(self):
#test status and parameters
self.resetState = True
self.resetCount = 0
self.maxResets = self.config.maxresets
self.passing = True
self.abort = False
self.debugMode = self.config.debugmode
# reading initial UUT params
(min_chn, max_chn, odd_chn, even_chn, pwr, clpwr, cltxminpwr, cltxmaxpwr, losth, pminterval,
rxpwr, rxmintol, rxmaxtol, clrxpwr, clrxmintol, clrxmaxtol, linetxmintol, linetxmaxtol) = self.config.uutParams
tdcType = self.config.tdcType
self.linemaxberr = self.config.lineberrlimit
self.clientmaxberr = self.config.clientberrlimit
self.uut_type = int(self.config.uuttype)
#initialize testbed
tb = self.config.testbed
#sql database
self.burnInTestArgs = {}
self.modTemps = {}
#data file
pathname = self.get_pathname(self.config.dataFileName)
self.df = file(pathname, "w")
#log file
self.lf = self.config.logfile
# Making uut list
from copy import copy
self.uutDict = copy(self.config.uut_dict) #dict from stratatestrunner
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
#Setting up the UUT test info
for sn in self.uutSnList: #only one UUT
self.burnInTestArgs[self.uutDict[sn]["id"]] = []
uut_slot = self.uutDict[sn]['slot']
self.SLOT = int(uut_slot)
self.serialno = sn
#Setting up the UUT
self.uut_ser_dict = {}
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s" % slot
UUT_ser_mike = "UUT_slot%s_mike" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
self.uut860 = self.uutDict[sn]['obj']
self.uutdsp = self.uutDict[sn]['mike']
self.dbg_obj = self.uutDict[sn]['mike_debug']
self.uut_ser_dict[UUT_ser] = self.uut860
self.uut_ser_dict[UUT_ser_mike] = self.uutdsp
#create logging
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
self.diag = {}
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug)
self.diagnostic("Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = self.dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, self.dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
self.info("Debug log started.....")
#verify the tdc type
uut_tdc_type = self.uutdsp.get_tdc_type()
self.info("UUT TDC Type: %s" % (int(uut_tdc_type),))
if (int(tdcType) != int(uut_tdc_type)):
self.info("Part number from the command line does not match the UUT TDC Type of %s." % (uut_tdc_type,))
while(1):
status = upper(self.user_input("\nDo you want to (c)ontinue or (a)bort the BurnIn[c/a]?:"))
if status == "A":
raise TestSuiteAbort, "Suite aborted."
break
elif status == "C":
self.info("Operator selected to continue the test.\n")
break
#getting initial UUT state
startTime = time.time()
while((self.resetState == True) and (self.resetCount <= self.maxResets)):
#set up uut
self.setup_uut()
# check uut initial state
try:
uut_client_sync = self.uut860.get_client_sync()
self.info("mr 0x3e802 = %s" % uut_client_sync)
if uut_client_sync == '0':
uut_client_state = [0, 1, 0, 1, 0.0, 0, 0]
clientlostsync = 0
clientSecondsInSyncCurrent = int(time.time() - startTime)
clientSecondsOutOfSyncCurrent = 0
clientSecondsSinceReset = int(time.time() - startTime)
clientber = 0.0
clientPreFECBER = 0
clientberr = 0
else:
uut_client_state = [1, 0, 0, 0, 0.0, 0, 0]
clientlostsync = int(uut_client_state[0])
clientSecondsInSyncCurrent = uut_client_state[1]
clientSecondsOutOfSyncCurrent = uut_client_state[2]
clientSecondsSinceReset = uut_client_state[3]
clientber = uut_client_state[4]
clientPreFECBER = uut_client_state[5]
clientberr = uut_client_state[6]
except:
self.info("Got exception!")
uut_client_state = [1, 0, 0, 0, 0.0, 0, 0]
clientlostsync = int(uut_client_state[0])
clientSecondsInSyncCurrent = uut_client_state[1]
clientSecondsOutOfSyncCurrent = uut_client_state[2]
clientSecondsSinceReset = uut_client_state[3]
clientber = uut_client_state[4]
clientPreFECBER = uut_client_state[5]
clientberr = uut_client_state[6]
#lost sync determination
if (clientlostsync == 1):
self.resetState = self.uut860.get_4011_soft_reset_status()
if self.resetState == True:
self.info("UUT was reset.\n")
self.lf.write("\n\nUUT was reset.\n")
self.df.write("\n\nUUT was reset.\n")
time.sleep(30)
self.resetCount +=1
else:
self.resetState = False
#failure determination
if (self.resetCount > self.maxResets):
self.passing = False #uut was reset
self.failed("UUT was reset more than %s times." % self.maxResets)
if (clientlostsync == 1) and (self.resetState == False):
self.passing = False #uut is out of sync
self.failed("UUT was out of sync.")
#initial status output
self.info("Initial: LostSync: %s SecondsInSync: %s ResetCount: %s" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
self.lf.write("\n\nInitial: LostSync: %s SecondsInSync: %s ResetCount: %s\n" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
self.df.write("\n\nInitial: LostSync: %s SecondsInSync: %s ResetCount: %s\n" % (clientlostsync, clientSecondsInSyncCurrent, self.resetCount))
def initialize(self):
# create aliases
tb = self.config.testbed
self.tdc_channel_dict = self.config.tdc_params
#log file
self.lf = self.config.logfile
#sql database
self.errorCount = {}
# Making uut list
from copy import copy
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: %s : %s : %s\n"
%(sn, self.uutDict[sn]["id"], self.uutDict[sn]["slot"]))
self.errorCount[sn] = 0
self.uutRefSnList = self.uutSnList# + [refsn]
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
#----- reference dbg window logger ---------------------
# get a logger for the reference Mike-Debug shell
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
obj = uut_dict['obj']
self.uut_ser_dict[slot] = self.config.testbed[UUT_ser]
self.uut_ser_dict[UUT_ber] = self.config.testbed[UUT_ber]
self.uut_ser_dict[UUT_dbg] = self.config.testbed[UUT_dbg]
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
dbg_obj = self.uut_ser_dict[UUT_dbg]
self.info("Setting UUT TDC to Auto-Cont mode...")
ser_obj.set_tdc_auto_mode('Cont')
if self.config.flags.DEBUG:
self.info("Dumping out UUT TDC setting...")
raw_info = ser_obj.show_tdc_state()
self.info("%s" % raw_info)
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
#----- dbg window logger ---------------------
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug, dbg=True)
self.diagnostic("UUT Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Debug log started.....")
self.uutDict[sn]['obj'] = ser_obj
self.errorCount[sn] = 0
self.tdc_type = ser_obj.get_tdc_type()
tdc_type = self.tdc_type
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
## initializing Ref and UUT
if (self.tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))
def initialize(self):
# create aliases
tb = self.config.testbed
self.SC = tb['SC']
self.DiCon = tb['DiCon_SW']
self.VOAREFTX = tb["VOA_Line_Ref_Tx"]
self.PROGCD = tb["ProgCD"]
self.dBox = self.PROGCD.dBox
self.OSA = tb["OSA"]
self.VOAASE = tb["VOA_ASE"]
self.VOAOUT = tb["VOA_Out"]
self.REFRX = tb["ReferenceRx_Mike"]
self.REFRX_ber = tb["ReferenceRx"]
self.DAQ = tb["DAQ"]
self.PWAV = tb['PWAV']
self.PDIR = tb['PDIR']
self.UUT_LINE_OUTPUT_SW = tb['UUT_LINE_OUTPUT_SW']
self.UUT_CLIENT_OUTPUT_SW = tb['UUT_CLIENT_OUTPUT_SW']
self.refsn = self.REFRX.SN
refsn = self.refsn
try:
cd_list = self.config.cdlist.split(',')
self.cdTestList = []
for cd in cd_list:
self.cdTestList.append(int(cd))
self.diagnostic("### CD list: %s" % self.cdTestList)
except:
self.cdTestList = self.config.cdTestList
self.diagnostic("### CD list: %s" % self.cdTestList)
try:
tmp_list = self.config.osnrlist.split(',')
self.osnrList = []
for osnr in tmp_list:
osnr_pq = PQ("%s dB" % osnr)
self.osnrList.append(osnr_pq)
self.diagnostic("### OSNR list: %s" % self.osnrList)
except:
self.osnrList = self.config.osnrList
self.diagnostic("### OSNR list: %s" % self.osnrList)
self.RxLOSThr = -24.0
#log file
self.lf = self.config.logfile
#sql database
self.lineTxBerArgs = {}
self.errorCount = {}
# test type:
self.UUT_TEST_TYPE = self.config.UUT_TEST_TYPE
self.init_osnr = self.config.init_osnr
# step 1: set ProgCD SW6 to CNT to disable light from coming in.
self.PROGCD.dBox.set_switch(6, 'cnt')
# step 2. Disable VOAs
self.info("Disabling VOA's ...")
varAtt = self.config.varAtt
for i in range(len(varAtt['voa'])):
tb[varAtt['voa'][i]].state = "OFF"
tb[varAtt['voa'][i]].attenuation = varAtt['att'][i]
tb[varAtt['voa'][i]].wavelength = varAtt['wl'][i]
# Making uut list
from copy import copy
# copy from stratatestrunner.py
self.uutDict = copy(self.config.uut_dict)
self.uutSnList = self.uutDict.keys()
self.info("Number of UUTS TO BE TESTED: %s\n" %len(self.uutSnList))
self.lf.write("\n\nNumber of UUTS TO BE TESTED: %s\n"
%len(self.uutSnList))
for sn in self.uutSnList:
self.info("UUT INFO: %s : %s : %s\n"
%(sn, self.uutDict[sn]["id"], self.uutDict[sn]["slot"]))
self.lineTxBerArgs[self.uutDict[sn]["id"]] = {}
self.errorCount[sn] = 0
self.uutRefSnList = self.uutSnList# + [refsn]
self.tdc_channel_dict = self.config.tdc_params
self.dicon_sw_dict = self.config.dicon_sw_dict
# get the rx dicon switch configuration for testing Reference
self.dicon_sw_dict_rx = self.config.dicon_sw_dict_rx
self.card_type_str = self.config.default_card_type
# make serial objects for UUTs
index = 0
self.uut_ser_dict = {}
# dictionary to store logger and diagnostic related resources.
self.diag = {}
self.diag_logger = {}
self.diagnostic("Setting RxLOSThr on REF to %s" % self.RxLOSThr)
self.REFRX.RxLOSThr = self.RxLOSThr
demod_settle_time = 14000
self.diagnostic("Extending REFRX (%s) demod settle time to %s msec" % (self.REFRX.SN, demod_settle_time))
self.REFRX.extend_demod_settle_time(demod_settle_time)
#----- reference dbg window logger ---------------------
# get a logger for the reference Mike-Debug shell
refsn_mike_debug = "ReferenceRx_mike_debug"
refsn_dbg_obj = self.config.testbed[refsn_mike_debug]
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
refsn_dbg_logger, refsn_mike_debug_log_name = Diag.getLogger(basepath, refsn_mike_debug, dbg=True)
self.diagnostic("Reference Mike debug log located at '%s'" % os.path.dirname(refsn_mike_debug_log_name))
self.diag[refsn_mike_debug] = Diag.DiagResponse()
self.diag[refsn_mike_debug].log = refsn_dbg_logger
self.diag[refsn_mike_debug].dsp = refsn_dbg_obj
self.diag[refsn_mike_debug].logname = refsn_mike_debug_log_name
self.info("Starting Reference mike-debug shell logging...")
refsn_t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[refsn_mike_debug].log, refsn_dbg_obj))
self.diag[refsn_mike_debug].t_id = refsn_t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Reference mike debug log started.....")
self.info("Setting REF TDC to Auto-Cont mode...")
self.REFRX.set_tdc_auto_mode('Cont')
if self.config.flags.DEBUG:
self.info("Dumping out REF TDC setting...")
raw_info = self.REFRX.show_tdc_state()
self.info("%s" % raw_info)
for sn, uut_dict in self.uutDict.items():
slot = uut_dict['slot']
UUT_ser = "UUT_slot%s_mike" % slot
UUT_ber = "UUT_slot%s" % slot
UUT_dbg = "UUT_slot%s_mike_debug" % slot
obj = uut_dict['obj']
self.uut_ser_dict[slot] = self.uutDict[sn]['mike']
self.uut_ser_dict[UUT_ber] = self.uutDict[sn]['obj']
self.uut_ser_dict[UUT_dbg] = self.uutDict[sn]['mike_debug'] #config.testbed[UUT_dbg]
self.lineTxBerArgs[self.uutDict[sn]["id"]] = []
ser_obj = self.uut_ser_dict[slot]
ber_obj = self.uut_ser_dict[UUT_ber]
dbg_obj = self.uut_ser_dict[UUT_dbg]
self.info("Setting UUT TDC to Auto-Cont mode...")
ser_obj.set_tdc_auto_mode('Cont')
if self.config.flags.DEBUG:
self.info("Dumping out UUT TDC setting...")
raw_info = ser_obj.show_tdc_state()
self.info("%s" % raw_info)
self.info("Configuring diagnostic resources...")
basepath = os.path.dirname(self.config.reportpath)
self.info("Basepath: %s" % basepath)
#----- dbg window logger ---------------------
# get a logger for the Mike-Debug shell
sn_mike_debug = "%s_mike_debug" % sn
dbg_logger, mike_debug_log_name = Diag.getLogger(basepath, sn_mike_debug, dbg=True)
self.diagnostic("UUT Mike debug log located at '%s'" % os.path.dirname(mike_debug_log_name))
self.diag[sn_mike_debug] = Diag.DiagResponse()
self.diag[sn_mike_debug].log = dbg_logger
self.diag[sn_mike_debug].dsp = dbg_obj
self.diag[sn_mike_debug].logname = mike_debug_log_name
self.info("Starting mike-debug shell logging...")
t_id = thread.start_new_thread(Diag.dbgLogger,
(self.diag[sn_mike_debug].log, dbg_obj))
self.diag[sn_mike_debug].t_id = t_id
#self.diag[sn_mike_debug].thread = thread.start_new_thread(Diag.dbgLogger, (self.diag[sn_mike_debug].log, dbg_obj))
self.info("Debug log started.....")
self.uutDict[sn]['obj'] = ser_obj
self.info("Setting UUT (slot%s:%s) for %s..." % (slot, sn,
self.UUT_TEST_TYPE))
self.info("Setting REFERENCE card (%s) for %s..." % (self.REFRX.SN, 'Rx'))
#if self.UUT_TEST_TYPE == 'Tx':
# #ser_obj.set_uut_for_tx_tests()
# # 1. set LOF timeout
# tdc_lof_timeout = '6000.0'
# #tdc_lof_timeout = '1.0'
# self.info("Setting LOF timeout value %s for TDC..." % tdc_lof_timeout)
# ser_obj.set_tdc_lof_timeout(tdc_lof_timeout)
#if index == 0: # we only set the reference once
# self.REFRX.set_ref_for_tx_tests(self.card_type_str)
#else:
#ser_obj.set_uut_for_rx_tests()
#if index == 0:
#self.REFRX.set_ref_for_rx_tests(self.card_type_str)
self.errorCount[sn] = 0
self.tdc_type = self.config.default_tdc_type
tdc_type = self.tdc_type
uut_tx_channel = self.tdc_channel_dict[tdc_type][0]
self.diagnostic("Setting TxChan to channel %s" % uut_tx_channel)
ser_obj.ModChan = uut_tx_channel
self.REFRX.ModChan = uut_tx_channel
self.info("UUT TxChan: %s" % ser_obj.ModChan)
self.info("REF TxChan: %s" % self.REFRX.ModChan)
self.diagnostic("Setting RxLOSThr on UUT(%s) to %s" % (sn,self.RxLOSThr))
ser_obj.RxLOSThr = self.RxLOSThr
# XXX: the following is experimental...
self.diagnostic("Extending UUT(%s)demod settle time to %s msec" % (sn,demod_settle_time))
ser_obj.extend_demod_settle_time(demod_settle_time)
self.info("Turning on Input VOAs and Stabilizing.....\n" )
for voa in self.config.voaInList:
tb[voa].state = "ON"
self.VOAOUT.state = "ON"
time.sleep(10) # time to settle all instrument
## initializing Ref and UUT
if (self.tdc_type == 1): # 1585.51
self.chn = 51
else:
self.chn = 50
self.info( "\nTime Stamp: %s"
% (time.strftime( "%m-%d-%Y %H:%M:%S", time.localtime())))