def init_state() :
try:
if int(scriptSys.TIME) >= maxTimeInit :
#condiciones de Fallas:
if scriptSys.VOLTAGE > VALTA :scriptSys.GENERAL['vstate'] = "vALTA"
if scriptSys.VOLTAGE < VBAJA :scriptSys.GENERAL['vstate'] = "vBAJA"
else : scriptSys.GENERAL['vstate'] = "vMEDIA"
# scriptSys.AUX['INIT'+str(scriptSys.TIME)] = scriptSys.CURRENT
if scriptSys.CURRENT >iMargin or scriptSys.CURRENT < (-iMargin):
scriptSys.AUX['F01'] =scriptSys.CURRENT
scriptSys.AUX['F01t'] =scriptSys.TIME
scriptSys.final_report("F01",0)
return
if scriptSys.VOLTAGE < vMargin:
charge_state(0)
return
##############################
if scriptSys.VOLTAGE <= umbralVoltLow:
charge_state(0)
return
if scriptSys.VOLTAGE > umbralVoltLow:
zmeasure_state()
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e,"init_state()")
def measure_z1():
try:
if scriptSys.GENERAL['mode'] != 'Z_MEASURE': #si es 1 llamado
scriptSys.GENERAL['mode'] = 'Z_MEASURE'
scriptSys.TIME_INIT = scriptSys.TIME
print "DISCHARGE,1.8"
return
actual_time = (scriptSys.TIME - scriptSys.TIME_INIT)
if actual_time >= tTestD:
scriptSys.final_report(0, 0)
return
if actual_time >= (tTestC - tMargin) and actual_time < (tTestC +
tMargin):
print "PAUSE"
return
if actual_time >= (tTestB - tMargin) and actual_time < (tTestB +
tMargin):
print "DISCHARGE,1.0"
return
if actual_time >= (tTestA - tMargin) and actual_time < (tTestA +
tMargin):
print "PAUSE"
return
print "RUN"
return
except:
scriptSys.error_report("measure_z1()")
def testA():
if ENTRADAS == 1:
if scriptSys.VOLTAGE < 3800:
charge_state(1)
if ENTRADAS == 2 or ENTRADAS == 3:
print "SQUARE,1.0,-1.0,2"
sys.exit()
if ENTRADAS >= 4 and ENTRADAS < 6:
print "PAUSE"
sys.exit()
if ENTRADAS >= 6 and ENTRADAS < 12:
print "CHARGE,4.2,1.8"
sys.exit()
if ENTRADAS >= 12 and ENTRADAS < 15:
print "PAUSE"
sys.exit()
if ENTRADAS >= 15 and ENTRADAS < 42:
print "DISCHARGE,1.0"
sys.exit()
if ENTRADAS >= 42 and ENTRADAS < 45:
print "PAUSE"
sys.exit()
if ENTRADAS >= 45 and ENTRADAS < 72:
print "DISCHARGE,1.0"
sys.exit()
if ENTRADAS >= 72 and ENTRADAS < 75:
print "PAUSE"
sys.exit()
if ENTRADAS >= 75 and ENTRADAS < 102:
print "DISCHARGE,1.0"
sys.exit()
if ENTRADAS >= 102 and ENTRADAS < 105:
print "PAUSE"
sys.exit()
if ENTRADAS >= 105 and ENTRADAS < 132:
print "DISCHARGE,1.0"
sys.exit()
if ENTRADAS >= 132 and ENTRADAS < 135:
print "PAUSE"
sys.exit()
if ENTRADAS >= 135 and ENTRADAS < 162:
print "DISCHARGE,1.0"
sys.exit()
if ENTRADAS >= 162 and ENTRADAS < 165:
print "PAUSE"
sys.exit()
if ENTRADAS > 165:
scriptSys.final_report(0, 0)
sys.exit()
return
def stress_test():
try:
if scriptSys.GENERAL['mode'] != 'STRESS': #si es llamado por 1
scriptSys.GENERAL['mode'] = 'STRESS'
scriptSys.TIME_INIT = scriptSys.TIME
scriptSys.AUX['testnr'] = str(int(scriptSys.AUX['testnr']) + 1)
scriptSys.AUX['strike'] = 0
scriptSys.AUX['strikeh'] = 0
print "PAUSE"
return
#condiciones de Fallas:
if scriptSys.VOLTAGE < lowVoltageLimit: #si actula la proteccion cargo la Batery
scriptSys.AUX['Dropdown voltage T=' +
str(scriptSys.TIME)] = scriptSys.VOLTAGE
# scriptSys.send_msg('Dropdown voltage T='+ str(scriptSys.TIME))
scriptSys.final_report("SoHfail", 0)
return
# if scriptSys.VOLTAGE < vMargin : #si actula la proteccion cargo la Batery
# scriptSys.GENERAL['mode'] = 'CHARGE'
# scriptSys.TIME_INIT = scriptSys.TIME
# print "CHARGE,"+ vCharge1 +","+ iCharge1
# return
if scriptSys.CURRENT > (-iMargin) and scriptSys.VOLTAGE < vMargin:
scriptSys.AUX['F12'] = scriptSys.CURRENT
scriptSys.final_report("F12", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeInit:
slope1 = scriptSys.get_slope(
range(scriptSys.TIME_INIT + 3, scriptSys.TIME))
if slope1['VOLTAGE'] > 80 and slope1['CURRENT'] > 180:
scriptSys.AUX['F13 T=' + str(scriptSys.TIME)] = slope1
# scriptSys.send_msg('F13 T='+ str(scriptSys.TIME))
scriptSys.final_report("F13", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= tMaxStress:
scriptSys.AUX['F12'] = (scriptSys.TIME - scriptSys.TIME_INIT)
scriptSys.final_report("F15", 0)
return
######################################
actual_time = (scriptSys.TIME - scriptSys.TIME_INIT)
scriptSys.AUX['actual_time'] = actual_time
if actual_time >= (tTestC3 - tMargin) and actual_time < (tTestC3 +
tMargin):
msj = evaluate()
return
if actual_time >= (tTestB3 - tMargin) and actual_time < (tTestB3 +
tMargin):
print "PAUSE"
return
if actual_time >= (tTestA3 - tMargin) and actual_time < (tTestA3 +
tMargin):
print "DISCHARGE," + iDischargeTest2
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "stress_test()")
def init_state() :
try:
if int(scriptSys.TIME) >= maxTimeInit :
#condiciones inciales:
if scriptSys.CURRENT < (iMargin):
scriptSys.AUX['failcode'] = 3
scriptSys.final_report('FAIL_A',int(scriptSys.AUX['failcode']))
return
##############################
measure_state()
return
##############################
print "RUN"
return
except Exception as e:
scriptSys.error_report(e,"init_state()")
def init_state():
try:
if int(scriptSys.TIME) >= maxTimeInit:
if scriptSys.VOLTAGE > VALTA: scriptSys.GENERAL['vstate'] = "vALTA"
if scriptSys.VOLTAGE < VBAJA: scriptSys.GENERAL['vstate'] = "vBAJA"
else: scriptSys.GENERAL['vstate'] = "vMEDIA"
if scriptSys.CURRENT > iMargin or scriptSys.CURRENT < (-iMargin):
scriptSys.final_report("F01", 0)
return
if scriptSys.CURRENT < (2 * iMargin):
charge_state(0)
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "init_state()")
def cond_state():
try:
if not scriptSys.GENERAL['mode'] == 'CONDITIONING': #es llamado por 1
scriptSys.GENERAL['mode'] = 'CONDITIONING'
scriptSys.TIME_INIT = scriptSys.TIME
print "PAUSE"
return
if ((scriptSys.TIME) -
(scriptSys.TIME_INIT)) >= (maxTimeCond - tMargin):
stress_state()
return
#condiciones de Fallas:
if scriptSys.CURRENT > (-iMargin) and scriptSys.VOLTAGE < vMargin:
scriptSys.final_report("F18", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeInit:
slope = scriptSys.get_slope(
range(scriptSys.TIME_INIT + 3, scriptSys.TIME))
if slope['VOLTAGE'] < 80:
scriptSys.final_report("F19", 0)
return
if scriptSys.CURRENT > iMargin or scriptSys.CURRENT < (-iMargin):
scriptSys.final_report("F20", 0)
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "cond_state()")
def stress_test():
try:
if scriptSys.VOLTAGE < vMargin: #si actula la proteccion cargo la Batery
scriptSys.GENERAL['mode'] = 'CHARGE'
scriptSys.TIME_INIT = scriptSys.TIME
print "CHARGE," + vCharge1 + "," + iCharge1
return
if scriptSys.GENERAL['mode'] != 'STRESS': #si es llamado por 1
scriptSys.GENERAL['mode'] = 'STRESS'
scriptSys.TIME_INIT = scriptSys.TIME
print "DISCHARGE," + iDischargeTest1
return
#condiciones de Fallas:
if scriptSys.CURRENT > (-iMargin) and scriptSys.VOLTAGE < vMargin:
scriptSys.final_report("F12", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeInit:
slope = scriptSys.get_slope(
range(scriptSys.TIME_INIT + 3, scriptSys.TIME))
if slope['VOLTAGE'] > 80 and slope['CURRENT'] > 180:
scriptSys.final_report("F13", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= tMaxStress:
scriptSys.final_report("F15", 0)
return
if scriptSys.VOLTAGE <= lowVoltageLimit: #si actula la proteccion cargo la Batery
evaluate()
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "stress_test()")
def discharge_state(number):
try:
if not scriptSys.GENERAL['mode'] == 'DISCHARGE': #si es llamado por 1
scriptSys.GENERAL['mode'] = 'DISCHARGE'
scriptSys.TIME_INIT = scriptSys.TIME
if number == 1: print "DISCHARGE," + iDischarge1
if number == 2: print "DISCHARGE," + iDischarge2
if number == 3: print "DISCHARGE," + iDischarge3
return
if scriptSys.VOLTAGE < (umbralVoltTarget - umbralVolt) \
and (scriptSys.TIME - scriptSys.TIME_INIT) >= minTimeDischarge:
cond_state()
return
#condiciones de Fallas:
if scriptSys.CURRENT > (-iMargin) and scriptSys.VOLTAGE < vMargin:
scriptSys.final_report("F12", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeInit:
slope = scriptSys.get_slope(
range(scriptSys.TIME_INIT + 3, scriptSys.TIME))
if slope['VOLTAGE'] > 80 and slope['CURRENT'] > 180:
scriptSys.final_report("F13", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeDischarge:
scriptSys.final_report("F15", 0)
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "discharge_state()")
def discharge_state(number) :
try:
if not scriptSys.GENERAL['mode'] == 'DISCHARGE' : #si es llamado por 1
scriptSys.GENERAL['mode'] = 'DISCHARGE'
scriptSys.TIME_INIT = scriptSys.TIME
if number == 1 : print "DISCHARGE,"+ iDischarge1
if number == 2 : print "DISCHARGE,"+ iDischarge2
if number == 3 : print "DISCHARGE,"+ iDischarge3
return
if scriptSys.VOLTAGE < (umbralVoltTarget - umbralVolt) \
and (scriptSys.TIME - scriptSys.TIME_INIT) >= minTimeDischarge:
cond_state()
return
if (int(scriptSys.TIME) - int(scriptSys.TIME_INIT)) >= maxTimeDischarge:
scriptSys.final_report("maxTimeDischarge")
return
print "RUN"
return
except:
scriptSys.error_report("discharge_state()")
def evaluate() :
try:
capacityVectoAmps = 0
capacityVectorAh = 0
capacityVectoWatt = 0
for line in scriptSys.data:
i = int(line['CURRENT'])
t = int(line['TIME'])
if i >= (iDischTest1 - iMar) and i <=(iDischTest1 + iMar) \
and (t > scriptSys.TIME_INIT):
capacityVectoAmps += int(line['CURRENT'])
capacityVectoWatt += int(line['CURRENT']) * int(line['VOLTAGE'])
capacityAh = int(capacityVectoAmps / (1000*3600)) #/1000x mAmp y 3600xHr
capacityWh = int(capacityVectoAmps / (1000000*3600))
# scriptSys.import_data()
result = (scriptSys.TIME - scriptSys.TIME_INIT)
#regresion lineal
SoH = int((result * slope + origin)/1000)
scriptSys.final_report("sohAW",SoH,capacityAh,capacityWh)
return
except:
scriptSys.error_report("evaluate()")
def init_state() :
try:
if scriptSys.TIME >= maxTimeInit and scriptSys.VOLTAGE > vMargin:
scriptInc.measure_z1()
return
if scriptSys.TIME >= maxTimeInitFail and scriptSys.VOLTAGE <= vMargin:
scriptSys.final_report("F01",0)
return
# if scriptSys.VOLTAGE <= umbralVoltLow:
# charge_state(1)
# return
# if scriptSys.VOLTAGE > umbralVoltLow:
# stress_state()
# return
#
# if scriptSys.VOLTAGE < umbralVoltHigh and \
# scriptSys.VOLTAGE > umbralVoltLow:
# stress_state()
# return
print "RUN"
return
except:
scriptSys.error_report("init_state()")
def stress_test() :
try:
if scriptSys.GENERAL['mode'] != 'STRESS' : #si es llamado por 1
scriptSys.GENERAL['mode'] = 'STRESS'
scriptSys.TIME_INIT = scriptSys.TIME
print "DISCHARGE,"+ iDischargeTest1
return
if scriptSys.VOLTAGE <= vMargin:
scriptSys.final_report("maxTimeInitFail",0)
return
if scriptSys.VOLTAGE <= lowVoltageLimit: #si actula la proteccion cargo la Batery
evaluate()
return
actual_time = (scriptSys.TIME - scriptSys.TIME_INIT)
if actual_time >= tMaxStress :
scriptSys.final_report("tMaxStress",0)
return
print "RUN"
return
except:
scriptSys.error_report("stress_test()")
def charge_state(number) :
try:
if not scriptSys.GENERAL['mode'] == 'CHARGE' : #si es llamado por 1 vez
scriptSys.GENERAL['mode'] = 'CHARGE'
scriptSys.TIME_INIT = scriptSys.TIME
# if (umbralVoltTarget - scriptSys.VOLTAGE) <(0.1*umbralVoltTarget):
# number = 4
# elif (umbralVoltTarget -scriptSys.VOLTAGE)<(0.2*umbralVoltTarget):
# number = 3
# elif (umbralVoltTarget -scriptSys.VOLTAGE)<(0.4*umbralVoltTarget):
# number = 2
# else:
# number = 1
# if number == 4 : print "CHARGE,"+ vCharge4 +","+ iCharge4
# if number == 3 : print "CHARGE,"+ vCharge3 +","+ iCharge3
# if number == 1 :
print "CHARGE,"+ vCharge1 +","+ iCharge1
return
if scriptSys.VOLTAGE < (int(1000*float(vCharge2)) + vMargin) and \
scriptSys.VOLTAGE > (int(1000*float(vCharge2)) - vMargin) and \
scriptSys.CURRENT < vMargin:
scriptSys.final_report(0)
if scriptSys.CURRENT <= (umbralCurrentTarget) and \
(scriptSys.TIME - scriptSys.TIME_INIT) >= minTimeCharge:
cond_state()
return
if (int(scriptSys.TIME) - int(scriptSys.TIME_INIT)) >= maxTimeCharge :
scriptSys.final_report("maxTimeCharge")
return
# print "RUN"
print "CHARGE,"+ vCharge2 +","+ iCharge2
return
except:
scriptSys.error_report("charge_state()")
def cond_state():
try:
if not scriptSys.GENERAL['mode'] == 'CONDITIONING' : #es llamado por 1
scriptSys.GENERAL['mode'] = 'CONDITIONING'
scriptSys.TIME_INIT = scriptSys.TIME
print "PAUSE"
return
if ((scriptSys.TIME) - (scriptSys.TIME_INIT)) >= (maxTimeCond-tMargin):
stress_state()
return
if scriptSys.VOLTAGE < (int(1000*float(vCharge2)) + vMargin) and \
scriptSys.VOLTAGE > (int(1000*float(vCharge2)) - vMargin) and \
scriptSys.CURRENT < vMargin:
scriptSys.final_report(0)
# if scriptSys.VOLTAGE < umbralVoltLow:
# charge_state(2)
# scriptSys.ini_Update()
# sys.exit()
# return
#
# scriptInc.already_charged()
# if scriptSys.VOLTAGE > umbralVoltHigh:
# discharge_state(2)
# scriptSys.ini_Update()
# sys.exit()
# if scriptSys.VOLTAGE < umbralVoltHigh and \
# scriptSys.VOLTAGE > umbralVoltLow:
# scriptInc.measure_z1()
# scriptSys.ini_Update()
# sys.exit()
print "RUN"
return
except:
scriptSys.error_report("cond_state()")
def evaluate():
try:
scriptSys.import_data()
flag1 = True
flag2 = False
flag3 = False
flag4 = False
var = []
cur = []
for line in scriptSys.data:
i = int(line['CURRENT'])
t = int(line['TIME'])
s = int(line['STATUS'])
if s == 3 and flag1 and (t > scriptSys.TIME_INIT):
flag1 = False
ind = scriptSys.data.index(line) - 1
Vi0 = int(scriptSys.data[ind - 1]['VOLTAGE'])
Vi0 += int(scriptSys.data[ind - 2]['VOLTAGE'])
Vi0 += int(scriptSys.data[ind - 3]['VOLTAGE'])
Vi0 += int(scriptSys.data[ind - 4]['VOLTAGE'])
Vi0 += int(scriptSys.data[ind - 5]['VOLTAGE'])
Vi0 /= 5 #promedio de las ultimas 5 muestas antes de la descarga
t0 = int(line['TIME']) #tiempo de inicio de la descarga
flag2 = True
if s == 4 and flag2 and (t > scriptSys.TIME_INIT):
flag2 = False
ind = scriptSys.data.index(line) + 1
Vf0 = int(scriptSys.data[ind + 1]['VOLTAGE'])
Vf0 += int(scriptSys.data[ind + 2]['VOLTAGE'])
Vf0 += int(scriptSys.data[ind + 3]['VOLTAGE'])
Vf0 += int(scriptSys.data[ind + 4]['VOLTAGE'])
Vf0 += int(scriptSys.data[ind + 5]['VOLTAGE'])
Vf0 /= 5 #promedio de las ultimas 5 muestas antes de la descarga
Vd1 = Vi0 - int(scriptSys.data[ind + 0]['VOLTAGE'])
Vd2 = Vi0 - int(scriptSys.data[ind + 16]['VOLTAGE'])
flag3 = True
if s == 3 and (t > scriptSys.TIME_INIT
): #tomo las tensiones durante la descarga
var.append(int(line['VOLTAGE']))
cur.append(int(line['CURRENT']))
#regresion lineal
testnr = int(scriptSys.AUX['testnr'])
if testnr == 1:
origin = org
if testnr == 2:
origin = org - 9000
if testnr == 3:
origin = org - 10000
if testnr == 4:
origin = org - 10000
if testnr == 5:
origin = org - 11000
result = factor1 * Vd1 + factor2 * Vd2
SoH = int((result * slopeP + origin) / 1000)
current = sum(cur) / len(cur)
Zint = int((float(float(Vf0 - Vi0)) / float(current)) * 1000)
scriptSys.AUX['current' + str(testnr)] = current
scriptSys.AUX['Vf0' + str(testnr)] = Vf0
scriptSys.AUX['Vi0' + str(testnr)] = Vi0
scriptSys.AUX['Zint' + str(testnr)] = Zint
# scriptSys.send_msg('SoH'+str(testnr)+":"+str(SoH))
######################################################
#evaluacion de repetir el test
# t0 -= len(var)
######################################################
Va = 20 #pico negativo maximo en la descarga
Vam = 250
#caso A
ave = sum(var[5:20]) / len(var[5:20])
t = 0
for v in var[0:5]:
t += 1
if (ave - v) > Va:
scriptSys.AUX['casoA_t' + str(t0 + t - 1)] = (ave - v)
if int(scriptSys.AUX['strike']) >= 1:
if (t0 + t - 1) - int(scriptSys.AUX['striket']) >= 30:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
else:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
# scriptSys.send_msg('casoA tiempo: '+ str(t0 + t -1))
if (ave - v) > Vam:
scriptSys.AUX['casoAm_t' + str(t0 + t - 1)] = (ave - v)
scriptSys.AUX['strike'] = str(int(scriptSys.AUX['strike']) + 1)
# scriptSys.send_msg('casoA tiempo: '+ str(t0 + t -1))
scriptSys.final_report("SoHfail", SoH)
return
######################################################
Vb = 50 #caida promedio maxima en la descarga
Vbm = 300
#caso B
w = 10
t = 5
for x in range(5 + w, len(var) - 5 - w):
t += 1
ave = sum(var[x - w:x]) / len(var[x - w:x])
if (ave - var[x]) > Vb:
scriptSys.AUX['casoB_t' + str(t0 + t + w)] = (ave - var[x])
# scriptSys.send_msg('casoB tiempo: '+ str(t0 + t +w))
if int(scriptSys.AUX['strike']) >= 1:
if (t0 + t - 1) - int(scriptSys.AUX['striket']) >= 30:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
else:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
if (ave - var[x]) > Vbm:
scriptSys.AUX['casoBm_t' + str(t0 + t + w)] = (ave - var[x])
scriptSys.AUX['strike'] = str(int(scriptSys.AUX['strike']) + 1)
# scriptSys.send_msg('casoB tiempo: '+ str(t0 + t +w))
scriptSys.final_report("SoHfail", SoH)
return
######################################################
Vc = 20
Vcm = 200
#caso C
ave = sum(var[-25:-5]) / len(var[-25:-5])
t = len(var[:-25])
for v in var[-5:]:
t += 1
if (ave - v) > Vc:
scriptSys.AUX['casoC_t' + str(t0 + t - 1)] = (ave - v)
# scriptSys.send_msg('casoC tiempo: '+ str(t0 + t -1))
if int(scriptSys.AUX['strike']) >= 1:
if (t0 + t - 1) - int(scriptSys.AUX['striket']) >= 30:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
else:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
if (ave - v) > Vcm:
scriptSys.AUX['casoCm_t' + str(t0 + t + w)] = (ave - v)
# scriptSys.send_msg('casoC tiempo: '+ str(t0 + t -1))
scriptSys.AUX['strike'] = str(int(scriptSys.AUX['strike']) + 1)
scriptSys.final_report("SoHfail", SoH)
return
######################################################
Vdm = 2800 #tension de caida maxima
#caso D
t = 0
for v in var:
t += 1
if v < Vdm:
scriptSys.AUX['casoDm_t' + str(t0 + t - 1)] = v
# scriptSys.send_msg('casoD tiempo: '+ str(t0 + t -1))
scriptSys.final_report("SoHfail", SoH)
return
######################################################
#caso E
p = 0 #evaluacion de pendiente positiva
t = 0
for x in range(20, len(var) - 10):
p += var[x + 1] - var[x]
t += 1
if p > 16:
# scriptSys.send_msg('casoE pendiente: '+ str(p))
scriptSys.AUX['casoE_t' + str(t0 + t - 1)] = p
if int(scriptSys.AUX['strike']) >= 1:
if (t0 + t - 1) - int(scriptSys.AUX['striket']) >= 30:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
else:
scriptSys.AUX['strike'] = str(int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
######################################################
#casoF
w = 30 #evaluacion de caida de promedio
t = 15
for x in range(5 + w, len(var) - 5 - w):
t += 1
p = 0
for y in range(w):
p += var[x + y] - var[x + y + 1]
# print var[x]
if p > 132:
# scriptSys.send_msg('casoF pendiente: '+ str(p)+ ' tiempo: '+ str(t0 + t +w))
scriptSys.AUX['casoF_t' + str(t0 + t - 1)] = p
if int(scriptSys.AUX['strike']) >= 1:
if (t0 + t - 1) - int(scriptSys.AUX['striket']) >= 30:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
else:
scriptSys.AUX['strike'] = str(
int(scriptSys.AUX['strike']) + 1)
scriptSys.AUX['striket'] = str(t0 + t - 1)
######################################################
#evaluacion de strikes
strike = int(scriptSys.AUX['strike'])
scriptSys.AUX['strikeh'] = int(scriptSys.AUX['strikeh']) + strike
# if strike >= 3 or strikeh >= 3:
strikeh = int(scriptSys.AUX['strikeh'])
# scriptSys.final_report("SoHfail",SoH)
if strikeh >= 3:
scriptSys.final_report("SoHfail", SoH)
return
#evaluacion de repetir el test
# if testnr >= 2:
# soh1 = int(scriptSys.AUX['soh'+str(testnr-1)])
# # if abs(soh1-int(SoH)) < 20 and strike == 0:
# if abs(int(soh1)-int(SoH)) < 10:
# if (soh1+int(SoH))/2 > (Boundary + Bmargin):
# scriptSys.final_report("SoHok",SoH)
# return
# if (soh1+int(SoH))/2 < (Boundary - Bmargin):
# scriptSys.final_report("SoHfail",SoH)
# return
# if testnr >= 5:
# if (soh1+int(SoH))/2 >= (Boundary):
# scriptSys.final_report("SoHok",SoH)
# return
# if (soh1+int(SoH))/2 < (Boundary):
# scriptSys.final_report("SoHfail",SoH)
# return
if Zint > Z_BOUNDARY:
scriptSys.final_report("SoHok", Zint)
else:
scriptSys.final_report("SoHok", Zint)
scriptSys.AUX['strike'] = 0
scriptSys.TIME_INIT = scriptSys.TIME
scriptSys.AUX['testnr'] = str(int(scriptSys.AUX['testnr']) + 1)
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "evaluate()")
tTestB = tTest1 + tTest2
tTestC = tTest1 + tTest2 + tTest3
tTestD = tTest1 + tTest2 + tTest3 + tTest4
#
def measure_z1() :
try:
if scriptSys.GENERAL['mode'] != 'Z_MEASURE' : #si es 1 llamado
scriptSys.GENERAL['mode'] = 'Z_MEASURE'
scriptSys.TIME_INIT = scriptSys.TIME
<<<<<<< refs/remotes/origin/master
print "CHARGE,4.2,1.8"
return
ent = int(scriptSys.GENERAL['entradas'])
actual_time = (scriptSys.TIME - scriptSys.TIME_INIT)
if ent >= 63 :
scriptSys.final_report(0,0)
return
if ent >= 60:
print "CHARGE,4.2,1.8"
return
if ent >= 57:
print "PAUSE"
return
if ent >= 54:
print "DISCHARGE,1.0"
return
if ent >= 51:
print "PAUSE"
return
if ent >= 48:
print "CHARGE,4.2,1.8"
def inform():
try:
if scriptSys.SCRIPT['mode'] != 'INFORM': #si es llamado por primera vez
scriptSys.SCRIPT['mode'] = 'INFORM'
scriptSys.TIME_INIT = scriptSys.TIME
if scriptSys.DEV['datastate'] == 'OK':
if scriptSys.ANALYSIS['erasestate'] == 'OK':
if scriptSys.ANALYSIS['analysisstate'] == 'OK':
scriptSys.final_report('SUCCESS_A', 0)
elif scriptSys.ANALYSIS['analysisstate'] == 'FAIL':
scriptSys.final_report('FAIL_A',
int(scriptSys.AUX['failcode']))
else:
scriptSys.final_report('FAIL_Z',
int(scriptSys.AUX['failcode']))
elif scriptSys.ANALYSIS['erasestate'] == 'FAIL':
if scriptSys.ANALYSIS['analysisstate'] == 'OK':
scriptSys.final_report('FAIL_B', 0)
elif scriptSys.ANALYSIS['analysisstate'] == 'FAIL':
scriptSys.final_report('FAIL_C',
int(scriptSys.AUX['failcode']))
else:
scriptSys.final_report('FAIL_Y',
int(scriptSys.AUX['failcode']))
elif scriptSys.DEV['datastate'] == 'FAIL':
if scriptSys.ANALYSIS['analysisstate'] == 'OK':
scriptSys.final_report('FAIL_D', 0)
elif scriptSys.ANALYSIS['analysisstate'] == 'FAIL':
scriptSys.final_report('FAIL_E',
int(scriptSys.AUX['failcode']))
else:
scriptSys.final_report('FAIL_X',
int(scriptSys.AUX['failcode']))
else:
scriptSys.final_report('FAIL_W',
int(scriptSys.AUX['failcode']))
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeInform:
print "STOP"
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "inform()")
def charge_state(number):
try:
if not scriptSys.GENERAL['mode'] == 'CHARGE': #si es llamado por 1 vez
scriptSys.GENERAL['mode'] = 'CHARGE'
scriptSys.TIME_INIT = scriptSys.TIME
print "CHARGE," + vCharge1 + "," + iCharge1
return
if scriptSys.CURRENT < iMargin and \
scriptSys.VOLTAGE > (int(1000*float(vCharge2))-100) :
scriptSys.final_report("F03", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) <= maxTimeInit:
print "CHARGE," + vCharge2 + "," + iCharge2
return
if scriptSys.CURRENT < (umbralCurrentTarget) and \
(scriptSys.TIME - scriptSys.TIME_INIT) >= minTimeCharge:
cond_state()
return
#condiciones de Fallas:
if scriptSys.CURRENT < iMargin:
scriptSys.final_report("F02", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeInit:
slope = scriptSys.get_slope(
range(scriptSys.TIME_INIT + 3, scriptSys.TIME))
if scriptSys.GENERAL['vstate'] == "vBAJA" and not slope['VOLTAGE'] > -80 \
and scriptSys.CURRENT > (int(1000*float(iCharge2))-200):
scriptSys.final_report("F04", 0)
return
if scriptSys.GENERAL['vstate'] == "vMEDIA" and not slope['VOLTAGE'] > -80\
and scriptSys.CURRENT > (int(1000*float(iCharge2))-200):
scriptSys.final_report("F05", 0)
return
if scriptSys.GENERAL['vstate'] == "vALTA" and not slope['CURRENT'] < 80\
and scriptSys.VOLTAGE > (int(1000*float(vCharge2))-200):
scriptSys.final_report("F06", 0)
return
if slope['VOLTAGE'] > 0 and slope['CURRENT'] < 80:
scriptSys.final_report("F07", 0)
return
if slope['VOLTAGE'] < 100:
scriptSys.final_report("F08", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeChargeLow and \
scriptSys.GENERAL['vstate'] == "vBAJA" :
scriptSys.final_report("F09", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeChargeMed and \
scriptSys.GENERAL['vstate'] == "vMEDIA" :
scriptSys.final_report("F10", 0)
return
if (scriptSys.TIME - scriptSys.TIME_INIT) >= maxTimeChargeHig and \
scriptSys.GENERAL['vstate'] == "vALTA" :
scriptSys.final_report("F11", 0)
return
print "RUN"
return
except Exception as e:
scriptSys.error_report(e, "charge_state()")
if ENTRADAS >= 162 and ENTRADAS < 165:
print "PAUSE"
sys.exit()
if ENTRADAS > 165:
scriptSys.final_report(0, 0)
sys.exit()
return
################################################################
################################################################
########## MAIN ##########
################################################################
################################################################
if scriptSys.Msg == 81:
scriptSys.final_report("F22", 0)
sys.exit()
if scriptSys.GENERAL['mode'] == "INIT":
testA()
# init_state()
elif scriptSys.GENERAL['mode'] == "CHARGE":
charge_state(1)
elif scriptSys.GENERAL['mode'] == "DISCHARGE":
discharge_state(1)
elif scriptSys.GENERAL['mode'] == "CONDITIONING":
cond_state()
elif scriptSys.GENERAL['mode'] == "Z_MEASURE":
zmeasure_state()
elif scriptSys.GENERAL['mode'] == "Z_MEASURE2":
zmeasure2_state()
elif scriptSys.GENERAL['mode'] == "STRESS":
