def test_method(self):
passFlag = True
self.port = {}
self.IL = {}
pd1 = CalConfig.rxPinAdc['PD1']
pd2 = CalConfig.rxPinAdc['PD2']
self.dbRes = {}
delta_pd_min = CalConfig.pd_pwr_delta['Min']
delta_pd_max = CalConfig.pd_pwr_delta['Max']
while(1):
response = self.displayMenu(self.setUp)
if (response == "Y"):
break
if(response == "N"):
raise TestSuiteAbort, "User aborted the test"
self.info("Pd Padding test using onboard EDFA")
self.IL['out1'] = self.displayMenu('Enter Demod out1 IL from demod data sheet: ','float')
self.IL['out2'] = self.displayMenu('Enter Demod out2 IL from demod data sheet: ','float')
if( self.IL['out1'] > self.IL['out2']):
self.info("Output #1 is the High Loss Port")
self.port['HL'] = 1
self.port['LL'] = 2
else:
self.info("Output #2 is the High Loss Port")
self.port['HL'] = 2
self.port['LL'] = 1
self.lowLossPad = self.displayMenu('Pick a 0.0 +/- 0.25 dB dB pad and report its value: ','float')
self.info('User picked zerodB (actual) = %0.3f' % (self.lowLossPad))
deltaIL = self.IL['out1'] - self.IL['out2']
self.hiLossPadEstd = CalConfig.pdDelta - deltaIL + self.lowLossPad
self.info("Estimated Hi Loss Pad: %0.3f" % (self.hiLossPadEstd))
s = ("Pick %0.2f +/- 0.25 dB pad and report its actual value :" %
(self.hiLossPadEstd))
self.pickHiLossPad = self.displayMenu(s,'float')
self.info('User picked hiLossPad = %0.3f' % (self.pickHiLossPad))
self.info("Connect as per the following configuration")
self.info("Output %d ---- pad %.3f ---- PD2" % (self.port['HL'], self.pickHiLossPad))
self.info("Output %d ---- pad %.3f ---- PD1" % (self.port['LL'], self.lowLossPad))
str = """
Ready [y/n]: """
while(1):
res = self.displayMenu(str)
if(res == 'Y'):
break
self.info("Starting Module....")
self.UUT.start_module()
result = self.UUT.set_check_all(state="off")
self.info("set check all off -> %s " % (result))
time.sleep(5)
self.info("setting the EDFA pump to 0x7000")
self.UUT.set_edfa_pump(hex_val=0x7000)
time.sleep(5)
padretryCnt = 3
while(padretryCnt > 0):
cnt = 10
DeltaLst=[]
Pd1PwrLst = []
Pd2PwrLst = []
while(cnt >0):
pd1_pwr = self.getRxPwr(pd1)
pd2_pwr = self.getRxPwr(pd2)
delta_pd = pd1_pwr - pd2_pwr
DeltaLst.append(delta_pd)
Pd1PwrLst.append(pd1_pwr)
Pd2PwrLst.append(pd2_pwr)
self.info("PD1:%.2f PD2:%.2f delta:%.2f" % (pd1_pwr,pd2_pwr,delta_pd))
cnt-=1
avg_delta = avg(DeltaLst)
avg_pd1Pwr = avg(Pd1PwrLst)
avg_pd2Pwr = avg(Pd2PwrLst)
if(avg_delta > delta_pd_min and avg_delta < delta_pd_max):
self.info("Delta (PD1-PD2):%.2f within limits[%.2f,%.2f]" % (avg_delta,delta_pd_min,delta_pd_max))
passFlag = True
break
else:
passFlag = False
self.failed("Delta (PD1-PD2):%.2f exceeded limits[%.2f,%.2f]" % (avg_delta,delta_pd_min,delta_pd_max))
if(avg_delta > delta_pd_min):
self.hiLossPadEstd = (self.pickHiLossPad - (avg_delta - delta_pd_max))
else:
self.hiLossPadEstd = (self.pickHiLossPad - (avg_delta - delta_pd_min))
s = ("Pick %0.3f +/- 0.25 dB pad and report its actual value :" %
(self.hiLossPadEstd))
self.pickHiLossPad = self.displayMenu(s,'float')
self.info("ReConnect as per the following configuration")
self.info("Output %d ---- pad %.3f ---- PD2" % (self.port['HL'], self.pickHiLossPad))
self.info("Output %d ---- pad %.3f ---- PD1" % (self.port['LL'], self.lowLossPad))
str = """
Ready [y/n]: """
while(1):
res = self.displayMenu(str)
if(res == 'Y'):
break
padretryCnt -= 1
print "**** %d retries remaining" % (padretryCnt)
self.info("resetting the edfa pump to zero")
self.UUT.set_edfa_pump(hex_val=0x0)
if(passFlag):
self.dbRes['HighLossPort'] = int(self.port['HL'])
self.dbRes['LowLossPort'] = int(self.port['LL'])
self.dbRes['WantHighLossPad'] = round(self.hiLossPadEstd, 3)
self.dbRes['WantLowLossPad'] = round(self.lowLossPad, 3)
self.dbRes['PickHighLossPad'] = round(self.pickHiLossPad, 3)
#No measurement done without pads in out1 and out2
self.dbRes['Out1PwrReading'] = 0.0
self.dbRes['Out2PwrReading'] = 0.0
if(self.port['HL'] == 1):
self.dbRes['Out1FinalReading'] = avg_pd2Pwr
self.dbRes['Out2FinalReading'] = avg_pd1Pwr
else:
self.dbRes['Out1FinalReading'] = avg_pd1Pwr
self.dbRes['Out2FinalReading'] = avg_pd2Pwr
print "debug:dbRes", self.dbRes
self.info("\n\n\n!!! Please note this on the traveler !!!")
self.info("Output %d ---- pad %.3f ---- PD2" % (self.port['HL'],self.pickHiLossPad,))
self.info("Output %d ---- pad %.3f ---- PD1" % (self.port['LL'],self.lowLossPad))
print "\n\n\n"
return self.passed("PD1/PD2 padding")
else:
return self.failed("Pd Padding failed")
def rxInAccCheck(self,specificRxPin, reset860):
myName = specificRxPin.myName
mySwitchNum = specificRxPin.mySwitchNum
specificRxPin.rxInAccCheck_pass = True
errCnt = 0
accResult = []
self.info("")
self.info("Perform Rx Accurracy check on %s" % (myName))
self.backToDefaultStates()
if (reset860):
self.info("")
sleepTime = 180
self.info("Resetting dsp to reload cal tbls .... sleep %s secs\n" % (sleepTime))
#res = self.UUT.reset_dsp()
try:
res = self.UUT.sendMyCmd("reset me")
except:
pass
time.sleep(sleepTime)
self.switchConnect(switchNum=mySwitchNum)
self.rxVoa.state = "ON"
self.dfbLaser.on()
time.sleep(2)
for wantInPwr in CalConfig.rxInAccCheckPts:
self.setInputPwr(wantInPwr, myName=myName)
time.sleep(2)
self.estRxPwr = self.estimateInputPwr(myName)
cnt = 4
tmpRxPwrLst = []
for i in range(cnt):
uutRxPwr = self.getRxPwr(specificRxPin.myAdcNum)
#print "debug uutRxPwr: ", uutRxPwr
tmpRxPwrLst.append(uutRxPwr)
self.uutRxPwr = avg(tmpRxPwrLst)
self.delta = self.estRxPwr - self.uutRxPwr
self.info("est InPwr: %.3f uut report: %.3f delta:%.3f" %
(self.estRxPwr,self.uutRxPwr,self.delta))
if (abs(self.delta) > CalConfig.rxPinInAccTolerance):
#self.failed("Rx Accuracy check exceeded tolerance of %.2f" % (CalConfig.rxPinInAccTolerance))
self.info("Retrying...")
status = self.retryPinAccCheck(specificRxPin,wantInPwr)
if (status == False):
errCnt += 1
self.failed("Rx Accuracy check exceeded tolerance of %.2f" % (CalConfig.rxPinInAccTolerance))
else:
pass
else:
pass
accResult.append((self.estRxPwr,self.uutRxPwr))
#end of for loop
self.rxPinAccRes[specificRxPin.myName] = accResult
#print "Debug in rxInAccCheck"
#print self.rxPinAccRes
if(errCnt > 0):
specificRxPin.rxInAccCheck_pass = False
else:
specificRxPin.rxInAccCheck_pass = True
self.backToDefaultStates()
def edfaOutPwrAccuracy(self,reset860=False):
self.info("")
self.info("EDFA Output Pwr Accuracy check...")
if (reset860):
self.info("")
sleepTime = 180
self.info("Resetting dsp to reload cal tbls .... sleep %s secs\n" % (sleepTime))
#res = self.UUT.reset_dsp()
try:
res = self.UUT.sendMyCmd("reset me")
except:
pass
time.sleep(sleepTime)
myName = "edfaIn"
self.edfaOutPwrAccuracy_pass = True
self.backToDefaultStates()
self.switchConnect(switchName=myName) # allow light to go into EDFA
self.dfbLaser.on()
time.sleep(2)
wavelen = CalConfig.dfbLaser_wavelength
self.edfaOutPwrM.wavelength = wavelen
self.rxVoa.state = "ON"
time.sleep(3)
# read back voa attn
attn = self.rxVoa.attenuation.value
self.info("Current rx voa attn is %.2f" % (attn))
edfaInAvg = []
edfaOutAvg = []
edfaPCrntAvg = []
outPwrValues = []
outPwr_mWatt = []
#fix light going to edfa
wantInPwr = -5.0
self.setInputPwr(wantInPwr, myName=myName)
attn = self.rxVoa.attenuation.value
time.sleep(2)
currentInPwr = self.estimateInputPwr(myName)
edfaInPwr = self.UUT.show_edfa_input('dBm')[0].value
self.info("Est rxPwr:%.2f edfaReporInPwr: %.2f" % (currentInPwr, edfaInPwr))
if (edfaInPwr < wantInPwr * 1.3):
self.failed("Edfa input %.2f is lower than expected %.2f" % (edfaInPwr, currentInPwr))
return False
result = self.UUT.set_check_all(state="off")
self.info("set check all off -> %s " % (result))
self.info("set edfa loop off")
result = self.UUT.set_edfa_loop('off')
print "Edfa loop off:", result
if(self.rev_260 < 10):
CalConfig.edfaOutPwrDict = {6.0:0x5600, 8.0:0x6500, 9.0:0x7100, 10.0:0x7e00, 12.0:0xa100, 13.0:0xb600}
self.info("Using OLD PumpPwrDict...")
# want 6.0, 8.0, 10.0 at edfa Output
for wantEdfaOutPwr in CalConfig.edfaOutPwrAccLst:
#self.info("wantEdfaOutPwr: %.3f est inPwr: %.3f attn:%.3f" %
# (wantEdfaOutPwr, currentInPwr, attn ))
if (not self.adjustEdfaOutPower(wantEdfaOutPwr,CalConfig.edfaOutPwrDict[wantEdfaOutPwr],self.edfaOutPwrM )):
self.failed("unable to achieve edfaOutPwr %.2f" % (wantEdfaOutPwr))
self.edfaOutPwrAccuracy_pass = False
return
edfaOutAdcLst = []
edfaOutPwrLst = []
edfaPCrntLst = []
# avg over 4 readings
for i in range(4):
edfaOutAdc = self.UUT.show_edfa_output('hex')[0].value
edfaOutPwr = self.UUT.show_edfa_output('dBm')[0].value
edfaPCrntAdc = self.UUT.show_edfa_current('hex')[0].value
print "debug edfaOutAdc: ", edfaOutAdc, "edfaOutPwr: ", edfaOutPwr
edfaOutAdcLst.append(edfaOutAdc)
edfaOutPwrLst.append(edfaOutPwr)
edfaPCrntLst.append(edfaPCrntAdc)
edfaInAdc = self.UUT.show_edfa_input('hex')[0].value
edfaInPwr = self.UUT.show_edfa_input('dBm')[0].value
outAdcAvg = int(avg(edfaOutAdcLst))
outPwrAvg = round(avg(edfaOutPwrLst), 3)
pCrntAvg = int(avg(edfaPCrntLst))
pumpI = self.getEdfaPumpCurrent(pCrntAvg)
# this is from a directly connected power meter
adjEdfaOutPwr = self.getOpticalPower(self.edfaOutPwrM)
print "debug edfa meter power reading -> ", adjEdfaOutPwr
adjEdfaOutPwr = self.getTrueEdfaOutPwr(adjEdfaOutPwr)
delta = outPwrAvg - adjEdfaOutPwr
self.info("wavelen:%.3f(nm) edfaInPwr:%.3f edfaOutPwr:%.3f edfaOutAdc:0x%x (%d) estEdfaOutPwr:%.3f delta:%.3f edfaPumpI:%.2f" %
(wavelen.value, edfaInPwr, outPwrAvg, outAdcAvg, outAdcAvg, adjEdfaOutPwr, delta, pumpI))
if (abs(delta) > CalConfig.edfaOutAccTolerance):
self.failed("Edfa output accuracy check exceeded limit %.2f" % (CalConfig.edfaOutAccTolerance))
self.edfaOutPwrAccuracy_pass = False
res = self.UUT.set_edfa_pump(hex_val=0x0)
def edfaInputPwrAccuracy (self, reset860=False):
self.info("")
self.info("Checking EDFA Input Accuracy...")
self.csvFd.write("\n\n")
self.csvFd.write("Checking EDFA Input Accuracy...\n")
if (reset860):
self.info("")
sleepTime = 180
self.info("Resetting dsp to reload cal tbls .... sleep %s secs\n" % (sleepTime))
#res = self.UUT.reset_dsp()
try:
res = self.UUT.sendMyCmd("reset me")
except:
pass
time.sleep(sleepTime)
myName = "edfaIn"
self.edfaInput_Accuracy_pass = True
self.backToDefaultStates()
self.switchConnect(switchName=myName) # allow light to go into EDFA
self.dfbLaser.on()
time.sleep(2)
self.rxVoa.state = "ON"
rxWavelenLst = [CalConfig.dfbLaser_wavelength]
for wavelen in rxWavelenLst:
self.rxVoa.wavelength = wavelen
time.sleep(2)
self.csvFd.write("Wavelength, WantInPwr, UUT Report, Delta\n")
for wantInPwr in CalConfig.edfaPwrAccCheckPts:
if (wantInPwr > CalConfig.edfaInMax):
self.info("!! Should not happen !!")
self.info("want %.2f exceeded EDFA Pmax of %.2f" % (wantInPwr,CalConfig.edfaInMax))
self.info("!! Should not happen !!")
raise globalExceptionRxPwrAcc
if (wantInPwr > CalConfig.edfaSrcPmax):
self.info("!! Should not happen !!")
self.info("setup is unable to provide %.2f for this data pt" % (wantInPwr))
self.info("!! Should not happen !!")
raise globalExceptionRxPwrAcc
self.setInputPwr(wantInPwr, myName=myName)
attn = self.rxVoa.attenuation.value
time.sleep(2)
currentInPwr = self.estimateInputPwr(myName)
#self.info("est inPwr:%.3f wantInPwr:%.3f voa attn:%.2f" % (currentInPwr ,wantInPwr, attn))
rxPwrAvg = []
rxPwrHexAvg = []
for i in range(4):
rxPwr = self.UUT.show_edfa_input('dBm')[0].value
rxPwrHex = self.UUT.show_edfa_input('hex')[0].value
rxPwrAvg.append(rxPwr)
rxPwrHexAvg.append(rxPwrHex)
rxPwr = avg(rxPwrAvg)
rxPwrHex = avg(rxPwrHexAvg)
delta = abs(rxPwr - currentInPwr)
if (wantInPwr == -25.0 or wantInPwr == -30.0):
edfaAccCheckTol = CalConfig.edfaInputAccTolAtLowPwr
else:
edfaAccCheckTol = CalConfig.edfaInputAccTolerance
#if (delta > CalConfig.edfaInputAccTolerance):
if (delta > edfaAccCheckTol):
self.failed("edfa input accuracy exceeded tolerance")
self.edfaInput_Accuracy_pass = False
#self.rxPwrAccRes.append((float(wavelen),currentInPwr , rxPwr))
self.edfaInPwrAccRes.append((float(wavelen),currentInPwr , rxPwr))
self.info("wavelength: %.3f(nm) rxInPwr: %.3f uut report: %.3f (0x%x) delta: %.3f" %
(wavelen, currentInPwr, rxPwr , rxPwrHex, delta))
self.csvFd.write("%.3f, %.2f, %.2f, %.2f\n" % (wavelen, wantInPwr ,rxPwr ,delta))
self.backToDefaultStates()
