def __init__(self, *args):
super(TestFbpWindow, self).__init__(*args)
uic.loadUi('wizard.ui', self)
self._initialize_widgets()
self._initialize_signals()
self._list_serial_ports()
self._current_ps_id = {
'Fonte 1': 1,
'Fonte 2': 2,
'Fonte 3': 3,
'Fonte 4': 4,
'Todas': 5
}
self._bsmp_var = {
'soft_intlk': 25,
'hard_intlk': 26,
'iload': 27,
'vload': 28,
'vdclink': 29,
'temp': 30,
'digital_pot': 35
}
self._drs = SerialDRS()
def __init__(self):
QThread.__init__(self)
self._drs = SerialDRS()
self._baudrate = '6000000'
self._is_active = False
self._screen_readings = {
'setpoint': 0.0,
'reference': 0.0,
'slowref_counter': 0,
'syncpulse_counter': 0,
'iload_1': 0.0,
'iload_2': 0.0,
'vload': 0.0,
'vcapbank': 0.0,
'induc_temp': 0.0,
'igbt_temp': 0.0,
'duty_cycle': 0,
'soft_intlk': 0,
'hard_intlk': 0,
'fwr_version': ''
}
self._hard_interlocks = [
'Falha nos drivers do módulo', 'Sub-tensão no DCLINK',
'Sobre-tensão no DCLINK', 'Sobre-tensão na carga',
'Sobre-corrente na carga'
]
self._soft_interlocks = [
'Falha leitura DCCT 2', 'Falha leitura DCCT 1',
'Alta diferença entre DCCTs', 'Falha DCCT 2', 'Falha DCCT 1',
'Sobre-temperatura nos indutores',
'Sobre-temperatura nos indutores'
]
def __init__(self):
QThread.__init__(self)
self._comport = None
self._baudrate = None
self._boardsinfo = []
self._nHRADC = None
self._led = None
self.drs = SerialDRS()
self.source = KrohnHite523_GPIB()
self.dmm = Keysight3458A_GPIB()
self.refVal = {'GND': 0,
'Vref_bipolar_p': 5,
'Vref_bipolar_n': -5,
'Temp': -0.35,
'Vin_bipolar_p': 10,
'Vin_bipolar_n': -10,
'Iin_bipolar_p': 0.05,
'Iin_bipolar_n': -0.05
}
self.refTol = {'GND': 0.02,
'Vref_bipolar_p': 0.02,
'Vref_bipolar_n': 0.02,
'Temp': 0.1,
'Vin_bipolar_p': 0.02,
'Vin_bipolar_n': 0.02,
'Iin_bipolar_p': 0.0003,
'Iin_bipolar_n': 0.0003}
def __init__(self, comport=None, baudrate=None, serial_number=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
#self._serial_port = serial.Serial()
self.FBP = SerialDRS()
def __init__(self):
QThread.__init__(self)
self._comport = None
self._baudarate = None
self._serial_number = []
self._ps_address = 1
self.FBP = SerialDRS()
def __init__(self, comport=None, baudrate=None,
mod0=None, mod1=None, mod2=None, mod3=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_mod0 = mod0
self._serial_mod1 = mod1
self._serial_mod2 = mod2
self._serial_mod3 = mod3
self._serial_port = serial.Serial()
self._active_interlocks = ''
self.FBP = SerialDRS()
def __init__(self,
comport=None,
baudrate=None,
serial_number=None,
variant=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
self._variant = variant
self.FBP = SerialDRS()
self._load_current = [0, 0, 2, 4, 6, 8, 10, -10, -8, -6, -4, -2]
def __init__(self, comport=None, baudrate=None, serial_number=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
self._led = None
self._buzzer = None
self._details = ""
self._loopback_fail = "\n"
self._index_res_ok = 3
self._send_partial_data = False
self._udc = SerialDRS()
def __init__(self):
self._baudrate = '6000000'
self._drs = SerialDRS()
self._is_active = False
self._screen_readings = {
'readback': 0.0,
'slowref_counter': 0,
'syncpulse_counter': 0,
'iload_1': 0.0,
'iload_2': 0.0,
'vload': 0.0,
'vcapbank': 0.0,
'induc_temp': 0.0,
'igbt_temp': 0.0,
'duty_cycle': 0,
'soft_intlk': 0,
'hard_intlk': 0
}
def __init__(self):
QThread.__init__(self)
self._comport = None
self._baudrate = None
self._serial_mod0 = None
self._serial_mod1 = None
self._serial_mod2 = None
self._serial_mod3 = None
self._serial_list = []
self._variant_list = []
self._nHRADC = None
self._led = None
self.drs = SerialDRS()
self.source = KrohnHite523_GPIB()
self.dmm = Keysight3458A_GPIB()
def __init__(self):
QThread.__init__(self)
self._is_active = False
self._baudrate = '6000000'
#self._baudrate = '115200'
self._drs = SerialDRS()
self._screen_readings = {
'digital_pot_read': 0.0,
'fault_status': 0,
'intlk': 0,
'vdclink_1': 0.0,
'vdclink_2': 0.0,
'vdclink_3': 0.0,
'vdclink_4': 0.0
}
self._interlocks = [
'Sobre tensão na fonte 3', 'Sobre-tensão na fonte 2',
'Sobre-tensão na fonte 1', 'Interlock externo', 'Sensor de fumaça',
'Falha Fonte 3', 'Falha Fonte 2', 'Falha Fonte 1'
]
class FacAcdc:
def __init__(self):
self._baudrate = '6000000'
self._drs = SerialDRS()
self._is_active = False
self._screen_readings = {
'readback': 0.0,
'slowref_counter': 0,
'syncpulse_counter': 0,
'iload_1': 0.0,
'iload_2': 0.0,
'vload': 0.0,
'vcapbank': 0.0,
'induc_temp': 0.0,
'igbt_temp': 0.0,
'duty_cycle': 0,
'soft_intlk': 0,
'hard_intlk': 0
}
@property
def is_active(self):
return self._is_active
def connect_serial(self, com_port):
res = False
if com_port is not None:
res = self._drs.Connect(com_port, self._baudrate)
self._is_active = True
return res
def disconnect_serial(self):
res = self._drs.Disconnect()
self._is_active = False
return res
def turn_on(self):
res = self._drs.turn_on()
return res
def turn_off(self):
res = self._drs.turn_off()
return res
def open_loop(self):
res = self._drs.open_loop()
return res
def close_loop(self):
res = self._drs.close_loop()
return res
def soft_intlk_info(self):
pass
def soft_intlk_reset(self):
pass
def hard_intlk_info(self):
pass
def hard_intlk_reset(self):
pass
def update_params(self):
pass
class DCCTTest(QThread):
test_complete = pyqtSignal(bool)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
def __init__(self,
comport=None,
baudrate=None,
serial_number=None,
variant=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
self._variant = variant
self.FBP = SerialDRS()
self._load_current = [0, 0, 2, 4, 6, 8, 10, -10, -8, -6, -4, -2]
@property
def serial_number(self):
return self._serial_number
@serial_number.setter
def serial_number(self, value):
self._serial_number = value
@property
def variant(self):
return self._variant
@variant.setter
def variant(self, value):
self._variant = value
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudarate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
self.FBP.SetSlaveAdd(5)
return self.FBP.Connect(self._comport, self._baudrate)
def test_communication(self):
result = (False, False
) # Result for communication test and aux power supply
try:
print('##########################')
print(self.FBP.Write_sigGen_Aux(1))
time.sleep(5)
test_package = self.FBP.Read_ps_Model()
if (test_package[0] == 0) and (test_package[1] == 17) and (
test_package[2] == 512) and (test_package[3]
== 14) and (test_package[4]
== 223):
result = (True, True)
else:
result = (False, False)
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
except:
result = (False, False)
return result
def _test_sequence(self):
result = False
list_log = []
current_DCCT = []
current_DCCT1 = []
current_DCCT2 = []
dcct = DCCT()
dcct.serial_number = self._serial_number
dcct.variant = self._variant
res = self._send_to_server(dcct)
print(dcct.variant)
if res:
#TODO: Sequencia de Testes
if self.FBP.Read_ps_SoftInterlocks() is not 0:
if round(self.FBP.Read_iMod1()) == 0 and round(self.FBP.Read_iMod2()) == 0\
and round(self.FBP.Read_iMod3()) == 0 and round(self.FBP.Read_iMod4()) == 0:
print('Resetando Interlocks...')
self.FBP.ResetInterlocks()
else:
print(
'Jiga com problemas! Verifique os Soft interlocks ativos...'
)
if self.FBP.Read_ps_HardInterlocks() is not 0:
if round(self.FBP.Read_iMod1()) == 0 and round(self.FBP.Read_iMod2()) == 0\
and round(self.FBP.Read_iMod3()) == 0 and round(self.FBP.Read_iMod4()) == 0:
print('Resetando Interlocks...')
self.FBP.ResetInterlocks()
else:
print(
'Jiga com problemas! Verifique os Hard interlocks ativos...'
)
print('variante ' + str(self._variant))
if self._variant == 'DCCT-CONF-A':
list_log.append(DCCTLog())
list_log.append(DCCTLog())
current_DCCT1.append(self.FBP.Read_iMod3(
)) # medidas de corrente com fonte desligada
current_DCCT2.append(self.FBP.Read_iMod4(
)) # medidas de corrente com fonte desligada
time.sleep(1)
self.FBP.TurnOn(0b0001)
time.sleep(1)
if self.FBP.Read_ps_OnOff() is not 1:
print('ERRO! O MÓDULO NÃO LIGOU CORRETAMENTE!!!')
self.update_gui.emit(
'O módulo da Jiga não ligou corretamente. Desligue a jiga reinicie o teste!!!'
)
else:
self.update_gui.emit('Fonte ligada')
time.sleep(1)
self.FBP.ClosedLoop(0b0001)
self.update_gui.emit('Malha fechada')
time.sleep(1)
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
for i in range(1, len(self._load_current)):
self.FBP.SetISlowRef(self._load_current[i])
time.sleep(1)
self.update_gui.emit(
'Testando DCCTs com corrente de ' +
str(self._load_current[i]) + 'A')
self.update_gui.emit(
' Corrente de saida do modulo padrao: '
+ str(round(self.FBP.Read_iMod1())) + 'A')
compare_mod1 = round(self.FBP.Read_iMod1())
if not self._load_current[i] == compare_mod1:
self.update_gui.emit(str(self._load_current[i]))
self.update_gui.emit(str(compare_mod1))
self.update_gui.emit(
'\nMAU FUNCIONAMENTO NO TESTE: CIRCUITO ABERTO OU DEFEITO NO MODULO PADRAO\n'
)
time.sleep(30) # Alterar para 30s
self.update_gui.emit(' Corrente DCCT1: ' +
str(self.FBP.Read_iMod3()) + 'A')
self.update_gui.emit(' Corrente DCCT2: ' +
str(self.FBP.Read_iMod4()) + 'A')
print(self.FBP.Read_iMod3())
print(self.FBP.Read_iMod4())
current_DCCT1.append(self.FBP.Read_iMod3())
current_DCCT2.append(self.FBP.Read_iMod4())
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
current_DCCT.append(current_DCCT1)
current_DCCT.append(current_DCCT2)
for j in range(0, 2):
for k in range(0, len(self._load_current)):
if round(current_DCCT[j]
[k]) == self._load_current[k]:
string_result = 'Aprovado'
result = True
else:
string_result = 'Reprovado'
result = False
break
list_log[j].test_result = string_result
self.update_gui.emit('DCCT' + str(j + 1) + ' ' +
str(list_log[j].test_result))
for l in range(2):
list_log[l].iload_off = current_DCCT[l][0]
list_log[l].iload0 = current_DCCT[l][1]
list_log[l].iload1 = current_DCCT[l][2]
list_log[l].iload2 = current_DCCT[l][3]
list_log[l].iload3 = current_DCCT[l][4]
list_log[l].iload4 = current_DCCT[l][5]
list_log[l].iload5 = current_DCCT[l][6]
list_log[l].iload6 = current_DCCT[l][7]
list_log[l].iload7 = current_DCCT[l][8]
list_log[l].iload8 = current_DCCT[l][9]
list_log[l].iload9 = current_DCCT[l][10]
list_log[l].iload10 = current_DCCT[l][11]
list_log[l].id_canal_dcct = l + 1
list_log[l].serial_number_dcct = self._serial_number
if self._send_to_server(list_log[0]):
self.update_gui.emit('Dados enviados para o servidor')
else:
self.update_gui.emit(
'Erro no envio de dados para o servidor')
if self._send_to_server(list_log[1]):
self.update_gui.emit('Dados enviados para o servidor')
else:
self.update_gui.emit(
'Erro no envio de dados para o servidor')
elif self._variant == 'DCCT-CONF-B':
list_log.append(DCCTLog())
list_log.append(None)
current_DCCT1.append(self.FBP.Read_iMod3(
)) # medidas de corrente com fonte desligada
time.sleep(1)
self.FBP.TurnOn(0b0001)
time.sleep(1)
if self.FBP.Read_ps_OnOff() is not 1:
print('ERRO! O MÓDULO NÃO LIGOU CORRETAMENTE!!!')
self.update_gui.emit(
'O módulo da Jiga não ligou corretamente. Desligue a jiga e reinicie o teste!!!'
)
else:
self.update_gui.emit('Fonte ligada')
time.sleep(1)
self.FBP.ClosedLoop(0b0001)
self.update_gui.emit('Malha fechada')
time.sleep(1)
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
for i in range(1, len(self._load_current)):
self.FBP.SetISlowRef(self._load_current[i])
time.sleep(1)
self.update_gui.emit(
'Testando DCCTs com corrente de ' +
str(self._load_current[i]) + 'A')
self.update_gui.emit(
' Corrente de saida do modulo padrao: '
+ str(round(self.FBP.Read_iMod1())) + 'A')
compare_mod1 = round(self.FBP.Read_iMod1())
if not self._load_current[i] == compare_mod1:
self.update_gui.emit(str(self._load_current[i]))
self.update_gui.emit(str(compare_mod1))
self.update_gui.emit(
'\nMAU FUNCIONAMENTO NO TESTE: CIRCUITO ABERTO OU DEFEITO NO MODULO PADRAO\n'
)
time.sleep(30) # Alterar para 30s
self.update_gui.emit(' Corrente DCCT1: ' +
str(self.FBP.Read_iMod3()) + 'A')
current_DCCT1.append(self.FBP.Read_iMod3())
for j in range(0, len(self._load_current)):
if round(current_DCCT1[j]) == self._load_current[j]:
string_result = 'Aprovado'
result = True
else:
string_result = 'Reprovado'
result = False
break
list_log[0].test_result = string_result
self.update_gui.emit('DCCT1 ' +
str(list_log[0].test_result))
list_log[0].iload_off = current_DCCT1[0]
list_log[0].iload0 = current_DCCT1[1]
list_log[0].iload1 = current_DCCT1[2]
list_log[0].iload2 = current_DCCT1[3]
list_log[0].iload3 = current_DCCT1[4]
list_log[0].iload4 = current_DCCT1[5]
list_log[0].iload5 = current_DCCT1[6]
list_log[0].iload6 = current_DCCT1[7]
list_log[0].iload7 = current_DCCT1[8]
list_log[0].iload8 = current_DCCT1[9]
list_log[0].iload9 = current_DCCT1[10]
list_log[0].iload10 = current_DCCT1[11]
list_log[0].id_canal_dcct = 1
list_log[0].serial_number_dcct = self._serial_number
if self._send_to_server(list_log[0]):
self.update_gui.emit('Dados enviados para o servidor')
else:
self.update_gui.emit(
'Erro no envio de dados para o servidor')
self.FBP.TurnOff(0b0001)
self.test_complete.emit(result)
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
client_method = item.method
client_response = client.do_request(client_method, client_data)
print(client_response)
server_status = self._parse_response(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def run(self):
self._test_sequence()
class RackTest(QThread):
test_complete = pyqtSignal(bool)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
def __init__(self, comport=None, baudrate=None, serial_number=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
#self._serial_port = serial.Serial()
self.FBP = SerialDRS()
@property
def serial_number(self):
return self._serial_number
@serial_number.setter
def serial_number(self, value):
self._serial_number = value
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudarate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
self.FBP.SetSlaveAdd(5)
return self.FBP.Connect(self._comport, self._baudrate)
def test_communication(self):
result = False # Result for communication test
try:
self.FBP.Write_sigGen_Aux(0)
test_package = self.FBP.Read_ps_Model()
if (test_package[0] == 0) and (test_package[1] == 17) and (test_package[2] == 512) and (test_package[3] == 14) and (test_package[4] == 223):
result = True
else:
result = False
except:
result = False
return result
def _test_sequence(self):
result = True
test_setup = False
list_iout0 = []
list_iout1 = []
list_iout2 = []
list_iout3 = []
rack = Rack()
rack.serial_number = self._serial_number
res = self._send_to_server(rack)
if res:
#TODO: Sequencia de Testes
self.FBP.Write_sigGen_Aux(0) # Usando 0 modulos de potência
log = RackLog()
for i in range(0, 10):
list_iout0.append(self.FBP.Read_iMod1())
list_iout1.append(self.FBP.Read_iMod2())
list_iout2.append(self.FBP.Read_iMod3())
list_iout3.append(self.FBP.Read_iMod4())
self.update_gui.emit('aguarde 5 segundos para o início da ' + str(i+1) + ' leitura')
time.sleep(5) # Alterar para 60s
self.update_gui.emit('leitura ' + str(i+1) + ':')
self.update_gui.emit('iout0 = ' + str(list_iout0[i]) + ' A')
self.update_gui.emit('iout1 = ' + str(list_iout1[i]) + ' A')
self.update_gui.emit('iout2 = ' + str(list_iout2[i]) + ' A')
self.update_gui.emit('iout3 = ' + str(list_iout3[i]) + ' A')
if (abs(round(list_iout0[i]))>=12) or (abs(round(list_iout1[i]))>=12) \
or (abs(round(list_iout2[i]))>=12) or (abs(round(list_iout3[i]))>=12):
self.update_gui.emit('ERRO: REPITA O PROCEDIMENTO DE CONEXÕES DO BASTIDOR E INICIE UM NOVO TESTE')
test_setup = False
break
else:
test_setup = True
if test_setup:
for j in range(0, 10):
if (round(list_iout0[j])==-2) and (round(list_iout1[j])==1) and (round(list_iout2[j])==-3) and ((round(list_iout3[j]) == 3) or (round(list_iout3[j]) == 2)):
if result:
log.test_result = 'Aprovado'
result = True
else:
log.test_result = 'Reprovado'
result = False
if result:
self.update_gui.emit('Aprovado')
else:
self.update_gui.emit('Reprovado')
log.iout0 = sum(list_iout0)/len(list_iout0)
log.iout1 = sum(list_iout1)/len(list_iout1)
log.iout2 = sum(list_iout2)/len(list_iout2)
log.iout3 = sum(list_iout3)/len(list_iout3)
log.delta_iout0 = max(list_iout0) - min(list_iout0)
log.delta_iout1 = max(list_iout1) - min(list_iout1)
log.delta_iout2 = max(list_iout2) - min(list_iout2)
log.delta_iout3 = max(list_iout3) - min(list_iout3)
log.serial_number_rack = self._serial_number
log.details = ""
if self._send_to_server(log):
self.update_gui.emit('Dados enviados para o servidor')
else:
self.update_gui.emit('Erro no envio de dados para o servidor')
# ao finalizar, emitir signals
self.test_complete.emit(result)
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
client_method = item.method
client_response = client.do_request(client_method, client_data)
server_status = self._parse_response(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def run(self):
self._test_sequence()
class HRADCCalib(QThread):
calib_complete = pyqtSignal(bool)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
device = {'HRADC': 1, 'DM': 2}
bytesFormat = {'Uint16': 'H', 'Uint32': 'L', 'Uint64': 'Q', 'float': 'f'}
ufmOffset = {
'serial': 0,
'calibdate': 4,
'variant': 9,
'rburden': 10,
'calibtemp': 12,
'vin_gain': 14,
'vin_offset': 16,
'iin_gain': 18,
'iin_offset': 20,
'vref_p': 22,
'vref_n': 24,
'gnd': 26
}
hradcVariant = {'HRADC-FBP': 0, 'HRADC-FAX': 1}
hradcInputTypes = [
'GND', 'Vref_bipolar_p', 'Vref_bipolar_n', 'Temp', 'Vin_bipolar',
'Iin_bipolar'
]
# DMM param
nplc = 10
dmmSampleCount = 4
# DC Source param
settlingTime = 2
vin_lsb = 20 / pow(2, 18)
vin_step = vin_lsb / 4
vin_max = 10.2
iin_lsb = 0.1 / pow(2, 18)
iin_step = iin_lsb / 3
iin_max = 0.051
warmup_min = 20 # 0.084 # 20 minutes
def __init__(self):
QThread.__init__(self)
self._comport = None
self._baudrate = None
self._serial_mod0 = None
self._serial_mod1 = None
self._serial_mod2 = None
self._serial_mod3 = None
self._serial_list = []
self._variant_list = []
self._nHRADC = None
self._led = None
self.drs = SerialDRS()
self.source = KrohnHite523_GPIB()
self.dmm = Keysight3458A_GPIB()
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudrate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
@property
def serial_list(self):
return self._serial_list
@serial_list.setter
def serial_list(self, value_list):
self._serial_list = value_list
@property
def variant_list(self):
return self._variant_list
@variant_list.setter
def variant_list(self, value_list):
self._variant_list = value_list
@property
def serial_mod0(self):
return self._serial_mod0
@serial_mod0.setter
def serial_mod0(self, value):
self._serial_mod0 = value
@property
def serial_mod1(self):
return self._serial_mod1
@serial_mod1.setter
def serial_mod1(self, value):
self._serial_mod1 = value
@property
def serial_mod2(self):
return self._serial_mod2
@serial_mod2.setter
def serial_mod2(self, value):
self._serial_mod2 = value
@property
def serial_mod3(self):
return self._serial_mod3
@serial_mod3.setter
def serial_mod3(self, value):
self._serial_mod3 = value
@property
def nHRADC(self):
return self._nHRADC
@nHRADC.setter
def nHRADC(self, value):
self._nHRADC = value
def _timeout(self):
print('\nFim do warm-up\n')
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
self.dmm.Connect('GPIB0::22::INSTR')
self.source.Connect('GPIB0::25::INSTR')
self.source.DisableOutput()
#self.source.Reset()
self.source.LOFloatChassis('F')
self.source.OutputTermination(0)
self.source.SetVoltageLimit(2)
self.source.SetOutput(0, 'V')
self.dmm.InitDefault()
self.dmm.SetMeasurementType('DCV', 10)
self.dmm.SetMultipointMeas(self.dmmSampleCount)
return self.drs.Connect(self._comport, self._baudrate)
def test_communication(self):
try:
test_package = self.drs.Read_ps_Model()
print(test_package)
if (test_package[0] == 0) and (test_package[1] == 17) and (
test_package[2] == 512) and (test_package[3]
== 10) and (test_package[4]
== 227):
print('TRUE')
return True
print('FALSE')
return False
except:
print('EXCEPT')
return False
def _calib_sequence(self):
print(
'\n\n\n\n**********************************************************************************************************'
)
print(' Valeeendoooo!!!')
print(
'**********************************************************************************************************\n'
)
t0 = time.perf_counter()
print(self.serial_list)
print(self.variant_list)
"""
fig = plt.figure()
# HRADC samples
ax1 = fig.add_subplot(2,2,1)
ax1.ticklabel_format(useOffset = False)
ax1.set_ylabel('HRADC Samples [LSB]')
ax1.grid()
# Samples histogram
ax2 = fig.add_subplot(2,2,2)
ax2.ticklabel_format(useOffset = False)
ax3 = fig.add_subplot(2,2,3) # HRADC mean Vs DMM mean
ax3_2 = ax3.twinx()
ax4 = fig.add_subplot(2,2,4) # HRADC std Vs DMM std
ax4_2 = ax4.twinx()
"""
print('\nInicializando equipamentos...\n')
self.update_gui.emit('Inicializando equipamentos...')
self.source.DisableOutput()
self.source.LOFloatChassis('F')
self.source.OutputTermination(0)
self.source.SetVoltageLimit(2)
self.source.SetOutput(0, 'V')
self.dmm.InitDefault()
self.dmm.SetMeasurementType('DCV', 10)
self.dmm.SetMultipointMeas(self.dmmSampleCount)
self.nHRADC = 4 - self.serial_list.count(None)
t = ' placas' if self.nHRADC > 1 else ' placa'
t2 = 'Inicializando calibracao de ' + str(
self.nHRADC) + t + ' HRADC...'
print(t2 + '\n')
self.update_gui.emit(t2)
self.drs.Config_nHRADC(self.nHRADC)
time.sleep(1)
print('Resetando' + t + '...\n')
self.update_gui.emit('Resetando' + t + '...')
self.drs.ResetHRADCBoards(1)
time.sleep(1)
self.drs.ResetHRADCBoards(0)
time.sleep(1)
self.drs.OpMode(1) # Para enviar amostras sem conversao
time.sleep(0.5)
print('Configurando backplane...\n')
self.update_gui.emit('Configurando backplane...')
self.drs.SelectHRADCBoard(0)
time.sleep(0.5)
self.drs.SelectTestSource('Vin_bipolar')
time.sleep(0.5)
print('Configurando' + t + ' em Vref_bipolar_p...\n')
self.update_gui.emit('Configurando' + t + ' em Vref_bipolar_p...')
for slot in range(self.nHRADC):
self.drs.ConfigHRADC(slot, 100000, 'Vref_bipolar_p', 0, 0)
time.sleep(1)
print('Iniciando warm-up...\n')
self.update_gui.emit('Iniciando warm-up...\n')
self.drs.EnableHRADCSampling()
t = Timer(self.warmup_min * 60, self._timeout)
t.start()
while (t.is_alive()):
print(time.strftime("%H:%M:%S", time.localtime()))
time.sleep(1)
self.drs.DisableHRADCSampling()
time.sleep(1)
#########################
#### ITERAR AQUI!!! #####
#########################
for slot in range(self.nHRADC):
#slot = 0
log = HRADCLogCalib()
ufmdata_16 = []
emptyBuff = np.array([])
log.serial_number_hradc = self.serial_list[slot]
variant = self.variant_list[slot]
print('************ Iniciando a calibracao do slot #' + str(slot) +
' ( S/N: ' + str(log.serial_number_hradc) + ' / ' + variant +
') ************\n')
self.update_gui.emit('*** INICIANDO CALIBRACAO DO SLOT #' +
str(slot) + ' ( S/N: ' +
str(log.serial_number_hradc) + ' / ' +
variant + ') ***')
self.source.DisableOutput()
self.source.SetOutput(0, 'V')
self.dmm.SetMeasurementType('DCV', 10)
self.drs.SelectTestSource('Vin_bipolar')
time.sleep(0.5)
self.drs.SelectHRADCBoard(slot)
time.sleep(0.5)
print('*****************************************')
print('****** Iniciando calibracao Vin... ******')
print('*****************************************\n')
self.drs.ConfigHRADC(slot, 100000, 'Vin_bipolar', 0, 0)
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(0.5)
################################################
print(' *** Configurando Vin -FS ... ***\n')
################################################
self.update_gui.emit(' Encontrando fundo de escala -Vin...')
sourceOut = -9.9
self.source.EnableOutput()
while True:
sourceOut = self._saturate(sourceOut, -self.vin_max,
self.vin_max)
# if any HRADC samples != 0, set source lower
print('sourceOut = ' + str(sourceOut) + ' V\n')
self.source.SetOutput(sourceOut, 'V')
time.sleep(self.settlingTime)
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_blocks(0))
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
deltaFS = meanHRADC * self.vin_lsb
inc = deltaFS if deltaFS > self.vin_lsb else self.vin_lsb
print('\nmax meanHRADC stdHRADC inc')
print(
str(sampHRADC.max()) + ' ' + str(meanHRADC) + ' ' +
str(stdHRADC) + ' ' + str(inc) + '\n')
if ((sampHRADC == 0).all()):
break
sourceOut -= inc
vin_negFS = np.array(self.dmm.ReadMeasurementPoints()).mean()
print('Vin -FS: ' + str(vin_negFS) + ' V\n')
#################################################
print('\n *** Procurando Vin T[1] ... ***\n')
#################################################
self.update_gui.emit(' Procurando Vin T[1]...')
sumNonFSCodes = 0
T_1 = vin_negFS
while True:
# Increment source output
sourceOut += self.vin_step
sourceOut = self._saturate(sourceOut, -self.vin_max,
self.vin_max)
print('sourceOut = ' + str(sourceOut) + ' V\n')
self.source.SetOutput(sourceOut, 'V')
time.sleep(self.settlingTime)
# Start measurements
self.dmm.TrigMultipointMeas()
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
print('\nmax meanHRADC stdHRADC')
print(
str(sampHRADC.max()) + ' ' + str(meanHRADC) + ' ' +
str(stdHRADC) + '\n')
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
#T_1 = np.array(DMM.ReadMeasurementPoints()).mean()
old_T_1 = T_1
T_1 = np.array(self.dmm.GetMultipointMeas()).mean()
# Repeat if more than 50% HRADC samples == 0
old_sumNonFSCodes = sumNonFSCodes
sumNonFSCodes = sum(sampHRADC > 0)
print('DMM T[1] "non-FS codes"')
print(str(T_1) + ' ' + str(sumNonFSCodes) + '\n')
if (sumNonFSCodes >= len(sampHRADC) / 2):
break
T_1 = (old_T_1 * old_sumNonFSCodes +
T_1 * sumNonFSCodes) / (old_sumNonFSCodes + sumNonFSCodes)
print('*** Vin T[1]: ' + str(T_1) + ' V ***\n\n')
################################################
print(' *** Configurando Vin +FS ... ***\n')
################################################
self.update_gui.emit(' Encontrando fundo de escala +Vin...')
sourceOut = 9.9
while True:
sourceOut = self._saturate(sourceOut, -self.vin_max,
self.vin_max)
# if any HRADC samples != 0, set source lower
print('sourceOut = ' + str(sourceOut) + ' V\n')
self.source.SetOutput(sourceOut, 'V')
time.sleep(self.settlingTime)
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_blocks(0))
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
deltaFS = 20 - meanHRADC * self.vin_lsb
inc = deltaFS if deltaFS > self.vin_lsb else self.vin_lsb
print('\nmin meanHRADC stdHRADC inc')
print(
str(sampHRADC.min()) + ' ' + str(meanHRADC) + ' ' +
str(stdHRADC) + ' ' + str(inc) + '\n')
if ((sampHRADC == 0x3FFFF).all()):
break
sourceOut += inc
vin_posFS = np.array(self.dmm.ReadMeasurementPoints()).mean()
print('Vin +FS: ' + str(vin_posFS) + ' V\n')
###################################################
print('\n *** Procurando Vin T[end] ... ***\n')
###################################################
self.update_gui.emit(' Procurando Vin T[end]...')
sumNonFSCodes = 0
T_end = vin_posFS
while True:
# Decrement source output
sourceOut -= self.vin_step
sourceOut = self._saturate(sourceOut, -self.vin_max,
self.vin_max)
print('sourceOut = ' + str(sourceOut) + ' V\n')
self.source.SetOutput(sourceOut, 'V')
time.sleep(self.settlingTime)
# Start measurements
self.dmm.TrigMultipointMeas()
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
print('\nmin meanHRADC stdHRADC')
print(
str(sampHRADC.min()) + ' ' + str(meanHRADC) + ' ' +
str(stdHRADC) + '\n')
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
#T_end = np.array(DMM.ReadMeasurementPoints()).mean()
old_T_end = T_end
T_end = np.array(self.dmm.GetMultipointMeas()).mean()
# Repeat if more than 50% HRADC samples == 0
old_sumNonFSCodes = sumNonFSCodes
sumNonFSCodes = sum(sampHRADC < 0x3FFFF)
print('DMM T[end] "non-FS codes"')
print(str(T_end) + ' ' + str(sumNonFSCodes) + '\n')
if (sumNonFSCodes >= len(sampHRADC) / 2):
break
T_end = (old_T_end * old_sumNonFSCodes + T_end * sumNonFSCodes) / (
old_sumNonFSCodes + sumNonFSCodes)
print('*** Vin T[end]: ' + str(T_end) + ' V ***')
print('*** Vin T[1]: ' + str(T_1) + ' V ***\n')
log.vin_gain = (T_end - T_1) / (20 - self.vin_lsb)
log.vin_offset = T_1 - log.vin_gain * (-10 + self.vin_lsb / 2)
print(' Vin Gain: ' + str(log.vin_gain))
print(' Vin Offset: ' + str(log.vin_offset))
print('\nTempo de execucao: ' +
str((time.perf_counter() - t0) / 60) + ' min\n\n')
self.source.SetOutput(0, 'V')
self.source.DisableOutput()
self.drs.DisableHRADCSampling()
time.sleep(1)
print('*********************************')
print('****** Medindo referencias ******')
print('*********************************\n')
print(' Medindo +Vref...\n')
self.update_gui.emit(' Medindo +Vref...')
self.drs.ConfigHRADC(slot, 100000, 'Vref_bipolar_p', 0, 0)
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(0.5)
self.drs.EnableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableHRADCSampling()
time.sleep(0.5)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print('\n************** FALHA SAMPLES BUFFER **************\n')
self.source.DisableOutput()
self.DisableHRADCSampling()
return
log.vref_p = self._convertVinSample(sampHRADC.mean())
print('\n+Vref = ' + str(log.vref_p) + ' V\n')
print(' Medindo -Vref...\n')
self.update_gui.emit(' Medindo -Vref...')
self.drs.ConfigHRADC(slot, 100000, 'Vref_bipolar_n', 0, 0)
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(0.5)
self.drs.EnableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableHRADCSampling()
time.sleep(0.5)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print('\n************** FALHA SAMPLES BUFFER **************\n')
self.source.DisableOutput()
self.DisableHRADCSampling()
return
log.vref_n = self._convertVinSample(sampHRADC.mean())
print('\n-Vref = ' + str(log.vref_n) + ' V\n')
print(' Medindo GND...\n')
self.update_gui.emit(' Medindo GND...')
self.drs.ConfigHRADC(slot, 100000, 'GND', 0, 0)
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(0.5)
self.drs.EnableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableHRADCSampling()
time.sleep(0.5)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print('\n************** FALHA SAMPLES BUFFER **************\n')
self.source.DisableOutput()
self.DisableHRADCSampling()
return
log.gnd = self._convertVinSample(sampHRADC.mean())
print('\nGND = ' + str(log.gnd) + ' V\n\n')
print('**********************************')
print('****** Medindo temperaturas ******')
print('**********************************\n')
self.update_gui.emit(' Medindo temperaturas...')
self.drs.ConfigHRADC(slot, 100000, 'Temp', 0, 0)
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(0.5)
self.drs.EnableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableSamplesBuffer()
time.sleep(0.5)
self.drs.DisableHRADCSampling()
time.sleep(0.5)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_blocks(0))
if np.array_equal(sampHRADC, emptyBuff):
print('\n************** FALHA SAMPLES BUFFER **************\n')
self.source.DisableOutput()
self.DisableHRADCSampling()
return
log.temperature_hradc = -100 * self._convertVinSample(
sampHRADC.mean())
log.temperature_power_supply = self.source.GetTemperature()
log.temperature_dmm = self.dmm.GetTemperature()
print('HRADC Temp = ' + str(log.temperature_hradc) + ' oC')
print('Source Temp = ' + str(log.temperature_power_supply) + ' oC')
print('DMM Temp = ' + str(log.temperature_dmm) + ' oC\n')
if variant == 'HRADC-FBP':
print('*****************************************')
print('****** Iniciando calibracao Iin... ******')
print('*****************************************\n')
self.dmm.SetMeasurementType('DCI', 0.05)
self.source.SetOutput(0, 'I')
self.drs.SelectTestSource('Iin_bipolar')
time.sleep(0.5)
self.drs.ConfigHRADC(slot, 100000, 'Iin_bipolar', 0, 0)
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(0.5)
################################################
print(' *** Configurando Iin -FS ... ***\n')
################################################
self.update_gui.emit(' Encontrando fundo de escala -Iin...')
sourceOut = -0.0495
self.source.EnableOutput()
while True:
sourceOut = self._saturate(sourceOut, -self.iin_max,
self.iin_max)
# if any HRADC samples != 0, set source lower
print('sourceOut = ' + str(sourceOut) + ' A\n')
self.source.SetOutput(sourceOut, 'I')
time.sleep(self.settlingTime)
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_blocks(0))
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
deltaFS = meanHRADC * self.iin_lsb
inc = deltaFS if deltaFS > self.iin_lsb else self.iin_lsb
print('\nmax meanHRADC stdHRADC inc')
print(
str(sampHRADC.max()) + ' ' + str(meanHRADC) +
' ' + str(stdHRADC) + ' ' + str(inc) + '\n')
#if((sampHRADC == 0).all()):
if (sum(sampHRADC == 0) >= len(sampHRADC) * 0.9):
break
sourceOut -= inc
iin_negFS = np.array(self.dmm.ReadMeasurementPoints()).mean()
print('Iin -FS: ' + str(iin_negFS) + ' A\n')
#################################################
print('\n *** Procurando Iin T[1] ... ***\n')
#################################################
self.update_gui.emit(' Procurando Iin T[1]...')
sumNonFSCodes = 0
T_1 = iin_negFS
while True:
# Increment source output
sourceOut += self.iin_step
sourceOut = self._saturate(sourceOut, -self.iin_max,
self.iin_max)
print('sourceOut = ' + str(sourceOut) + ' A\n')
self.source.SetOutput(sourceOut, 'I')
time.sleep(self.settlingTime)
# Start measurements
self.dmm.TrigMultipointMeas()
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(
self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
print('\nmax meanHRADC stdHRADC')
print(
str(sampHRADC.max()) + ' ' + str(meanHRADC) +
' ' + str(stdHRADC) + '\n')
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
#T_1 = np.array(DMM.ReadMeasurementPoints()).mean()
old_T_1 = T_1
T_1 = np.array(self.dmm.GetMultipointMeas()).mean()
# Repeat if more than 50% HRADC samples == 0
old_sumNonFSCodes = sumNonFSCodes
sumNonFSCodes = sum(sampHRADC > 0)
print('DMM T[1] "non-FS codes"')
print(str(T_1) + ' ' + str(sumNonFSCodes) + '\n')
if (sumNonFSCodes >= len(sampHRADC) / 2):
break
T_1 = (old_T_1 * old_sumNonFSCodes + T_1 * sumNonFSCodes) / (
old_sumNonFSCodes + sumNonFSCodes)
print('*** Iin T[1]: ' + str(T_1) + ' A ***\n\n')
################################################
print(' *** Configurando Iin +FS ... ***\n')
################################################
self.update_gui.emit(' Encontrando fundo de escala +Iin...')
sourceOut = 0.0495
while True:
sourceOut = self._saturate(sourceOut, -self.iin_max,
self.iin_max)
# if any HRADC samples != 0, set source lower
print('sourceOut = ' + str(sourceOut) + ' A\n')
self.source.SetOutput(sourceOut, 'I')
time.sleep(self.settlingTime)
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(self.drs.Recv_samplesBuffer_blocks(0))
print(sampHRADC)
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
deltaFS = 0.1 - meanHRADC * self.iin_lsb
inc = deltaFS if deltaFS > self.iin_lsb else self.iin_lsb
print('\nmin meanHRADC stdHRADC inc')
print(
str(sampHRADC.min()) + ' ' + str(meanHRADC) +
' ' + str(stdHRADC) + ' ' + str(inc) + '\n')
#if((sampHRADC == 0x3FFFF).all()):
if (sum(sampHRADC == 0x3FFFF) >= len(sampHRADC) * 0.9):
break
sourceOut += inc
iin_posFS = np.array(self.dmm.ReadMeasurementPoints()).mean()
print('Iin +FS: ' + str(iin_posFS) + ' A\n')
###################################################
print('\n *** Procurando Iin T[end] ... ***\n')
###################################################
self.update_gui.emit(' Procurando Iin T[end]...')
sumNonFSCodes = 0
T_end = iin_posFS
while True:
# Decrement source output
sourceOut -= self.iin_step
sourceOut = self._saturate(sourceOut, -self.iin_max,
self.iin_max)
print('sourceOut = ' + str(sourceOut) + ' A\n')
self.source.SetOutput(sourceOut, 'I')
time.sleep(self.settlingTime)
# Start measurements
self.dmm.TrigMultipointMeas()
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(1)
sampHRADC = np.array(
self.drs.Recv_samplesBuffer_allblocks())
print(sampHRADC)
meanHRADC = sampHRADC.mean()
stdHRADC = sampHRADC.std()
print('\nmin meanHRADC stdHRADC')
print(
str(sampHRADC.min()) + ' ' + str(meanHRADC) +
' ' + str(stdHRADC) + '\n')
if np.array_equal(sampHRADC, emptyBuff):
print(
'\n************** FALHA SAMPLES BUFFER **************\n'
)
self.source.DisableOutput()
self.DisableHRADCSampling()
return
#T_end = np.array(DMM.ReadMeasurementPoints()).mean()
old_T_end = T_end
T_end = np.array(self.dmm.GetMultipointMeas()).mean()
# Repeat if more than 50% HRADC samples == 0
old_sumNonFSCodes = sumNonFSCodes
sumNonFSCodes = sum(sampHRADC < 0x3FFFF)
print('DMM T[end] "non-FS codes"')
print(str(T_end) + ' ' + str(sumNonFSCodes) + '\n')
if (sumNonFSCodes >= len(sampHRADC) / 2):
break
T_end = (old_T_end * old_sumNonFSCodes + T_end *
sumNonFSCodes) / (old_sumNonFSCodes + sumNonFSCodes)
print('*** Iin T[end]: ' + str(T_end) + ' A ***')
print('*** Iin T[1]: ' + str(T_1) + ' A ***\n')
log.iin_gain = (T_end - T_1) / (0.1 - self.iin_lsb)
log.iin_offset = T_1 - log.iin_gain * (-0.05 +
self.iin_lsb / 2)
else:
log.iin_gain = 0
log.iin_offset = 0
self.source.SetOutput(0, 'V')
self.source.DisableOutput()
self.drs.DisableHRADCSampling()
time.sleep(1)
print('************************************')
print('****** Salvando resultados... ******')
print('************************************\n')
print('Configurando placa em modo UFM...')
self.update_gui.emit(' Configurando placa em modo UFM...')
#slot = slot - 1
self.drs.ConfigHRADCOpMode(slot, 1)
time.sleep(0.5)
print('\Salvando resultados da calibracao na placa HRADC...')
self.update_gui.emit(
' Salvando resultados da calibracao na placa HRADC...')
data = time.localtime()
# Day
ufmdata_16 = self._convertToUint16List(data.tm_mday, 'Uint16')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['calibdate'],
ufmdata_16[i])
time.sleep(0.1)
# Month
ufmdata_16 = self._convertToUint16List(data.tm_mon, 'Uint16')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,
i + self.ufmOffset['calibdate'] + 1,
ufmdata_16[i])
time.sleep(0.1)
# Year
ufmdata_16 = self._convertToUint16List(data.tm_year, 'Uint16')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,
i + self.ufmOffset['calibdate'] + 2,
ufmdata_16[i])
time.sleep(0.1)
# Hour
ufmdata_16 = self._convertToUint16List(data.tm_hour, 'Uint16')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,
i + self.ufmOffset['calibdate'] + 3,
ufmdata_16[i])
time.sleep(0.1)
# Minutes
ufmdata_16 = self._convertToUint16List(data.tm_min, 'Uint16')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,
i + self.ufmOffset['calibdate'] + 4,
ufmdata_16[i])
time.sleep(0.1)
# HRADC Temperature
ufmdata_16 = self._convertToUint16List(log.temperature_hradc,
'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['calibtemp'],
ufmdata_16[i])
time.sleep(0.1)
# Vin gain
ufmdata_16 = self._convertToUint16List(log.vin_gain, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['vin_gain'],
ufmdata_16[i])
time.sleep(0.1)
# Vin offset
ufmdata_16 = self._convertToUint16List(log.vin_offset, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['vin_offset'],
ufmdata_16[i])
time.sleep(0.1)
# Iin gain
ufmdata_16 = self._convertToUint16List(log.iin_gain, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['iin_gain'],
ufmdata_16[i])
time.sleep(0.1)
# Iin offset
ufmdata_16 = self._convertToUint16List(log.iin_offset, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['iin_offset'],
ufmdata_16[i])
time.sleep(0.1)
# +Vref
ufmdata_16 = self._convertToUint16List(log.vref_p, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['vref_p'],
ufmdata_16[i])
time.sleep(0.1)
# -Vref
ufmdata_16 = self._convertToUint16List(log.vref_n, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['vref_n'],
ufmdata_16[i])
time.sleep(0.1)
# GND
ufmdata_16 = self._convertToUint16List(log.gnd, 'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot, i + self.ufmOffset['gnd'],
ufmdata_16[i])
time.sleep(0.1)
self.drs.ReadHRADC_BoardData(slot)
time.sleep(1)
print('Configurando placa em modo Sampling...')
self.update_gui.emit(' Configurando placa em modo Sampling...')
self.drs.ConfigHRADCOpMode(slot, 0)
time.sleep(0.5)
print('Enviando dados ao servidor...\n')
self.update_gui.emit(' Enviando dados ao servidor...')
log_res = self._send_to_server(log)
print('\n\n*****************************************')
print('****** RESULTADOS ******')
print('*****************************************\n')
print(' Vin Gain: ' + str(log.vin_gain))
print(' Vin Offset: ' + str(log.vin_offset))
print(' Iin Gain: ' + str(log.iin_gain))
print(' Iin Offset: ' + str(log.iin_offset))
print(' +Vref = ' + str(log.vref_p) + ' V')
print(' -Vref = ' + str(log.vref_n) + ' V')
print(' GND = ' + str(log.gnd) + ' V\n')
print(' HRADC Temp = ' + str(log.temperature_hradc) + ' oC')
print(' Source Temp = ' + str(log.temperature_power_supply) +
' oC')
print(' DMM Temp = ' + str(log.temperature_dmm) + ' oC\n')
deltaT = time.perf_counter() - t0
print(' Tempo de execucao: ' + str(deltaT / 60) + ' min\n\n')
self.update_gui.emit('\n Resultados:\n')
self.update_gui.emit(' Vin Gain: ' + str(log.vin_gain))
self.update_gui.emit(' Vin Offset: ' + str(log.vin_offset))
self.update_gui.emit('')
self.update_gui.emit(' Iin Gain: ' + str(log.iin_gain))
self.update_gui.emit(' Iin Offset: ' + str(log.iin_offset))
self.update_gui.emit('')
self.update_gui.emit(' +Vref = ' + str(log.vref_p) + ' V')
self.update_gui.emit(' -Vref = ' + str(log.vref_n) + ' V')
self.update_gui.emit(' GND = ' + str(log.gnd) + ' V')
self.update_gui.emit('')
self.update_gui.emit(' HRADC Temp = ' +
str(log.temperature_hradc) + ' oC')
self.update_gui.emit(' Source Temp = ' +
str(log.temperature_power_supply) + ' oC')
self.update_gui.emit(' DMM Temp = ' + str(log.temperature_dmm) +
' oC')
self.update_gui.emit('')
self.update_gui.emit(' Tempo de execucao: ' + str(deltaT / 60) +
' min')
self.update_gui.emit('*** CALIBRACAO DO SLOT #' + str(slot) +
' ENCERRADA! ***\n\n')
self.update_gui.emit('Fim do procedimento de calibração\n\n')
self.calib_complete.emit(log_res)
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
print(client_data)
client_method = item.method
client_response = client.do_request(client_method, client_data)
server_status = self._parse_response(client_response)
print(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def _convertToUint16List(self, val, format):
val_16 = []
val_b = struct.pack(self.bytesFormat[format], val)
print(val_b)
for i in range(0, len(val_b), 2):
val_16.append(struct.unpack('H', val_b[i:i + 2])[0])
print(val_16)
return val_16
def _configBoardsToTest(self, board, inputType):
for slot in range(self.nHRADC):
if slot == board['slot']:
self.drs.ConfigHRADC(slot, 100000, inputType, 0, 0)
else:
self.drs.ConfigHRADC(slot, 100000, 'GND', 0, 0)
def _saturate(self, val, min, max):
if val > max:
return max
elif val < min:
return min
return val
def _convertVinSample(self, sample):
val = (sample - 131072) * self.vin_lsb
return val
def _convertIinSample(self, sample):
val = (sample - 131072) * self.iin_lsb
return val
def run(self):
self._calib_sequence()
class FacDcdc(QThread):
update_gui = pyqtSignal(dict)
def __init__(self):
QThread.__init__(self)
self._drs = SerialDRS()
self._baudrate = '6000000'
self._is_active = False
self._screen_readings = {
'setpoint': 0.0,
'reference': 0.0,
'slowref_counter': 0,
'syncpulse_counter': 0,
'iload_1': 0.0,
'iload_2': 0.0,
'vload': 0.0,
'vcapbank': 0.0,
'induc_temp': 0.0,
'igbt_temp': 0.0,
'duty_cycle': 0,
'soft_intlk': 0,
'hard_intlk': 0,
'fwr_version': ''
}
self._hard_interlocks = [
'Falha nos drivers do módulo', 'Sub-tensão no DCLINK',
'Sobre-tensão no DCLINK', 'Sobre-tensão na carga',
'Sobre-corrente na carga'
]
self._soft_interlocks = [
'Falha leitura DCCT 2', 'Falha leitura DCCT 1',
'Alta diferença entre DCCTs', 'Falha DCCT 2', 'Falha DCCT 1',
'Sobre-temperatura nos indutores',
'Sobre-temperatura nos indutores'
]
@property
def is_active(self):
return self._is_active
def connect_serial(self, com_port):
res = False
if com_port is not None:
res = self._drs.Connect(com_port, self._baudrate)
self._is_active = True
return res
def disconnect_serial(self):
res = self._drs.Disconnect()
self._is_active = False
return res
def turn_on(self):
try:
self._drs.turn_on()
except:
pass
def turn_off(self):
try:
self._drs.turn_off()
except:
pass
def open_loop(self):
try:
self._drs.open_loop()
except:
pass
def close_loop(self):
try:
self._drs.close_loop()
except:
pass
def enable_siggen(self):
try:
self._drs.enable_siggen()
except:
pass
def disable_siggen(self):
try:
self._drs.disable_siggen()
except:
pass
def soft_intlk_reset(self):
pass
def hard_intlk_reset(self):
pass
def send_setpoint(self, value):
res = self._drs.set_slowref(value)
def check_interlocks(self):
res = True
intlk = self._drs.read_bsmp_variable(26, 'uint32_t')
if intlk is 0:
res = False
return res
def update_params(self):
try:
self._screen_readings['setpoint'] = round(
self._drs.read_bsmp_variable(1, 'float'), 3)
self._screen_readings['reference'] = round(
self._drs.read_bsmp_variable(2, 'float'), 3)
self._screen_readings[
'slowref_counter'] = self._drs.read_bsmp_variable(
4, 'uint32_t')
self._screen_readings[
'syncpulse_counter'] = self._drs.read_bsmp_variable(
5, 'uint32_t')
self._screen_readings['soft_intlk'] = self._drs.read_bsmp_variable(
25, 'uint32_t')
self._screen_readings['hard_intlk'] = self._drs.read_bsmp_variable(
26, 'uint32_t')
self._screen_readings['iload_1'] = round(
self._drs.read_bsmp_variable(27, 'float'), 3)
self._screen_readings['iload_2'] = round(
self._drs.read_bsmp_variable(28, 'float'), 3)
self._screen_readings['vload'] = round(
self._drs.read_bsmp_variable(29, 'float'), 3)
self._screen_readings['vcapbank'] = round(
self._drs.read_bsmp_variable(30, 'float'), 3)
self._screen_readings['induc_temp'] = round(
self._drs.read_bsmp_variable(31, 'float'), 3)
self._screen_readings['igbt_temp'] = round(
self._drs.read_bsmp_variable(32, 'float'), 3)
self._screen_readings['duty_cycle'] = round(
self._drs.read_bsmp_variable(33, 'float'), 3)
self._screen_readings[
'fwr_version'] = self._drs.read_udc_arm_version()
self.update_gui.emit(self._screen_readings)
except:
pass
def get_hard_intlk_list(self, bitmask):
bitfield = self._get_bitfield(bitmask)
mask = bitfield[len(bitfield) - len(self._hard_interlocks):]
filtered = itertools.compress(self._hard_interlocks, mask)
return list(filtered)
def get_soft_intlk_list(self, bitmask):
bitfield = self._get_bitfield(bitmask)
mask = bitfield[len(bitfield) - len(self._soft_interlocks):]
filtered = itertools.compress(self._soft_interlocks, mask)
return list(filtered)
def _get_bitfield(self, bitmask):
bitfield = [int(bit)
for bit in bin(bitmask)[2:]] # [2:] to remove '0b'
return bitfield
class BurnInTest(QThread):
test_complete = pyqtSignal(bool)
update_gui = pyqtSignal(str)
current_state = pyqtSignal(str)
connection_lost = pyqtSignal()
test = {'Normal': 1, 'Burn-In': 2}
def __init__(self):
QThread.__init__(self)
self._comport = None
self._baudarate = None
self._serial_number = []
self._ps_address = 1
self.FBP = SerialDRS()
@property
def serial_number(self):
return self._serial_number
@serial_number.setter
def serial_number(self, value):
self._serial_number = value
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudarate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
return self.FBP.Connect(self._comport, self._baudrate)
def test_communication(self, ps_address):
result = False
self.FBP.SetSlaveAdd(ps_address)
time.sleep(1)
try:
self.FBP.Config_nHRADC(4) # alterar para 4
# self.FBP.Write_sigGen_Aux(1) # alterar para 4
time.sleep(5)
test_package = self.FBP.Read_ps_Model()
time.sleep(1)
if (test_package[0] == 0) and \
(test_package[1] == 17) and \
(test_package[2] == 512) and \
(test_package[3] == 14) and \
(test_package[4] == 223):
result = True
else:
result = False
except:
result = False
print('Falha na comunicação')
return result
def find_address(self):
test_address = 1
while (self.test_communication(test_address) == False):
print(test_address)
test_address = test_address + 1
print('o endereço da fonte é: ' + str(test_address))
return test_address
def set_address(self):
write_gui = []
ps_address = self.find_address()
time.sleep(0.5)
self.FBP.SetSlaveAdd(ps_address)
time.sleep(1)
if self.test_communication(ps_address):
self.FBP.SetRSAddress(self._ps_address)
time.sleep(1)
if self.test_communication(self._ps_address):
write_gui.append(str(self._ps_address))
write_gui.append('endereço ' + str(self._ps_address) +
' gravado com sucesso')
print('endereço ' + str(self._ps_address) +
' gravado com sucesso')
self._ps_address = self._ps_address + 1
else:
write_gui.append('erro na gravação do endereço')
print('erro na gravação do endereço')
return write_gui
def _test_sequence(self):
self.current_state.emit('Desligado')
print('##################################################')
print('##################################################')
print(self._serial_number)
print('##################################################')
print('##################################################')
test_current = [7,
-7] # alterar para 10 e -10, adequação à carga da WEG
for set_current in test_current:
for ps_turnOn in self._serial_number:
if self.test_communication(
self._serial_number.index(ps_turnOn) + 1):
self.FBP.SetSlaveAdd(
self._serial_number.index(ps_turnOn) + 1)
time.sleep(1)
self.FBP.Config_nHRADC(4) # alterar para 4
time.sleep(5)
self.update_gui.emit(
'Realizando auto-tuning dos módulos de potência...')
self.update_gui.emit(
' auto-tuning módulo 1...'
)
duty_mod1 = self._auto_tuning(set_current, 1)
self.update_gui.emit(
' auto-tuning módulo 2...'
)
duty_mod2 = self._auto_tuning(set_current, 2)
self.update_gui.emit(
' auto-tuning módulo 3...'
)
duty_mod3 = self._auto_tuning(set_current, 3)
self.update_gui.emit(
' auto-tuning módulo 4...'
)
duty_mod4 = self._auto_tuning(set_current, 4)
self.update_gui.emit(
'Ligando fontes e setando correntes para ' +
str(set_current) + ' A')
time.sleep(1)
self.FBP.ResetInterlocks()
time.sleep(0.5)
self.FBP.TurnOn(0b1111) # alterar para 0b1111
time.sleep(1)
self.FBP.SetISlowRefx4(duty_mod1, duty_mod2, duty_mod3,
duty_mod4)
time.sleep(0.5)
self.current_state.emit(str(set_current) + 'A')
if (abs(self.FBP.Read_iMod1()) > 12) or \
(abs(self.FBP.Read_iMod2()) > 12) or \
(abs(self.FBP.Read_iMod3()) > 12) or \
(abs(self.FBP.Read_iMod4()) > 12) or \
(round(self.FBP.Read_iMod1()) == 0) or \
(round(self.FBP.Read_iMod2()) == 0) or \
(round(self.FBP.Read_iMod3()) == 0) or \
(round(self.FBP.Read_iMod4()) == 0):
self.update_gui.emit(
'ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(10)
raise NameError('ERRO! REINICIE O TESTE E AS FONTES')
else:
self.update_gui.emit('Endereço não encontrado')
print('Endereço não encontrado')
for a in range(72): # alterar para 72
for ps_under_test in self._serial_number:
result = True
ps = PowerSupply()
ps.serial_number = ps_under_test
res = self._send_to_server(ps)
self.update_gui.emit('Medição da fonte de número serial '\
+ str(ps_under_test))
self.update_gui.emit('')
if self.test_communication(
self._serial_number.index(ps_under_test) + 1):
if res:
#TODO: Sequencia de Testes
for i in range(4): # Alterar para 4
self.update_gui.emit(
'Iniciando medições do módulo ' +
str(i + 1))
self.update_gui.emit('')
test = True
MeasureList = self._save_AllMeasurements\
(self._serial_number.index(ps_under_test) + 1, i)
'''########## Verificando resultado da corrente de saída ##########'''
'''################################################################'''
self.update_gui.emit(
' Corrente de saída: ' +
str(MeasureList[0]))
if (set_current - 1.5) <= set_current <= (
set_current + 1.5):
self.update_gui.emit(
' Leitura da corrente de saída OK'
)
if test:
test = True
else:
test = False
self.update_gui.emit(
' Leitura da corrente de saída NOK'
)
self.update_gui.emit('')
'''################################################################'''
'''########### Verificando resultado da tensão de saída ###########'''
'''################################################################'''
self.update_gui.emit(
' Tensão de saída: ' +
str(MeasureList[1]))
if set_current > 0:
if 1 <= round(MeasureList[1]) <= 14:
self.update_gui.emit(
' Leitura da tensão de saída OK'
)
if test:
test = True
else:
test = False
self.update_gui.emit(
' Leitura da tensão de saída NOK'
)
elif set_current < 0:
if -14 <= round(MeasureList[1]) <= -1:
self.update_gui.emit(
' Leitura da tensão de saída OK'
)
if test:
test = True
else:
test = False
self.update_gui.emit(
' Leitura da tensão de saída NOK'
)
self.update_gui.emit('')
'''################################################################'''
'''########## Verificando resultado da tensão de entrada ##########'''
'''################################################################'''
self.update_gui.emit(
' Tensão de entrada: ' +
str(MeasureList[2]))
if 6 <= round(MeasureList[2]) <= 16:
self.update_gui.emit(
' Leitura da tensão de entrada OK'
)
if test:
test = True
else:
test = False
self.update_gui.emit(
' Leitura da tensão de entrada NOK'
)
self.update_gui.emit('')
'''################################################################'''
'''############# Verificando resultado da temperatura #############'''
'''################################################################'''
self.update_gui.emit(
' Temperatura: ' +
str(MeasureList[3]))
if (MeasureList[3] < 110) or (MeasureList[3]
== 127):
self.update_gui.emit(
' Leitura da temperatura OK')
if test:
test = True
else:
test = False
self.update_gui.emit(
' Leitura da temperatura NOK')
self.update_gui.emit('')
'''################################################################'''
if set_current == test_current[0]:
log = PowerSupplyLog()
log.test_type = self.test['Burn-In']
log.id_canal_power_supply = i + 1
if test:
log.test_result = 'Aprovado'
self.update_gui.emit(
' MÓDULO ' + str(i + 1) +
' OK')
self.update_gui.emit('')
else:
log.test_result = 'Reprovado'
self.update_gui.emit(
' MÓDULO ' + str(i + 1) +
' NOK')
self.update_gui.emit('')
log.serial_number_power_supply = ps_under_test
log.iout0 = MeasureList[0]
log.vout0 = MeasureList[1]
log.vdclink0 = MeasureList[2]
log.temperatura0 = MeasureList[3]
log.details = ''
for _softinterlock in self._read_SoftInterlock(
self.FBP.Read_ps_SoftInterlocks()):
log.details = log.details + _softinterlock + '\t'
for _hardinterlock in self._read_HardInterlock(
self.FBP.Read_ps_HardInterlocks()):
log.details = log.details + _hardinterlock + '\t'
result = self._send_to_server(log)
elif set_current == test_current[1]:
log = PowerSupplyLog()
log.test_type = self.test['Burn-In']
log.id_canal_power_supply = i + 1
if test:
log.test_result = 'Aprovado'
else:
log.test_result = 'Reprovado'
log.serial_number_power_supply = ps_under_test
log.iout1 = MeasureList[0]
log.vout1 = MeasureList[1]
log.vdclink1 = MeasureList[2]
log.temperatura1 = MeasureList[3]
log.details = ''
for _softinterlock in self._read_SoftInterlock(
self.FBP.Read_ps_SoftInterlocks()):
log.details = log.details + _softinterlock + '\t'
for _hardinterlock in self._read_HardInterlock(
self.FBP.Read_ps_HardInterlocks()):
log.details = log.details + _hardinterlock + '\t'
result = self._send_to_server(log)
self.update_gui.emit(
' Interlocks Ativos:')
for softinterlock in self._read_SoftInterlock(
self.FBP.Read_ps_SoftInterlocks()):
self.update_gui.emit(' ' +
softinterlock)
for hardinterlock in self._read_HardInterlock(
self.FBP.Read_ps_HardInterlocks()):
self.update_gui.emit(' ' +
hardinterlock)
self.update_gui.emit('')
self.update_gui.emit(
'*********************************************************'
)
else:
self.update_gui.emit('Endereço não encontrado')
print('Endereço não encontrado')
if test:
if result:
result = True
else:
result = False
time.sleep(600) #Alterar para 600
self.test_complete.emit(result)
self.update_gui.emit('FIM DO TESTE!')
for ps_turnOff in self._serial_number:
self.FBP.SetSlaveAdd(self._serial_number.index(ps_turnOff) + 1)
time.sleep(1)
self.FBP.TurnOff(15)
time.sleep(1)
def _save_AllMeasurements(self, address, module):
self.FBP.SetSlaveAdd(address)
time.sleep(1)
Measurement = []
if module == 0:
Measurement.append(self.FBP.Read_iMod1())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vOutMod1())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vDCMod1())
time.sleep(0.1)
Measurement.append(self.FBP.Read_temp1())
time.sleep(0.1)
elif module == 1:
Measurement.append(self.FBP.Read_iMod2())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vOutMod2())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vDCMod2())
time.sleep(0.1)
Measurement.append(self.FBP.Read_temp2())
time.sleep(0.1)
elif module == 2:
Measurement.append(self.FBP.Read_iMod3())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vOutMod3())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vDCMod3())
time.sleep(0.1)
Measurement.append(self.FBP.Read_temp3())
time.sleep(0.1)
elif module == 3:
Measurement.append(self.FBP.Read_iMod4())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vOutMod4())
time.sleep(0.1)
Measurement.append(self.FBP.Read_vDCMod4())
time.sleep(0.1)
Measurement.append(self.FBP.Read_temp4())
time.sleep(0.1)
return Measurement
def _read_SoftInterlock(self, int_interlock):
SoftInterlockList = ['N/A', 'Sobre-tensao na carga 1', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensao na carga 2', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensao na carga 3', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensao na carga 4', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A']
op_bin = 1
ActiveSoftInterlocks = []
print('Soft Interlocks ativos:')
for i in range(len('{0:b}'.format(int_interlock))):
if (int_interlock & (op_bin << i)) == 2**i:
ActiveSoftInterlocks.append(SoftInterlockList[i])
print(SoftInterlockList[i])
print(
'-------------------------------------------------------------------'
)
return ActiveSoftInterlocks
def _read_HardInterlock(self, int_interlock):
HardInterlockList = ['Sobre-corrente na carga 1', 'N/A', \
'Sobre-tensao no DC-Link do modulo 1', \
'Sub-tensao no DC-Link do modulo 1', \
'Falha no rele de entrada do DC-Link do modulo 1', \
'Falha no fusivel de entrada do DC-Link do modulo 1', \
'Falha nos drivers do modulo 1', \
'Sobre-temperatura no modulo 1', \
'Sobre-corrente na carga 2', 'N/A', \
'Sobre-tensao no DC-Link do modulo 2', \
'Sub-tensao no DC-Link do modulo 2', \
'Falha no rele de entrada do DC-Link do modulo 2', \
'Falha no fusivel de entrada do DC-Link do modulo 2', \
'Falha nos drivers do modulo 2', \
'Sobre-temperatura no modulo 2', \
'Sobre-corrente na carga 3', 'N\A', \
'Sobre-tensao no DC-Link do modulo 3', \
'Sub-tensao no DC-Link do modulo 3', \
'Falha no rele de entrada no DC-Link do modulo 3', \
'Falha no fusivel de entrada do DC-Link do modulo 3', \
'Falha nos drivers do modulo 3', \
'Sobre-temperatura no modulo 3', \
'Sobre-corrente na carga 4', 'N/A', \
'Sobre-tensao no DC-Link do modulo 4', \
'Sub-tensao no DC-Link do modulo 4', \
'Falha no rele de entrada do DC-Link do modulo 4', \
'Falha no fusivel de entrada do DC-Link do modulo 4', \
'Falha nos drivers do modulo 4', \
'Sobre-temperatura no modulo 4']
op_bin = 1
ActiveHardInterlocks = []
print('Hard Interlocks ativos:')
for i in range(len('{0:b}'.format(int_interlock))):
if (int_interlock & (op_bin << i)) == 2**i:
ActiveHardInterlocks.append(HardInterlockList[i])
print(HardInterlockList[i])
print(
'-------------------------------------------------------------------'
)
return ActiveHardInterlocks
def _auto_tuning(self, current, module):
if current > 0:
duty = [20, 30]
elif current < 0:
duty = [-20, -30]
iout = []
vout = []
iref = []
print(
'\n####################### Auto tuning #######################\n')
if module == 1:
print('\nIniciando auto-tuning do modulo 1...')
self.FBP.TurnOn(0b0001)
time.sleep(1)
self.FBP.SetISlowRefx4(duty[0], 0, 0, 0)
time.sleep(5)
iout.append(self.FBP.Read_iMod1())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod1())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef1())
time.sleep(5)
self.FBP.SetISlowRefx4(duty[1], 0, 0, 0)
time.sleep(5)
iout.append(self.FBP.Read_iMod1())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod1())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef1())
time.sleep(1)
self.FBP.TurnOff(1)
time.sleep(5)
elif module == 2:
print('\nIniciando auto-tuning do modulo 2...')
self.FBP.TurnOn(0b0010)
time.sleep(1)
self.FBP.SetISlowRefx4(0, duty[0], 0, 0)
time.sleep(5)
iout.append(self.FBP.Read_iMod2())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod2())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef2())
time.sleep(5)
self.FBP.SetISlowRefx4(0, duty[1], 0, 0)
time.sleep(5)
iout.append(self.FBP.Read_iMod2())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod2())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef2())
time.sleep(1)
self.FBP.TurnOff(0b0010)
time.sleep(5)
elif module == 3:
print('\nIniciando auto-tuning do modulo 3...')
self.FBP.TurnOn(0b0100)
time.sleep(1)
self.FBP.SetISlowRefx4(0, 0, duty[0], 0)
time.sleep(5)
iout.append(self.FBP.Read_iMod3())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod3())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef3())
time.sleep(5)
self.FBP.SetISlowRefx4(0, 0, duty[1], 0)
time.sleep(5)
iout.append(self.FBP.Read_iMod3())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod3())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef3())
time.sleep(1)
self.FBP.TurnOff(0b0100)
time.sleep(5)
elif module == 4:
print('\nIniciando auto-tuning do modulo 4...')
self.FBP.TurnOn(0b1000)
time.sleep(1)
self.FBP.SetISlowRefx4(0, 0, 0, duty[0])
time.sleep(5)
iout.append(self.FBP.Read_iMod4())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod4())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef4())
time.sleep(5)
self.FBP.SetISlowRefx4(0, 0, 0, duty[1])
time.sleep(5)
iout.append(self.FBP.Read_iMod4())
time.sleep(0.1)
vout.append(self.FBP.Read_vOutMod4())
time.sleep(0.1)
iref.append(self.FBP.Read_iRef4())
time.sleep(1)
self.FBP.TurnOff(0b1000)
time.sleep(5)
print('iref:')
print(iref)
print('corrente de saída:')
print(iout)
print('tensão de saída:')
print(vout)
m = (iout[1] - iout[0]) / (duty[1] - duty[0])
print('coef. angular:')
print(m)
if m == 0:
self.update_gui.emit('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(10)
raise NameError('ERRO! REINICIE O TESTE E AS FONTES')
b = (-m) * duty[0] + iout[0]
set_duty = (current - b) / m
set_duty = round(set_duty, 2)
print('duty cicle:')
print(set_duty)
if abs(set_duty) > 95:
self.update_gui.emit('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(10)
raise NameError('ERRO! REINICIE O TESTE E AS FONTES')
return set_duty
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
client_method = item.method
client_response = client.do_request(client_method, client_data)
server_status = self._parse_response(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def run(self):
self._test_sequence()
from common.pydrs import SerialDRS
from datetime import datetime
import time
import visa
drs = SerialDRS()
now = datetime.now()
################################################################################
####################### LENDO ARQUIVO DE CONFIGURAÇÃO ##########################
################################################################################
_cfile = open('lintest_config.csv', 'r')
config = _cfile.read()
_cfile.close()
config = config.split(';')
for i in config:
config[config.index(i)] = config[config.index(i)].split('|')
for j in config:
if config[config.index(j)][0] == 'COMPort':
drs_port = config[config.index(j)][1]
drs_port = drs_port.replace('\n', '')
drs_port = drs_port.split(',')
if len(drs_port) == 1:
drs_port = drs_port[0]
elif config[config.index(j)][0] == 'InstAddr':
from common.pydrs import SerialDRS
from datetime import datetime
import time
drs = SerialDRS()
now = datetime.now()
drs_port = 'COM11'
drs_addr = 1
bastidor = '1041182348'
WarmUpTime = 3 * 3600
StepTime = 30
nbits = 18
idc_list = [10, 0, -10]
module_list = ['modulo 1', 'modulo 2', 'modulo 3', 'modulo 4']
################################################################################
def init_module(drs_port, drs_addr, module, idc):
print('Inicializando módulo...')
drs.Connect(drs_port)
time.sleep(1)
drs.SetSlaveAdd(drs_addr)
time.sleep(1)
drs.Config_nHRADC(4)
time.sleep(5)
if module == 'modulo 1':
drs.TurnOn(1)
class HRADCTest(QThread):
test_complete = pyqtSignal(list)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
device = {'HRADC':1, 'DM':2}
bytesFormat = {'Uint16': 'H', 'Uint32': 'L', 'Uint64': 'Q', 'float': 'f'}
ufmOffset = {'serial': 0, 'calibdate': 4, 'variant': 9, 'rburden': 10}
hradcVariant = {'HRADC-FBP': 0, 'HRADC-FAX': 1}
hradcInputTypes = ['GND', 'Vref_bipolar_p', 'Vref_bipolar_n', 'Temp',
'Vin_bipolar_p', 'Vin_bipolar_n', 'Iin_bipolar_p','Iin_bipolar_n']
def __init__(self):
QThread.__init__(self)
self._comport = None
self._baudrate = None
self._boardsinfo = []
self._nHRADC = None
self._led = None
self.drs = SerialDRS()
self.source = KrohnHite523_GPIB()
self.dmm = Keysight3458A_GPIB()
self.refVal = {'GND': 0,
'Vref_bipolar_p': 5,
'Vref_bipolar_n': -5,
'Temp': -0.35,
'Vin_bipolar_p': 10,
'Vin_bipolar_n': -10,
'Iin_bipolar_p': 0.05,
'Iin_bipolar_n': -0.05
}
self.refTol = {'GND': 0.02,
'Vref_bipolar_p': 0.02,
'Vref_bipolar_n': 0.02,
'Temp': 0.1,
'Vin_bipolar_p': 0.02,
'Vin_bipolar_n': 0.02,
'Iin_bipolar_p': 0.0003,
'Iin_bipolar_n': 0.0003}
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudrate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
@property
def serial_number(self):
return self._serial_number
@serial_number.setter
def serial_number(self, value):
self._serial_number = value
@property
def led(self):
return self._led
@led.setter
def led(self, value):
self._led = value
@property
def firmware_error(self):
return self._firmware_error
@firmware_error.setter
def firmware_error(self, value):
self._firmware_error = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
self.dmm.Connect('GPIB0::22::INSTR')
self.source.Connect('GPIB0::25::INSTR')
self.source.DisableOutput()
self.source.Reset()
self.source.LOFloatChassis('F')
self.source.OutputTermination(0)
self.source.SetVoltageLimit(2)
self.source.SetOutput(0,'V')
self.dmm.InitDefault()
self.dmm.SetMeasurementType('DCV',10)
self.dmm.SetMultipointMeas(3)
return self.drs.Connect(self._comport, self._baudrate)
def test_communication(self,slot):
try:
test_package = self.drs.Read_ps_Model()
print(test_package)
if (test_package[0] == 0) and (test_package[1] == 17) and (test_package[2] == 512) and (test_package[3] == 10) and (test_package[4] == 227):
print('Comunicando com HRADC...')
self.drs.Config_nHRADC(slot)
time.sleep(1)
print('Resetando HRADC...')
self.drs.ResetHRADCBoards(1)
time.sleep(1)
self.drs.ResetHRADCBoards(0)
time.sleep(1)
print('Configurando HRADC...\n')
self.drs.ConfigHRADC(slot-1,100000,'GND',0,0)
time.sleep(0.1)
print('Habilita SamplesBuffer...\n')
self.drs.EnableSamplesBuffer()
time.sleep(0.1)
print('Habilita Sampling...\n')
self.drs.EnableHRADCSampling()
time.sleep(1)
print('Desabilita SamplesBuffer...\n')
self.drs.DisableSamplesBuffer()
time.sleep(0.1)
print('Desabilita Sampling...\n')
self.drs.DisableHRADCSampling()
time.sleep(0.1)
print('Le SamplesBuffer...\n')
buff = np.array(self.drs.Recv_samplesBuffer_blocks(0))
print(buff)
hradcMean = buff.mean()
print(hradcMean)
if abs(hradcMean) < self.refTol['GND']:
print('TRUE')
return True
print('FALSE')
return False
except:
print('EXCEPT')
self.drs.DisableHRADCSampling()
return False
def _test_sequence(self):
print('\n ### Valendo! ###\n')
self.nHRADC = max([board['slot'] for board in self._boardsinfo])
t = ' placas' if self.nHRADC > 1 else ' placa'
t2 = 'Inicializando teste de ' + str(self.nHRADC) + t + ' HRADC...'
print(t2 + '\n')
self.update_gui.emit(t2)
print(self._boardsinfo)
print('Configurando nHRADC...\n')
self.update_gui.emit('Configurando nHRADC...')
self.drs.Config_nHRADC(self.nHRADC)
time.sleep(1)
print('Resetando HRADC...\n')
self.update_gui.emit('Resetando nHRADC...')
self.drs.ResetHRADCBoards(1)
time.sleep(1)
self.drs.ResetHRADCBoards(0)
log_res = []
print('Començando a ler boardsinfo...\n')
self.update_gui.emit('Començando a ler boardsinfo...')
for board in self._boardsinfo:
print('\n******************************************')
print('*************** Slot ' + str(board['slot']) + ' ***************')
print('******************************************\n\n')
print(board)
self.update_gui.emit('SLOT #' + str(board['slot']) + ' ( S/N: ' + str(board['serial']) + ' / ' + str(board['variant']) + ')')
hradc = HRADC()
ufmdata_16 = []
emptyBuff = np.array([])
hradc.serial_number = board['serial']
hradc.variant = board['variant']
hradc.burden_amplifier = "INA141"
if hradc.variant == 'HRADC-FBP':
hradc.burden_res = 20.0
hradc.cut_frequency = 48228.7
hradc.filter_order = 1
print('\nEnviando ao servidor dados desta placa...\n')
self.update_gui.emit(' Enviando ao servidor dados desta placa...')
res = self._send_to_server(hradc)
print('\nInicializando equipamentos...\n')
self.update_gui.emit(' Inicializando equipamentos...')
self.source.DisableOutput()
self.source.Reset()
self.source.LOFloatChassis('F')
self.source.OutputTermination(0)
self.source.SetVoltageLimit(2)
self.source.SetOutput(-10,'V')
self.dmm.InitDefault()
self.dmm.SetMeasurementType('DCV',10)
self.dmm.SetMultipointMeas(3)
if res:
print(res)
print('\n')
log_hradc = HRADCLog()
log_hradc.serial_number_hradc = board['serial']
log_hradc.device = self.device['HRADC']
log_hradc.test_result = "Aprovado"
log_hradc.details = board['pre_tests']
log_hradc_list = []
log_dm = HRADCLog()
log_dm.serial_number_hradc = board['serial']
log_dm.device = self.device['DM']
log_dm.test_result = "Aprovado"
log_dm_list = []
if board['slot'] > 0:
print('Configurando placa em UFM mode...')
self.update_gui.emit(' Configurando placa em UFM mode...')
#slot = slot - 1
slot = board['slot'] - 1
self.drs.ConfigHRADCOpMode(slot,1)
time.sleep(0.5)
print('\nEnviando serial number...')
self.update_gui.emit(' Enviando serial number...')
# Send serial number
ufmdata_16 = self._convertToUint16List(board['serial'],'Uint64')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,i+self.ufmOffset['serial'],ufmdata_16[i])
time.sleep(0.1)
print('\nEnviando variante...')
self.update_gui.emit(' Enviando variante...')
# Send variant
ufmdata_16 = self._convertToUint16List(self.hradcVariant[board['variant']],'Uint16')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,i+self.ufmOffset['variant'],ufmdata_16[i])
time.sleep(0.1)
print('\nEnviando rburden...')
self.update_gui.emit(' Enviando Rburden...')
# Send Rburden
ufmdata_16 = self._convertToUint16List(hradc.burden_res,'float')
for i in range(len(ufmdata_16)):
self.drs.WriteHRADC_UFM(slot,i+self.ufmOffset['rburden'],ufmdata_16[i])
time.sleep(0.1)
'''
print('Lendo byte')
time.sleep(0.5)
self.drs.ReadHRADC_UFM(slot,0)
'''
print(' Colocando a placa em Sampling mode...')
self.update_gui.emit(' Colocando a placa em Sampling mode...')
self.drs.ConfigHRADCOpMode(slot,0)
time.sleep(0.5)
self._configBoardsToTest(board,'GND')
time.sleep(0.5)
self.drs.SelectHRADCBoard(slot)
time.sleep(0.1)
for signalType in self.hradcInputTypes:
unit = ' V'
if(signalType == 'Vin_bipolar_p')|(signalType == 'Vin_bipolar_n'):
inputType = 'Vin_bipolar'
elif(signalType == 'Iin_bipolar_p')|(signalType == 'Iin_bipolar_n'):
inputType = 'Iin_bipolar'
unit = ' A'
else:
inputType = signalType
if not (hradc.variant == 'HRADC-FAX' and inputType == 'Iin_bipolar'):
print('\n - ' + signalType + ' -')
self.update_gui.emit(' - ' + signalType + ' -')
self.drs.ConfigHRADC(slot,100000,inputType,0,0)
time.sleep(0.1)
self.drs.SelectTestSource(inputType)
time.sleep(0.1)
if signalType == 'Vin_bipolar_p':
self.source.SetOutput(10,'V')
self.source.EnableOutput()
elif signalType == 'Vin_bipolar_n':
self.source.SetOutput(-10,'V')
self.source.EnableOutput()
elif signalType == 'Iin_bipolar_p':
self.dmm.SetMeasurementType('DCI',0.05)
self.source.SetOutput(0.05,'I')
self.source.EnableOutput()
elif signalType == 'Iin_bipolar_n':
self.dmm.SetMeasurementType('DCI',0.05)
self.source.SetOutput(-0.05,'I')
self.source.EnableOutput()
else:
self.source.DisableOutput()
self.source.SetOutput(0,'V')
self.drs.EnableSamplesBuffer()
time.sleep(1)
self.drs.EnableHRADCSampling()
time.sleep(1)
self.drs.DisableSamplesBuffer()
time.sleep(0.5)
buff = np.array(self.drs.Recv_samplesBuffer_blocks(0))
if np.array_equal(buff,emptyBuff):
print('\n************** FALHA SAMPLES BUFFER **************\n')
self.update_gui.emit('\n *** ERRO: Falha Samples Buffer ***\n')
self.source.DisableOutput()
return
#log_hradc.gnd = buff.mean()
log_hradc_list.append(buff.mean())
buff = np.array(self.dmm.ReadMeasurementPoints())
if np.array_equal(buff,emptyBuff):
print('\n************** FALHA SAMPLES BUFFER **************\n')
self.update_gui.emit('\n *** ERRO: Falha Samples Buffer ***\n')
self.source.DisableOutput()
return
#log_dm.gnd = buff.mean()
log_dm_list.append(buff.mean())
self.drs.DisableHRADCSampling()
time.sleep(0.1)
self.source.DisableOutput()
print('HRADC: ' + str(log_hradc_list[-1]) + unit)
print('DMM: ' + str(log_dm_list[-1]) + unit + '\n')
self.update_gui.emit(' HRADC: ' + str(log_hradc_list[-1]) + unit)
self.update_gui.emit(' DMM: ' + str(log_dm_list[-1]) + unit + '\n')
if abs(log_hradc_list[-1] - self.refVal[signalType]) > self.refTol[signalType]:
log_hradc.test_result = "Reprovado"
print('HRADC Reprovado: ' + signalType)
self.update_gui.emit(' *** HRADC Reprovado! ***')
if abs(log_dm_list[-1] - self.refVal[signalType]) > self.refTol[signalType]:
log_dm.test_result = "Reprovado"
print('DMM Reprovcado: ' + signalType)
self.update_gui.emit(' *** DMM Reprovado! ***')
else:
log_hradc_list.append(0)
log_dm_list.append(0)
print('\nSalvando log e enviando ao servidor...')
self.update_gui.emit(' Salvando log e enviando ao servidor...')
log_hradc._iin_n = log_hradc_list.pop()
log_hradc._iin_p = log_hradc_list.pop()
log_hradc._vin_n = log_hradc_list.pop()
log_hradc._vin_p = log_hradc_list.pop()
log_hradc._temperature = log_hradc_list.pop()
log_hradc._vref_n = log_hradc_list.pop()
log_hradc._vref_p = log_hradc_list.pop()
log_hradc._gnd = log_hradc_list.pop()
log_hradc.details = board['pre_tests']
log_dm._iin_n = log_dm_list.pop()
log_dm._iin_p = log_dm_list.pop()
log_dm._vin_n = log_dm_list.pop()
log_dm._vin_p = log_dm_list.pop()
log_dm._temperature = log_dm_list.pop()
log_dm._vref_n = log_dm_list.pop()
log_dm._vref_p = log_dm_list.pop()
log_dm._gnd = log_dm_list.pop()
log_dm.details = board['pre_tests']
log_hradc_serverstatus = self._send_to_server(log_hradc)
log_dm_serverstatus = self._send_to_server(log_dm)
if (log_hradc.test_result == "Reprovado") or (log_dm.test_result == "Reprovado"):
log_res.append("Reprovado")
else:
log_res.append("Aprovado")
else:
print('Salvando log de placa reprovada e enviando ao servidor...')
self.update_gui.emit(' Salvando log de placa reprovada e enviando ao servidor...')
log_hradc.test_result = "Reprovado"
log_hradc.details = board['pre_tests']
log_hradc_serverstatus = self._send_to_server(log_hradc)
else:
print('Falha de comunicacao com servidor!')
self.update_gui.emit('*** ERRO: Falha de comunicacao com servidor! ***')
# TODO: incluir falha de comunicacao com servidor no sinal log_res
#log_res.append('')
# Quando o teste terminar emitir o resultado em uma lista de objetos
# do tipo HRADCLog
self.source.DisableOutput()
self.source.SetOutput(0,'V')
print('\nEnviando sinal ao app...')
self.update_gui.emit('Enviando sinal ao app...')
for i in range(4 - len(log_res)):
log_res.append(None)
print('\nlog_res:' + str(log_res))
self.test_complete.emit(log_res)
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
print('client_data:\n')
print(client_data)
client_method = item.method
client_response = client.do_request(client_method, client_data)
server_status = self._parse_response(client_response)
print(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def _convertToUint16List(self, val, format):
val_16 = []
val_b = struct.pack(self.bytesFormat[format],val)
print(val_b)
for i in range(0,len(val_b),2):
val_16.append(struct.unpack('H',val_b[i:i+2])[0])
print(val_16)
return val_16
def _configBoardsToTest(self,board,inputType):
for slot in range(self.nHRADC):
if slot == board['slot']:
self.drs.ConfigHRADC(slot,100000,inputType,0,0)
else:
self.drs.ConfigHRADC(slot,100000,'GND',0,0)
def run(self):
self._test_sequence()
class TestFbpWindow(QWidget):
def __init__(self, *args):
super(TestFbpWindow, self).__init__(*args)
uic.loadUi('wizard.ui', self)
self._initialize_widgets()
self._initialize_signals()
self._list_serial_ports()
self._current_ps_id = {
'Fonte 1': 1,
'Fonte 2': 2,
'Fonte 3': 3,
'Fonte 4': 4,
'Todas': 5
}
self._bsmp_var = {
'soft_intlk': 25,
'hard_intlk': 26,
'iload': 27,
'vload': 28,
'vdclink': 29,
'temp': 30,
'digital_pot': 35
}
self._drs = SerialDRS()
def _initialize_widgets(self):
self.pb_disconnect.setEnabled(False)
self.pb_off_1.setEnabled(False)
self.pb_off_2.setEnabled(False)
self.pb_off_3.setEnabled(False)
self.pb_off_4.setEnabled(False)
self.pb_open_loop_1.setEnabled(False)
self.pb_open_loop_2.setEnabled(False)
self.pb_open_loop_3.setEnabled(False)
self.pb_open_loop_4.setEnabled(False)
self.le_iload_1.setReadOnly(True)
self.le_iload_2.setReadOnly(True)
self.le_iload_3.setReadOnly(True)
self.le_iload_4.setReadOnly(True)
self.le_vload_1.setReadOnly(True)
self.le_vload_2.setReadOnly(True)
self.le_vload_3.setReadOnly(True)
self.le_vload_4.setReadOnly(True)
self.le_vdclink_1.setReadOnly(True)
self.le_vdclink_2.setReadOnly(True)
self.le_vdclink_3.setReadOnly(True)
self.le_vdclink_4.setReadOnly(True)
self.le_temp_1.setReadOnly(True)
self.le_temp_2.setReadOnly(True)
self.le_temp_3.setReadOnly(True)
self.le_temp_4.setReadOnly(True)
self.le_intlk.setReadOnly(True)
#self.combo_iref_id.addItems(['Fonte 1', 'Fonte 2', 'Fonte 3',
# 'Fonte 4', 'Todas'])
self.combo_iref_id.addItems(
['Fonte 1', 'Fonte 2', 'Fonte 3', 'Fonte 4'])
self.combo_intlk_id.addItems(
['Fonte 1', 'Fonte 2', 'Fonte 3', 'Fonte 4'])
self.le_digital_pot_write.setText(str(self.sl_digital_pot.value()))
def _initialize_signals(self):
self.pb_connect.clicked.connect(self._connect_serial)
self.pb_disconnect.clicked.connect(self._disconnect_serial)
self.pb_on_1.clicked.connect(self._turn_on_1)
self.pb_on_2.clicked.connect(self._turn_on_2)
self.pb_on_3.clicked.connect(self._turn_on_3)
self.pb_on_4.clicked.connect(self._turn_on_4)
self.pb_off_1.clicked.connect(self._turn_off_1)
self.pb_off_2.clicked.connect(self._turn_off_2)
self.pb_off_3.clicked.connect(self._turn_off_3)
self.pb_off_4.clicked.connect(self._turn_off_4)
self.pb_open_loop_1.clicked.connect(self._open_loop_1)
self.pb_open_loop_2.clicked.connect(self._open_loop_2)
self.pb_open_loop_3.clicked.connect(self._open_loop_3)
self.pb_open_loop_4.clicked.connect(self._open_loop_4)
self.pb_close_loop_1.clicked.connect(self._close_loop_1)
self.pb_close_loop_2.clicked.connect(self._close_loop_2)
self.pb_close_loop_3.clicked.connect(self._close_loop_3)
self.pb_close_loop_4.clicked.connect(self._close_loop_4)
self.pb_send_iref.clicked.connect(self._send_iref)
self.pb_read_intlk.clicked.connect(self._read_intlk)
self.pb_reset_intlk.clicked.connect(self._reset_intlk)
self.pb_iload_1.clicked.connect(self._read_iload_1)
self.pb_iload_2.clicked.connect(self._read_iload_2)
self.pb_iload_3.clicked.connect(self._read_iload_3)
self.pb_iload_4.clicked.connect(self._read_iload_4)
self.pb_vload_1.clicked.connect(self._read_vload_1)
self.pb_vload_2.clicked.connect(self._read_vload_2)
self.pb_vload_3.clicked.connect(self._read_vload_3)
self.pb_vload_4.clicked.connect(self._read_vload_4)
self.pb_vdclink_1.clicked.connect(self._read_vdclink_1)
self.pb_vdclink_2.clicked.connect(self._read_vdclink_2)
self.pb_vdclink_3.clicked.connect(self._read_vdclink_3)
self.pb_vdclink_4.clicked.connect(self._read_vdclink_4)
self.pb_temp_1.clicked.connect(self._read_temp_1)
self.pb_temp_2.clicked.connect(self._read_temp_2)
self.pb_temp_3.clicked.connect(self._read_temp_3)
self.pb_temp_4.clicked.connect(self._read_temp_4)
self.pb_digital_pot_read.clicked.connect(self._read_digital_pot)
self.sl_digital_pot.valueChanged.connect(self._update_digital_pot)
def _list_serial_ports(self):
if sys.platform.startswith('win'):
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or sys.platform.startswith(
'cygwin'):
ports = glob.glob('/dev/tty[A-Za-z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsuported platform')
for port in ports:
try:
s = serial.Serial(port)
s.close()
self.combo_com.addItem(port)
except (OSError, serial.SerialException):
pass
"""*************************************************
******************* PyQt Slots *********************
*************************************************"""
@pyqtSlot()
def _connect_serial(self):
try:
port = str(self.combo_com.currentText())
baud = '6000000'
con = self._drs.Connect(port, baud)
print(con)
if con:
self.pb_connect.setEnabled(False)
self.pb_disconnect.setEnabled(True)
self.combo_com.setEnabled(False)
else:
self.pb_disconnect.setEnabled(False)
self.pb_connect.setEnabled(True)
self.combo_com.setEnabled(True)
except:
pass
@pyqtSlot()
def _disconnect_serial(self):
try:
self._drs.Disconnect()
self.pb_disconnect.setEnabled(False)
self.pb_connect.setEnabled(True)
self.combo_com.setEnabled(True)
except:
pass
@pyqtSlot()
def _turn_on_1(self):
self._drs.SetSlaveAdd(1)
try:
self._drs.turn_on()
self.pb_on_1.setEnabled(False)
self.pb_off_1.setEnabled(True)
except:
pass
@pyqtSlot()
def _turn_on_2(self):
self._drs.SetSlaveAdd(2)
try:
self._drs.turn_on()
self.pb_on_2.setEnabled(False)
self.pb_off_2.setEnabled(True)
except:
pass
@pyqtSlot()
def _turn_on_3(self):
self._drs.SetSlaveAdd(3)
try:
self._drs.turn_on()
self.pb_on_3.setEnabled(False)
self.pb_off_3.setEnabled(True)
except:
pass
@pyqtSlot()
def _turn_on_4(self):
self._drs.SetSlaveAdd(4)
try:
self._drs.turn_on()
self.pb_on_4.setEnabled(False)
self.pb_off_4.setEnabled(True)
except:
pass
@pyqtSlot()
def _turn_off_1(self):
self._drs.SetSlaveAdd(1)
try:
self._drs.turn_off()
self.pb_on_1.setEnabled(True)
self.pb_off_1.setEnabled(False)
except:
pass
@pyqtSlot()
def _turn_off_2(self):
self._drs.SetSlaveAdd(2)
self.pb_on_2.setEnabled(True)
self.pb_off_2.setEnabled(False)
try:
self._drs.turn_off()
except:
pass
@pyqtSlot()
def _turn_off_3(self):
self._drs.SetSlaveAdd(3)
try:
self._drs.turn_off()
self.pb_on_3.setEnabled(True)
self.pb_off_3.setEnabled(False)
except:
pass
@pyqtSlot()
def _turn_off_4(self):
self._drs.SetSlaveAdd(4)
try:
self._drs.turn_off()
self.pb_on_4.setEnabled(True)
self.pb_off_4.setEnabled(False)
except:
pass
@pyqtSlot()
def _open_loop_1(self):
self._drs.SetSlaveAdd(1)
try:
self._drs.open_loop()
self.pb_open_loop_1.setEnabled(False)
self.pb_close_loop_1.setEnabled(True)
except:
pass
@pyqtSlot()
def _open_loop_2(self):
self._drs.SetSlaveAdd(2)
try:
self._drs.open_loop()
self.pb_open_loop_2.setEnabled(False)
self.pb_close_loop_2.setEnabled(True)
except:
pass
@pyqtSlot()
def _open_loop_3(self):
self._drs.SetSlaveAdd(3)
try:
self._drs.open_loop()
self.pb_open_loop_3.setEnabled(False)
self.pb_close_loop_3.setEnabled(True)
except:
pass
@pyqtSlot()
def _open_loop_4(self):
self._drs.SetSlaveAdd(4)
try:
self._drs.open_loop()
self.pb_open_loop_4.setEnabled(False)
self.pb_close_loop_4.setEnabled(True)
except:
pass
@pyqtSlot()
def _close_loop_1(self):
self._drs.SetSlaveAdd(1)
try:
self._drs.closed_loop()
self.pb_open_loop_1.setEnabled(True)
self.pb_close_loop_1.setEnabled(False)
except:
pass
@pyqtSlot()
def _close_loop_2(self):
self._drs.SetSlaveAdd(2)
try:
self._drs.closed_loop()
self.pb_open_loop_2.setEnabled(True)
self.pb_close_loop_2.setEnabled(False)
except:
pass
@pyqtSlot()
def _close_loop_3(self):
self._drs.SetSlaveAdd(3)
try:
self._drs.closed_loop()
self.pb_open_loop_3.setEnabled(True)
self.pb_close_loop_3.setEnabled(False)
except:
pass
@pyqtSlot()
def _close_loop_4(self):
self._drs.SetSlaveAdd(4)
try:
self._drs.closed_loop()
self.pb_open_loop_4.setEnabled(True)
self.pb_close_loop_4.setEnabled(False)
except:
pass
@pyqtSlot()
def _send_iref(self):
ps = str(self.combo_iref_id.currentText())
if ps == 'Todas':
try:
ref = float(self.le_iref.text())
self._drs.set_slowref_fbp(ref)
except:
pass
else:
add = self._current_ps_id[ps]
try:
self._drs.SetSlaveAdd(add)
ref = float(self.le_iref.text())
self._drs.set_slowref(ref)
except:
pass
@pyqtSlot()
def _read_intlk(self):
ps = self.combo_intlk_id.currentText()
try:
add = self._current_ps_id[ps]
self._drs.SetSlaveAdd(add)
print(add)
i = self._drs.read_bsmp_variable(self._bsmp_var['hard_intlk'],
'uint16_t', 0)
print(1)
self.le_intlk.setText(str(i))
except:
pass
@pyqtSlot()
def _reset_intlk(self):
ps = self.combo_intlk_id.currentText()
try:
add = self._current_ps_id[ps]
self._drs.SetSlaveAdd(ps)
intlk = self._drs.ResetInterlocks()
self.le_intlk.clear()
except:
pass
@pyqtSlot()
def _read_iload_1(self):
try:
self._drs.SetSlaveAdd(1)
i = self._drs.read_bsmp_variable(self._bsmp_var['iload'], 'float',
0)
self.le_iload_1.setText(str(round(i, 4)))
except:
pass
@pyqtSlot()
def _read_iload_2(self):
try:
self._drs.SetSlaveAdd(2)
i = self._drs.read_bsmp_variable(self._bsmp_var['iload'], 'float',
0)
self.le_iload_2.setText(str(round(i, 4)))
except:
pass
@pyqtSlot()
def _read_iload_3(self):
try:
self._drs.SetSlaveAdd(3)
i = self._drs.read_bsmp_variable(self._bsmp_var['iload'], 'float',
0)
self.le_iload_3.setText(str(round(i, 4)))
except:
pass
@pyqtSlot()
def _read_iload_4(self):
try:
self._drs.SetSlaveAdd(4)
i = self._drs.read_bsmp_variable(self._bsmp_var['iload'], 'float',
0)
self.le_iload_4.setText(str(round(i, 4)))
except:
pass
@pyqtSlot()
def _read_vload_1(self):
try:
self._drs.SetSlaveAdd(1)
v = self._drs.read_bsmp_variable(self._bsmp_var['vload'], 'float',
0)
self.le_vload_1.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vload_2(self):
try:
self._drs.SetSlaveAdd(2)
v = self._drs.read_bsmp_variable(self._bsmp_var['vload'], 'float',
0)
self.le_vload_2.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vload_3(self):
try:
self._drs.SetSlaveAdd(3)
v = self._drs.read_bsmp_variable(self._bsmp_var['vload'], 'float',
0)
self.le_vload_3.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vload_4(self):
try:
self._drs.SetSlaveAdd(4)
v = self._drs.read_bsmp_variable(self._bsmp_var['vload'], 'float',
0)
self.le_vload_4.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vdclink_1(self):
try:
self._drs.SetSlaveAdd(1)
v = self._drs.read_bsmp_variable(self._bsmp_var['vdclink'],
'float', 0)
self.le_vdclink_1.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vdclink_2(self):
try:
self._drs.SetSlaveAdd(2)
v = self._drs.read_bsmp_variable(self._bsmp_var['vdclink'],
'float', 0)
self.le_vdclink_2.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vdclink_3(self):
try:
self._drs.SetSlaveAdd(3)
v = self._drs.read_bsmp_variable(self._bsmp_var['vdclink'],
'float', 0)
self.le_vdclink_3.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_vdclink_4(self):
try:
self._drs.SetSlaveAdd(4)
v = self._drs.read_bsmp_variable(self._bsmp_var['vdclink'],
'float', 0)
self.le_vdclink_4.setText(str(round(v, 4)))
except:
pass
@pyqtSlot()
def _read_temp_1(self):
try:
self._drs.SetSlaveAdd(1)
t = self._drs.read_bsmp_variable(self._bsmp_var['temp'], 'float',
0)
self.le_temp_1.setText(str(round(t, 4)))
except:
pass
@pyqtSlot()
def _read_temp_2(self):
try:
self._drs.SetSlaveAdd(2)
t = self._drs.read_bsmp_variable(self._bsmp_var['temp'], 'float',
0)
self.le_temp_2.setText(str(round(t, 4)))
except:
pass
@pyqtSlot()
def _read_temp_3(self):
try:
self._drs.SetSlaveAdd(3)
t = self._drs.read_bsmp_variable(self._bsmp_var['temp'], 'float',
0)
self.le_temp_3.setText(str(round(t, 4)))
except:
pass
@pyqtSlot()
def _read_temp_4(self):
try:
self._drs.SetSlaveAdd(4)
t = self._drs.read_bsmp_variable(self._bsmp_var['temp'], 'float',
0)
self.le_temp_4.setText(str(round(t, 4)))
except:
pass
@pyqtSlot()
def _update_digital_pot(self):
pot_val = self.sl_digital_pot.value()
self.le_digital_pot_write.setText(str(pot_val))
write_voltage = (6.0 / 100) * pot_val
self._drs.write_digital_pot_voltage(write_voltage)
read_voltage = self._drs.read_bsmp_variable(
self._bsmp_var['digital_pot'], 'float', 0)
self.le_digital_pot_read.setText(str(read_voltage))
@pyqtSlot()
def _read_digital_pot(self):
read_voltage = self._drs.read_bsmp_variable(
self._bsmp_var['digital_pot'], 'float', 0)
self.le_digital_pot_read.setText(str(read_voltage))
class FbpDclink(QThread):
update_gui = pyqtSignal(dict)
def __init__(self):
QThread.__init__(self)
self._is_active = False
self._baudrate = '6000000'
#self._baudrate = '115200'
self._drs = SerialDRS()
self._screen_readings = {
'digital_pot_read': 0.0,
'fault_status': 0,
'intlk': 0,
'vdclink_1': 0.0,
'vdclink_2': 0.0,
'vdclink_3': 0.0,
'vdclink_4': 0.0
}
self._interlocks = [
'Sobre tensão na fonte 3', 'Sobre-tensão na fonte 2',
'Sobre-tensão na fonte 1', 'Interlock externo', 'Sensor de fumaça',
'Falha Fonte 3', 'Falha Fonte 2', 'Falha Fonte 1'
]
@property
def is_active(self):
return self._is_active
def connect_serial(self, com_port):
if com_port is not None:
res = self._drs.Connect(com_port, self._baudrate)
self._drs.SetSlaveAdd(20)
return res
def disconnect_serial(self):
res = self._drs.Disconnect()
return res
def turn_on(self):
res = self._drs.turn_on()
self._is_active = True
return res
def turn_off(self):
res = self._drs.turn_off()
self._is_active = False
return res
def intlk_reset(self):
self._drs.reset_interlocks()
def write_reference_voltage(self, val):
self._drs.set_slowref(val)
def check_interlocks(self):
res = True
intlk = self._drs.read_bsmp_variable(26, 'uint32_t')
if intlk is 0:
res = False
return res
def get_current_reference(self):
ref = int(self._drs.read_bsmp_variable(2, 'float'))
return ref
def update_params(self):
try:
self._screen_readings['vdclink_2'] = round(
self._drs.read_bsmp_variable(30, 'float'), 3)
except:
pass
try:
self._screen_readings['digital_pot_read'] = round(
self._drs.read_bsmp_variable(28, 'float'), 3)
except:
pass
try:
self._screen_readings['intlk'] = self._drs.read_bsmp_variable(
26, 'uint32_t')
except:
pass
try:
self._screen_readings['vdclink_1'] = round(
self._drs.read_bsmp_variable(29, 'float'), 3)
except:
pass
try:
self._screen_readings['vdclink_3'] = round(
self._drs.read_bsmp_variable(31, 'float'), 3)
except:
pass
try:
self._screen_readings[
'fault_status'] = self._drs.read_bsmp_variable(27, 'uint16_t')
except:
pass
print(self._screen_readings)
self.update_gui.emit(self._screen_readings)
def get_intlk_list(self, bitmask):
bitfield = self._get_bitfield(bitmask)
mask = bitfield[len(bitfield) - len(self._interlocks):]
filtered = itertools.compress(self._interlocks, mask)
return list(filtered)
def _get_bitfield(self, bitmask):
bitfield = [int(bit)
for bit in bin(bitmask)[2:]] # [2:] to remove '0b'
return bitfield
class PowerSupplyTest(QThread):
test_complete = pyqtSignal(bool)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
def __init__(self,
comport=None,
baudrate=None,
serial_number=None,
variant=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
self._serial_port = serial.Serial()
self.FBP = SerialDRS()
@property
def serial_number(self):
return self._serial_number
@serial_number.setter
def serial_number(self, value):
self._serial_number = value
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudarate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
self._serial_port.baudrate = self._baudrate
self._serial_port.port = self._comport
return self.FBP.Connect(self._comport, self._baudrate)
def test_communication(self):
result = (False, False
) # Result for communication test and aux power supply
test = []
#TODO: Communication test
for i in range(2):
try:
if i == 0:
print('Configurando UDC da Fonte...')
self.FBP.SetSlaveAdd(1) # Endereço do controlador
time.sleep(0.5)
self.FBP.Config_nHRADC(4)
elif i == 1:
print('Configurando UDC da jiga...')
self.FBP.SetSlaveAdd(5) # Endereço do controlador
time.sleep(0.5)
self.FBP.Write_sigGen_Aux(0) # Usando 4 fontes no bastidor
# em teste e 0 na jiga bastidor
time.sleep(5)
test_package = self.FBP.Read_ps_Model()
if (test_package[0] == 0) and (test_package[1] == 17) and \
(test_package[2] == 512) and (test_package[3] == 14) and \
(test_package[4] == 223):
test.append(True)
else:
test.append(False)
except:
print('ERRO!!!')
test.append(False)
print(
'###########################################################')
print('Interlocks no teste de comunicação:')
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
if test == [True, True]:
result = (True, True)
else:
result = (False, False)
return result
def _test_sequence(self):
result = True
send_to_server_result = False
OnOff = ['Reprovado' for i in range(4)]
MeasDCLink = [[] for j in range(4)]
MeasVout = [[] for k in range(4)]
MeasTemp = [[] for l in range(4)]
MeasCurr = [[[] for m in range(5)] for n in range(4)]
compare_current = [
4, -4, 5, 10, -10
] # [0] e [1] alterados para adequação do novo ciclo de trabalho
LimDCLink = [14, 16] # valores limite para o DC Link
LimVout = [
5, 7.5
] # valores limite para tensão de saída alterar para LimVout[0] = 0.6 e LimVout[1] = 1
LimTemp = 60 # valor limite para temperatura
# If serial connection is lost
if not self._serial_port.is_open:
self.connection_lost.emit()
#TODO: Encerra testes
ps = PowerSupply()
ps.serial_number = self._serial_number
res = self._send_to_server(ps)
if res:
self.FBP.SetSlaveAdd(1) # Bastidor em teste
time.sleep(1)
self.FBP.ResetInterlocks()
time.sleep(5)
# self.FBP.TurnOff(0b1111)
# time.sleep(5)
'''########################### Teste Liga/Desliga ###########################'''
'''##########################################################################'''
self.update_gui.emit(
'Iniciando teste liga/desliga dos módulos de potência...')
for module in range(4):
self.FBP.TurnOn(2**module)
time.sleep(1)
# self.FBP.OpenLoop(2**module)
# time.sleep(1)
if self.FBP.Read_ps_OnOff() == 2**module:
OnOff[module] = 'OK'
else:
self.update_gui.emit('O módulo ' + str(module + 1) +
' não ligou corretamente')
OnOff[module] = 'NOK'
time.sleep(1)
self.FBP.TurnOff(2**module)
if self.FBP.Read_ps_OnOff() == 0:
if OnOff[module] == 'OK':
OnOff[module] = 'OK'
else:
OnOff[module] = 'NOK'
self.update_gui.emit('O módulo ' + str(module + 1) +
' não desligou corretamente')
time.sleep(1)
'''##########################################################################'''
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
self.FBP.TurnOn(0b1111) # liga todos os módulos
time.sleep(5)
self.FBP.OpenLoop(0b1111) # todos os módulos em malha aberta
if (abs(self.FBP.Read_iMod1()) > 12) or \
(abs(self.FBP.Read_iMod2()) > 12) or \
(abs(self.FBP.Read_iMod3()) > 12) or \
(abs(self.FBP.Read_iMod4()) > 12):
self.update_gui.emit('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(10)
raise NameError('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(1)
'''################## Teste em Malha Aberta com 21.5% #######################'''
'''##########################################################################'''
self.update_gui.emit('Iniciando teste com módulos a 4A...')
self.FBP.ClosedLoop(15)
time.sleep(1)
for module in range(4):
if module == 0:
self.FBP.SetISlowRefx4(4, 0, 0, 0) # ciclo de trabalho
elif module == 1: # alterado para 21.5%
self.FBP.SetISlowRefx4(0, 4, 0, 0) # ciclo de trabalho
elif module == 2: # alterado para 21.5%
self.FBP.SetISlowRefx4(0, 0, 4, 0) # ciclo de trabalho
elif module == 3: # alterado para 22,575%
self.FBP.SetISlowRefx4(0, 0, 0, 4) # ciclo de trabalho
# alterado para 21.5%
# o teste original pedia um ciclo de trabalho de 20%, contudo
# foi necessário alter o teste para trabalhar em malha aberta
# devido a uma alteração na carga
time.sleep(2)
if (abs(self.FBP.Read_iMod1()) > 12) or \
(abs(self.FBP.Read_iMod2()) > 12) or \
(abs(self.FBP.Read_iMod3()) > 12) or \
(abs(self.FBP.Read_iMod4()) > 12):
self.update_gui.emit('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(10)
raise NameError('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(1)
MeasureList = self._save_CurrentMeasurement(module)
for current in MeasureList:
MeasCurr[module][0].append(current)
time.sleep(1)
self.FBP.SetSlaveAdd(1) # bastidor em teste
print('mod1: ' + str(self.FBP.Read_iMod1()))
time.sleep(0.1)
print('mod2: ' + str(self.FBP.Read_iMod2()))
time.sleep(0.1)
print('mod3: ' + str(self.FBP.Read_iMod3()))
time.sleep(0.1)
print('mod4: ' + str(self.FBP.Read_iMod4()) + '\n')
time.sleep(0.1)
# self.FBP.ConfigWfmRef(module+1, 0) # ajusta 0 o ciclo de trabalho apenas para o modulo testado
if module == 0 or module == 1 or module == 2 or module == 3:
self.FBP.SetISlowRefx4(0, 0, 0, 0)
time.sleep(2)
'''##########################################################################'''
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
'''################## Teste em Malha Aberta com -21.5% ######################'''
'''##########################################################################'''
self.update_gui.emit('Iniciando teste com módulos a -4A...')
self.FBP.ClosedLoop(15)
time.sleep(1)
for module in range(4):
if module == 0:
self.FBP.SetISlowRefx4(-4, 0, 0, 0) # ciclo de trabalho
elif module == 1: # alterado para 21.5%
self.FBP.SetISlowRefx4(0, -4, 0, 0) # ciclo de trabalho
elif module == 2: # alterado para 21.5%
self.FBP.SetISlowRefx4(0, 0, -4, 0) # ciclo de trabalho
elif module == 3: # alterado para 22,575%
self.FBP.SetISlowRefx4(0, 0, 0, -4) # ciclo de trabalho
# alterado para 21.5%
# o teste original pedia um ciclo de trabalho de 20%, contudo
# foi necessário alter o teste para trabalhar em malha aberta
# devido a uma alteração na carga
time.sleep(2)
MeasureList = self._save_CurrentMeasurement(module)
for current in MeasureList:
MeasCurr[module][1].append(current)
time.sleep(1)
self.FBP.SetSlaveAdd(1) # bastidor em teste
print('mod1: ' + str(self.FBP.Read_iMod1()))
time.sleep(0.1)
print('mod2: ' + str(self.FBP.Read_iMod2()))
time.sleep(0.1)
print('mod3: ' + str(self.FBP.Read_iMod3()))
time.sleep(0.1)
print('mod4: ' + str(self.FBP.Read_iMod4()) + '\n')
time.sleep(0.1)
if module == 0 or module == 1 or module == 2 or module == 3:
self.FBP.SetISlowRefx4(0, 0, 0, 0)
time.sleep(2)
'''##########################################################################'''
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
'''#################### Teste em Malha Fechada com 5A #######################'''
'''##########################################################################'''
self.update_gui.emit(
'Iniciando teste com módulos em malha fechada a 5A...')
for module in range(4):
self.FBP.ClosedLoop(15)
time.sleep(1)
if module == 0:
self.FBP.SetISlowRefx4(5, 0, 0, 0)
elif module == 1:
self.FBP.SetISlowRefx4(0, 5, 0, 0)
elif module == 2:
self.FBP.SetISlowRefx4(0, 0, 5, 0)
elif module == 3:
self.FBP.SetISlowRefx4(0, 0, 0, 5)
time.sleep(2)
if (abs(self.FBP.Read_iMod1()) > 12) or \
(abs(self.FBP.Read_iMod2()) > 12) or \
(abs(self.FBP.Read_iMod3()) > 12) or \
(abs(self.FBP.Read_iMod4()) > 12):
self.update_gui.emit('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(10)
raise NameError('ERRO! REINICIE O TESTE E AS FONTES')
time.sleep(1)
MeasureList = self._save_CurrentMeasurement(module)
print('mod1: ' + str(self.FBP.Read_iMod1()))
time.sleep(0.1)
print('mod2: ' + str(self.FBP.Read_iMod2()))
time.sleep(0.1)
print('mod3: ' + str(self.FBP.Read_iMod3()))
time.sleep(0.1)
print('mod4: ' + str(self.FBP.Read_iMod4()) + '\n')
time.sleep(0.1)
for current in MeasureList:
MeasCurr[module][2].append(current)
self.FBP.SetSlaveAdd(1)
if module == 0 or module == 1 or module == 2 or module == 3:
self.FBP.SetISlowRefx4(0, 0, 0, 0)
time.sleep(2)
self.FBP.OpenLoop(15)
time.sleep(2)
'''##########################################################################'''
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
'''################### Teste em Malha Fechada com 10A #######################'''
'''##########################################################################'''
self.update_gui.emit(
'Iniciando teste com módulos em malha fechada a 10A...')
self.FBP.ClosedLoop(0b1111)
time.sleep(2)
self.FBP.OpMode(0)
time.sleep(2)
self.FBP.SetISlowRefx4(10, 10, 10, 10)
time.sleep(1)
for module in range(4):
time.sleep(5)
MeasureList = self._save_CurrentMeasurement(module)
for current in MeasureList:
MeasCurr[module][3].append(current)
self.FBP.SetSlaveAdd(1)
print('mod1: ' + str(self.FBP.Read_iMod1()))
time.sleep(0.1)
print('mod2: ' + str(self.FBP.Read_iMod2()))
time.sleep(0.1)
print('mod3: ' + str(self.FBP.Read_iMod3()))
time.sleep(0.1)
print('mod4: ' + str(self.FBP.Read_iMod4()) + '\n')
time.sleep(0.1)
'''##########################################################################'''
print('Interlocks Ativos: ')
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
self.update_gui.emit(
'Realizando medidas de tensão do DC-Link, tensão de saída e temperatura'
)
for o in range(8):
time.sleep(30) # alterar tempo para 30s
MeasDCLink[0].append(self.FBP.Read_vDCMod1())
time.sleep(0.1)
MeasDCLink[1].append(self.FBP.Read_vDCMod2())
time.sleep(0.1)
MeasDCLink[2].append(self.FBP.Read_vDCMod3())
time.sleep(0.1)
MeasDCLink[3].append(self.FBP.Read_vDCMod4())
time.sleep(0.1)
MeasVout[0].append(self.FBP.Read_vOutMod1())
time.sleep(0.1)
MeasVout[1].append(self.FBP.Read_vOutMod2())
time.sleep(0.1)
MeasVout[2].append(self.FBP.Read_vOutMod3())
time.sleep(0.1)
MeasVout[3].append(self.FBP.Read_vOutMod4())
time.sleep(0.1)
MeasTemp[0].append(self.FBP.Read_temp1())
time.sleep(0.1)
MeasTemp[1].append(self.FBP.Read_temp2())
time.sleep(0.1)
MeasTemp[2].append(self.FBP.Read_temp3())
time.sleep(0.1)
MeasTemp[3].append(self.FBP.Read_temp4())
time.sleep(0.1)
self.FBP.SetSlaveAdd(1)
'''################### Teste em Malha Fechada com -10A ######################'''
'''##########################################################################'''
self.update_gui.emit(
'Iniciando teste com módulos em malha fechada a -10A...')
self.FBP.SetISlowRefx4(0, 0, 0, 0)
time.sleep(0.5)
self.FBP.SetISlowRefx4(-10, -10, -10, -10)
for module in range(4):
time.sleep(5)
MeasureList = self._save_CurrentMeasurement(module)
for current in MeasureList:
MeasCurr[module][4].append(current)
self.FBP.SetSlaveAdd(1)
print('mod1: ' + str(self.FBP.Read_iMod1()))
time.sleep(0.1)
print('mod2: ' + str(self.FBP.Read_iMod2()))
time.sleep(0.1)
print('mod3: ' + str(self.FBP.Read_iMod3()))
time.sleep(0.1)
print('mod4: ' + str(self.FBP.Read_iMod4()) + '\n')
time.sleep(0.1)
'''##########################################################################'''
self.FBP.Read_ps_SoftInterlocks()
self.FBP.Read_ps_HardInterlocks()
self.update_gui.emit(
'Realizando medidas de tensão do DC-Link, tensão de saída e temperatura'
)
for p in range(8):
time.sleep(30) # alterar tempo para 30s
MeasDCLink[0].append(self.FBP.Read_vDCMod1())
time.sleep(0.1)
MeasDCLink[1].append(self.FBP.Read_vDCMod2())
time.sleep(0.1)
MeasDCLink[2].append(self.FBP.Read_vDCMod3())
time.sleep(0.1)
MeasDCLink[3].append(self.FBP.Read_vDCMod4())
time.sleep(0.1)
MeasVout[0].append(self.FBP.Read_vOutMod1())
time.sleep(0.1)
MeasVout[1].append(self.FBP.Read_vOutMod2())
time.sleep(0.1)
MeasVout[2].append(self.FBP.Read_vOutMod3())
time.sleep(0.1)
MeasVout[3].append(self.FBP.Read_vOutMod4())
time.sleep(0.1)
MeasTemp[0].append(self.FBP.Read_temp1())
time.sleep(0.1)
MeasTemp[1].append(self.FBP.Read_temp2())
time.sleep(0.1)
MeasTemp[2].append(self.FBP.Read_temp3())
time.sleep(0.1)
MeasTemp[3].append(self.FBP.Read_temp4())
time.sleep(0.1)
self.FBP.SetSlaveAdd(1)
self.FBP.SetISlowRefx4(0, 0, 0, 0)
time.sleep(1)
self.FBP.TurnOff(0b1111)
for module in range(4):
log = PowerSupplyLog()
log.id_canal_power_supply = module + 1
test = [True for p in range(9)]
n = 0
temp_exceeded = 0
self.update_gui.emit('')
self.update_gui.emit('Verificando resultados do módulo '\
+ str(module + 1) + '...')
'''-------------------------------------------------------------'''
for a in compare_current:
for b in MeasCurr[module][n]:
if a == round(b):
if test[n]:
test[n] = True
else:
test[n] = False
if test[n]:
self.update_gui.emit(' Aprovado no teste ' +
str(compare_current.index(a) +
1) + ' de corrente de saída')
else:
self.update_gui.emit(' Reprovado no teste ' +
str(compare_current.index(a) +
1) + ' de corrente de saída')
n = n + 1
'''-------------------------------------------------------------'''
'''-------------------------------------------------------------'''
for c in MeasDCLink[module]:
if (LimDCLink[0] <= round(c)) and (round(c) <=
LimDCLink[1]):
if test[5]:
test[5] = True
else:
test[5] = False
if test[5]:
self.update_gui.emit(
' Aprovado no teste de leitura da tensão do DC Link'
)
else:
self.update_gui.emit(
' Reprovado no teste de leitura da tensão do DC Link'
)
'''-------------------------------------------------------------'''
'''-------------------------------------------------------------'''
for d in MeasTemp[module]:
if d <= LimTemp:
if test[6]:
test[6] = True
elif d == 127:
temp_exceeded = 127
test[6] = False
elif (d >= LimTemp) and (d != 127):
# if d == 127:
# test[6] = True
# temp_exceeded = 127
test[6] = False
if test[6]:
self.update_gui.emit(
' Aprovado no teste de leitura da temperatura')
else:
if temp_exceeded == 127:
self.update_gui.emit(
' Aprovado no teste de leitura da temperatura com ressalvas'
)
test[6] = True
else:
self.update_gui.emit(
' Reprovado no teste de leitura de temperatura'
)
'''-------------------------------------------------------------'''
'''-------------------------------------------------------------'''
for e in range(0, len(MeasVout[module]) - 8):
if (LimVout[0] < MeasVout[module][e]) and (
MeasVout[module][e] < LimVout[1]):
if test[7]:
test[7] = True
else:
test[7] = False
if test[7]:
self.update_gui.emit(
' Aprovado no teste 1 de leitura da tensão de saída '
)
else:
self.update_gui.emit(
' Reprovado no teste 1 de leitura da tensão de saída'
)
'''-------------------------------------------------------------'''
'''-------------------------------------------------------------'''
for f in range(8, len(MeasVout[module])):
if (-LimVout[1] < MeasVout[module][f]) and (
MeasVout[module][f] < -LimVout[0]):
if test[8]:
test[8] = True
else:
test[8] = False
if test[8]:
self.update_gui.emit(
' Aprovado no teste 2 de leitura da tensão de saída'
)
else:
self.update_gui.emit(
' Reprovado no teste 2 de leitura da tensão de saída'
)
'''-------------------------------------------------------------'''
print('\n')
print(test)
print('\n')
if test == [True for g in range(9)]:
if result:
result = True
log.test_result = 'Aprovado'
else:
log.test_result = 'Reprovado'
result = False
log.result_test_on_off = OnOff[module]
log.serial_number_power_supply = self._serial_number
log.iout0 = MeasCurr[module][3][0]
log.iout1 = MeasCurr[module][4][0]
log.vout0 = MeasVout[module][7]
log.vout1 = MeasVout[module][15]
log.vdclink0 = MeasDCLink[module][7]
log.vdclink1 = MeasDCLink[module][15]
log.temperatura0 = MeasTemp[module][7]
log.temperatura1 = MeasTemp[module][15]
log.iout_add_20_duty_cycle = MeasCurr[module][0][0]
log.iout_less_20_duty_cycle = MeasCurr[module][1][0]
log.details = 'SoftInterlocks ativos: ' + str(self.FBP.Read_ps_SoftInterlocks()) + \
' HardInterlocks ativos: ' + str(self.FBP.Read_ps_HardInterlocks())
if temp_exceeded == 127:
log.details = log.details + ' (false_read 127 degrees Celsius)'
send_to_server_result = self._send_to_server(log)
self.update_gui.emit('')
self.update_gui.emit('Interlocks Ativos:')
for softinterlock in self._read_SoftInterlock(
self.FBP.Read_ps_SoftInterlocks()):
self.update_gui.emit(softinterlock)
for hardinterlock in self._read_HardInterlock(
self.FBP.Read_ps_HardInterlocks()):
self.update_gui.emit(hardinterlock)
print('--------------------------------------------\n')
self.test_complete.emit(result)
def _save_CurrentMeasurement(self, module):
Measurement = []
if module == 0:
self.FBP.SetSlaveAdd(1) # bastidor em teste
Measurement.append(self.FBP.Read_iMod1(
)) # corrente de saída lida pelo bastidor testado
time.sleep(0.1)
self.FBP.SetSlaveAdd(5) # jiga bastidor
Measurement.append(self.FBP.Read_iMod1()
) # corrente de saída lida pela jiga bastidor
time.sleep(0.1)
elif module == 1:
self.FBP.SetSlaveAdd(1) # bastidor em teste
Measurement.append(self.FBP.Read_iMod2(
)) # corrente de saída lida pelo bastidor testado
time.sleep(0.1)
self.FBP.SetSlaveAdd(5) # jiga bastidor
Measurement.append(self.FBP.Read_iMod2()
) # corrente de saída lida pela jiga bastidor
time.sleep(0.1)
elif module == 2:
self.FBP.SetSlaveAdd(1) # bastidor em teste
Measurement.append(self.FBP.Read_iMod3(
)) # corrente de saída lida pelo bastidor testado
time.sleep(0.1)
self.FBP.SetSlaveAdd(5) # jiga bastidor
Measurement.append(self.FBP.Read_iMod3()
) # corrente de saída lida pela jiga bastidor
time.sleep(0.1)
elif module == 3:
self.FBP.SetSlaveAdd(1) # bastidor em teste
Measurement.append(self.FBP.Read_iMod4(
)) # corrente de saída lida pelo bastidor testado
time.sleep(0.1)
self.FBP.SetSlaveAdd(5) # jiga bastidor
Measurement.append(self.FBP.Read_iMod4()
) # corrente de saída lida pela jiga bastidor
time.sleep(0.1)
return Measurement
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
print(client_data)
client_method = item.method
client_response = client.do_request(client_method, client_data)
print(client_response)
server_status = self._parse_response(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def run(self):
self._test_sequence()
#pass
def _read_SoftInterlock(self, int_interlock):
SoftInterlockList = ['N/A', 'Sobre-tensão na carga 1', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensão na carga 2', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensão na carga 3', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensão na carga 4', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A']
op_bin = 1
ActiveSoftInterlocks = []
for i in range(len('{0:b}'.format(int_interlock))):
if (int_interlock & (op_bin << i)) == 2**i:
ActiveSoftInterlocks.append(SoftInterlockList[i])
return ActiveSoftInterlocks
def _read_HardInterlock(self, int_interlock):
HardInterlockList = ['Sobre-corrente na carga 1', 'N/A', \
'Sobre-tensão no DC-Link do módulo 1', \
'Sub-tensão no DC-Link do módulo 1', \
'Falha no relé de entrada do DC-Link do módulo 1', \
'Falha no fusível de entrada do DC-Link do módulo 1', \
'Falha nos drivers do módulo 1', \
'Sobre-temperatura no módulo 1', \
'Sobre-corrente na carga 2', 'N/A', \
'Sobre-tensão no DC-Link do módulo 2', \
'Sub-tensão no DC-Link do módulo 2', \
'Falha no relé de entrada do DC-Link do módulo 2', \
'Falha no fusível de entrada do DC-Link do módulo 2', \
'Falha nos drivers do módulo 2', \
'Sobre-temperatura no módulo 2', \
'Sobre-corrente na carga 3', 'N\A', \
'Sobre-tensão no DC-Link do módulo 3', \
'Sub-tensão no DC-Link do módulo 3', \
'Falha no relé de entrada no DC-Link do módulo 3', \
'Falha no fusível de entrada do DC-Link do módulo 3', \
'Falha nos drivers do módulo 3', \
'Sobre-temperatura no módulo 3', \
'Sobre-corrente na carga 4', 'N/A', \
'Sobre-tensão no DC-Link do módulo 4', \
'Sub-tensão no DC-Link do módulo 4', \
'Falha no relé de entrada do DC-Link do módulo 4', \
'Falha no fusível de entrada do DC-Link do módulo 4', \
'Falha nos drivers do módulo 4', \
'Sobre-temperatura no módulo 4']
op_bin = 1
ActiveHardInterlocks = []
for i in range(len('{0:b}'.format(int_interlock))):
if (int_interlock & (op_bin << i)) == 2**i:
ActiveHardInterlocks.append(HardInterlockList[i])
return ActiveHardInterlocks
class PowerModuleTest(QThread):
test_complete = pyqtSignal(list)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
def __init__(self, comport=None, baudrate=None,
mod0=None, mod1=None, mod2=None, mod3=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_mod0 = mod0
self._serial_mod1 = mod1
self._serial_mod2 = mod2
self._serial_mod3 = mod3
self._serial_port = serial.Serial()
self._active_interlocks = ''
self.FBP = SerialDRS()
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudarate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
@property
def serial_mod0(self):
return self._serial_mod0
@serial_mod0.setter
def serial_mod0(self, value):
self._serial_mod0 = value
@property
def serial_mod1(self):
return self._serial_mod1
@serial_mod1.setter
def serial_mod1(self, value):
self._serial_mod1 = value
@property
def serial_mod2(self):
return self._serial_mod2
@serial_mod2.setter
def serial_mod2(self, value):
self._serial_mod2 = value
@property
def serial_mod3(self):
return self._serial_mod3
@serial_mod3.setter
def serial_mod3(self, value):
self._serial_mod3 = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
self._serial_port.baudrate = self._baudrate
self._serial_port.port = self._comport
self.FBP.SetSlaveAdd(5)
return self.FBP.Connect(self._comport, self._baudrate)
def test_communication(self):
# Resultado teste de comunicação para os 4 modulos
time.sleep(30)
n_mod = 0
result = ''
serial = [self._serial_mod0, self._serial_mod1, self._serial_mod2,
self._serial_mod3]
for j in range(0, len(serial)):
if serial[j] != None:
n_mod = n_mod+1
try:
self.FBP.Write_sigGen_Aux(n_mod)
test_package = self.FBP.Read_ps_Model()
if (test_package[0] == 0) and \
(test_package[1] == 17) and \
(test_package[2] == 512) and \
(test_package[3] == 14) and \
(test_package[4] == 223):
result = 'OK'
#---------------------verifica interlocks 1----------------------
print(self.FBP.Read_ps_SoftInterlocks())
print(self.FBP.Read_ps_HardInterlocks())
#----------------------------------------------------------------
self.FBP.ResetInterlocks()
else:
result = 'Falha'
except:
result = 'Falha'
return result
def _test_sequence(self):
response = [None for i in range(4)]
serial = [self._serial_mod0, self._serial_mod1, self._serial_mod2,
self._serial_mod3]
mod_result1 = [[] for j in range(4)] # para medidas de iout
mod_result2 = [[] for k in range(4)] # para medidas de vout
mod_result3 = [[] for l in range(4)] # para medidas de temperatura
mod_result4 = [[] for m in range(4)] # para medidas de dclink
load_current = ['turnedOff', 0, 23.5, 43.5, -43.5, -23.5] # correntes setadas
compare_current = [0, 0, 5, 10, -10, -5] # para comparar medidas de correntes
if not self._serial_port.is_open:
self.connection_lost.emit()
#TODO: Encerra testes
'''###########################################################'''
'''Número de modulos conectados para inicializar o controlador'''
'''###########################################################'''
n_mod = 0
for o in range(0, len(serial)):
if serial[o] != None:
n_mod = n_mod+1
self.FBP.Write_sigGen_Aux(n_mod)
'''###########################################################'''
'''###########################################################'''
'''###############################################################################'''
'''Setando todos os valores de corrente e salvando resultados na matriz mod_result'''
'''###############################################################################'''
sum_mod = 0
for module in serial:
if module is not None:
sum_mod = sum_mod + (2 ** serial.index(module))
print('sum_mod enviado para UDC: ' + str(sum_mod) + '\n')
#---------------------verifica interlocks 2----------------------
print(self.FBP.Read_ps_SoftInterlocks())
print(self.FBP.Read_ps_HardInterlocks())
# self._active_interlocks = 'self._active_interlocks +\
# '2-' + soft + '-' + hard + ' ''
#----------------------------------------------------------------
for set_current in load_current:
if set_current == 'turnedOff':
self.FBP.TurnOff(sum_mod)
self.update_gui.emit('Iniciando medições com modulos desligados')
#---------------------verifica interlocks 3----------------------
print(self.FBP.Read_ps_SoftInterlocks())
print(self.FBP.Read_ps_HardInterlocks())
# self._active_interlocks = self._active_interlocks +\
# '3-' + soft + '-' + hard + ' '
#----------------------------------------------------------------
time.sleep(30) # Alterar para 2 min
else:
self.FBP.TurnOn(sum_mod)
time.sleep(1)
self.FBP.OpenLoop(sum_mod)
time.sleep(1)
self.update_gui.emit('Iniciando medições com modulos ligados a '\
+ str(compare_current[load_current.index(set_current)]) + 'A')
self.FBP.SetISlowRef(0.25 * set_current)
time.sleep(0.5)
self.FBP.SetISlowRef(0.5 * set_current)
time.sleep(0.5)
self.FBP.SetISlowRef(set_current)
#---------------------verifica interlocks 4 - 8-----------------
print(self.FBP.Read_ps_SoftInterlocks())
print(self.FBP.Read_ps_HardInterlocks())
index = str(load_current.index(set_current) + 3)
# self._active_interlocks = self._active_interlocks\
# + index + '-' + soft + '-' + hard + ' '
#---------------------------------------------------------------
if abs(self.FBP.Read_iMod1()) > 12 or \
abs(self.FBP.Read_iMod2()) > 12 or \
abs(self.FBP.Read_iMod3()) > 12 or \
abs(self.FBP.Read_iMod4()) > 12:
self.update_gui.emit('ERRO DE LEITURA DAS CORRENTES, DESLIGUE A JIGA E REINICIE O TESTE')
break
time.sleep(30) # Alterar para 2 min
if serial[0] != None:
mod_result1[0].append(self.FBP.Read_iMod1())
self.update_gui.emit(' corrente de saída do módulo 1: ' + str(mod_result1[0][load_current.index(set_current)]))
time.sleep(0.1)
mod_result2[0].append(self.FBP.Read_vOutMod1())
self.update_gui.emit(' tensão de saída do módulo 1: ' + str(mod_result2[0][load_current.index(set_current)]))
time.sleep(0.1)
mod_result3[0].append(self.FBP.Read_temp1())
self.update_gui.emit(' temperatura do módulo 1: ' + str(mod_result3[0][load_current.index(set_current)]))
time.sleep(0.1)
mod_result4[0].append(self.FBP.Read_vDCMod1())
self.update_gui.emit(' tensão de entrada do módulo 1: ' + str(mod_result4[0][load_current.index(set_current)]))
time.sleep(0.1)
self.update_gui.emit('')
if serial[1] != None:
mod_result1[1].append(self.FBP.Read_iMod2())
self.update_gui.emit(' corrente de saída do módulo 2: ' + str(mod_result1[1][load_current.index(set_current)]))
time.sleep(0.1)
mod_result2[1].append(self.FBP.Read_vOutMod2())
self.update_gui.emit(' tensão de saída do módulo 2: ' + str(mod_result2[1][load_current.index(set_current)]))
time.sleep(0.1)
mod_result3[1].append(self.FBP.Read_temp2())
self.update_gui.emit(' temperatura do módulo 2: ' + str(mod_result3[1][load_current.index(set_current)]))
time.sleep(0.1)
mod_result4[1].append(self.FBP.Read_vDCMod2())
self.update_gui.emit(' tensão de entrada do módulo 2: ' + str(mod_result4[1][load_current.index(set_current)]))
time.sleep(0.1)
self.update_gui.emit('')
if serial[2] != None:
mod_result1[2].append(self.FBP.Read_iMod3())
self.update_gui.emit(' corrente de saída do módulo 3: ' + str(mod_result1[2][load_current.index(set_current)]))
time.sleep(0.1)
mod_result2[2].append(self.FBP.Read_vOutMod3())
self.update_gui.emit(' tensão de saída do módulo 3: ' + str(mod_result2[2][load_current.index(set_current)]))
time.sleep(0.1)
mod_result3[2].append(self.FBP.Read_temp3())
self.update_gui.emit(' temperatura do módulo 3: ' + str(mod_result3[2][load_current.index(set_current)]))
time.sleep(0.1)
mod_result4[2].append(self.FBP.Read_vDCMod3())
self.update_gui.emit(' tensão de entrada do módulo 3: ' + str(mod_result4[2][load_current.index(set_current)]))
time.sleep(0.1)
self.update_gui.emit('')
if serial[3] != None:
mod_result1[3].append(self.FBP.Read_iMod4())
self.update_gui.emit(' corrente de saída do módulo 4: ' + str(mod_result1[3][load_current.index(set_current)]))
time.sleep(0.1)
mod_result2[3].append(self.FBP.Read_vOutMod4())
self.update_gui.emit(' tensão de saída do módulo 4: ' + str(mod_result2[3][load_current.index(set_current)]))
time.sleep(0.1)
mod_result3[3].append(self.FBP.Read_temp4())
self.update_gui.emit(' temperatura do módulo 4: ' + str(mod_result3[3][load_current.index(set_current)]))
time.sleep(0.1)
mod_result4[3].append(self.FBP.Read_vDCMod4())
self.update_gui.emit(' tensão de entrada do módulo 4: ' + str(mod_result4[3][load_current.index(set_current)]))
time.sleep(0.1)
self.update_gui.emit('')
self.FBP.TurnOff(sum_mod)
'''###############################################################################'''
'''###############################################################################'''
for item in serial:
if item is not None:
power_module = PowerModule()
power_module.serial_number = item
res = self._send_to_server(power_module)
test = [True for p in range(4)]
if res:
self.update_gui.emit('')
self.update_gui.emit('Verificando resultados do modulo '\
+ str(serial.index(item)+1) + '...')
log = PowerModuleLog()
log.serial_number_power_module = item
# TODO: Faz os testes e seta os atributos de log
for q in range(0, len(mod_result1[serial.index(item)])):
if round(mod_result1[serial.index(item)][q]) == \
compare_current[q]:
if test[0]:
test[0] = True
else:
test[0] = False
if test[0]:
self.update_gui.emit(' Aprovado no teste de corrente de saída')
else:
self.update_gui.emit(' Reprovado no teste de corrente de saída')
if round(mod_result2[serial.index(item)][0]) == 0 and \
round(mod_result2[serial.index(item)][1]) == 0 and \
2 < mod_result2[serial.index(item)][2] < 3.5 and \
5 < mod_result2[serial.index(item)][3] < 6 and \
-6 < mod_result2[serial.index(item)][4] < -5 and \
-3.5 < mod_result2[serial.index(item)][5] < -2:
test[1] = True
else:
test[1] = False
if test[1]:
self.update_gui.emit(' Aprovado no teste de tensão de saída')
else:
self.update_gui.emit(' Reprovado no teste de tensão de saída')
for r in range(0, len(mod_result3[serial.index(item)])):
if mod_result3[serial.index(item)][r] < 90:
if test[2]:
test[2] = True
else:
test[2] = False
if test[2]:
self.update_gui.emit(' Aprovado no teste de leitura da temperatura')
else:
self.update_gui.emit(' Reprovado no teste de leitura da temperatura')
for s in range(0, len(mod_result4[serial.index(item)])):
if round(mod_result4[serial.index(item)][s]) == 15:
if test[3]:
test[3] = True
else:
test[3] = False
if test[3]:
self.update_gui.emit(' Aprovado no teste de leitura da tensão de entrada')
else:
self.update_gui.emit(' Reprovado no teste de leitura da tensão de entrada')
if test == [True for t in range(4)]:
log.test_result = 'Aprovado'
response[serial.index(item)] = True
else:
log.test_result = 'Reprovado'
response[serial.index(item)] = False
log.iload0 = mod_result1[serial.index(item)][0]
log.iload1 = mod_result1[serial.index(item)][1]
log.iload2 = mod_result1[serial.index(item)][2]
log.iload3 = mod_result1[serial.index(item)][3]
log.iload4 = mod_result1[serial.index(item)][4]
log.iload5 = mod_result1[serial.index(item)][5]
log.vload0 = mod_result2[serial.index(item)][0]
log.vload1 = mod_result2[serial.index(item)][1]
log.vload2 = mod_result2[serial.index(item)][2]
log.vload3 = mod_result2[serial.index(item)][3]
log.vload4 = mod_result2[serial.index(item)][4]
log.vload5 = mod_result2[serial.index(item)][5]
log.vdclink0 = mod_result4[serial.index(item)][0]
log.vdclink1 = mod_result4[serial.index(item)][1]
log.vdclink2 = mod_result4[serial.index(item)][2]
log.vdclink3 = mod_result4[serial.index(item)][3]
log.vdclink4 = mod_result4[serial.index(item)][4]
log.vdclink5 = mod_result4[serial.index(item)][5]
log.temperatura0 = mod_result3[serial.index(item)][0]
log.temperatura1 = mod_result3[serial.index(item)][1]
log.temperatura2 = mod_result3[serial.index(item)][2]
log.temperatura3 = mod_result3[serial.index(item)][3]
log.temperatura4 = mod_result3[serial.index(item)][4]
log.temperatura5 = mod_result3[serial.index(item)][5]
log.details = 'SoftInterlocks ativos: ' + str(self.FBP.Read_ps_SoftInterlocks()) + \
' HardInterlocks ativos: ' + str(self.FBP.Read_ps_HardInterlocks())
print(log.data)
self.update_gui.emit('modulo ' + str(serial.index(item)+1)\
+ ' ' + log.test_result)
log_res = self._send_to_server(log)
self._active_interlocks = ''
#response[serial.index(item)] = log_res
# Quando o teste terminar emitir o resultado em uma lista de objetos
# do tipo PowerModuleLog
self.test_complete.emit(response)
self.update_gui.emit('')
self.update_gui.emit('Interlocks Ativos:')
for softinterlock in self._read_SoftInterlock(self.FBP.Read_ps_SoftInterlocks()):
self.update_gui.emit(softinterlock)
for hardinterlock in self._read_HardInterlock(self.FBP.Read_ps_HardInterlocks()):
self.update_gui.emit(hardinterlock)
print('--------------------------------------------\n')
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
print(client_data)
client_method = item.method
client_response = client.do_request(client_method, client_data)
print(client_response)
server_status = self._parse_response(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def run(self):
self._test_sequence()
#pass
def _read_SoftInterlock(self, int_interlock):
SoftInterlockList = ['N/A', 'Sobre-tensão na carga 1', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensão na carga 2', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensão na carga 3', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A',\
'Sobre-tensão na carga 4', 'N/A', \
'N/A', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A']
op_bin = 1
ActiveSoftInterlocks = []
for i in range(len('{0:b}'.format(int_interlock))):
if (int_interlock & (op_bin << i)) == 2**i:
ActiveSoftInterlocks.append(SoftInterlockList[i])
return ActiveSoftInterlocks
def _read_HardInterlock(self, int_interlock):
HardInterlockList = ['Sobre-corrente na carga 1', 'N/A', \
'Sobre-tensão no DC-Link do módulo 1', \
'Sub-tensão no DC-Link do módulo 1', \
'Falha no relé de entrada do DC-Link do módulo 1', \
'Falha no fusível de entrada do DC-Link do módulo 1', \
'Falha nos drivers do módulo 1', \
'Sobre-temperatura no módulo 1', \
'Sobre-corrente na carga 2', 'N/A', \
'Sobre-tensão no DC-Link do módulo 2', \
'Sub-tensão no DC-Link do módulo 2', \
'Falha no relé de entrada do DC-Link do módulo 2', \
'Falha no fusível de entrada do DC-Link do módulo 2', \
'Falha nos drivers do módulo 2', \
'Sobre-temperatura no módulo 2', \
'Sobre-corrente na carga 3', 'N\A', \
'Sobre-tensão no DC-Link do módulo 3', \
'Sub-tensão no DC-Link do módulo 3', \
'Falha no relé de entrada no DC-Link do módulo 3', \
'Falha no fusível de entrada do DC-Link do módulo 3', \
'Falha nos drivers do módulo 3', \
'Sobre-temperatura no módulo 3', \
'Sobre-corrente na carga 4', 'N/A', \
'Sobre-tensão no DC-Link do módulo 4', \
'Sub-tensão no DC-Link do módulo 4', \
'Falha no relé de entrada do DC-Link do módulo 4', \
'Falha no fusível de entrada do DC-Link do módulo 4', \
'Falha nos drivers do módulo 4', \
'Sobre-temperatura no módulo 4']
op_bin = 1
ActiveHardInterlocks = []
for i in range(len('{0:b}'.format(int_interlock))):
if (int_interlock & (op_bin << i)) == 2**i:
ActiveHardInterlocks.append(HardInterlockList[i])
return ActiveHardInterlocks
from common.pydrs import SerialDRS
from datetime import datetime
import time
drs = SerialDRS()
now = datetime.now()
drs_port = 'COM11'
BastidorList = ['1041182343', '1041182349']
module_list = ['modulo 1', 'modulo 2', 'modulo 3', 'modulo 4']
PS_List = [1, 2, 3, 4]
SetTestList = [10, 0, -10]
SetCurrentList = [0, 10, 0, -10, 0]
WarmUpTime = 2 * 3600
StepTime = 60
# o teste dura 50 horas (em média) com um WarmUpTime de 2 horas e um StepTime de 60 min
print(str(now.day) + ',' + str(now.hour) + ':' + str(now.minute))
for bastidor in BastidorList:
print('\nConfigurando DRS e ligando módulos de potência do bastidor NS.:' +
str(bastidor) + '...\n')
drs.Connect(drs_port)
time.sleep(1)
drs.SetSlaveAdd(BastidorList.index(bastidor) + 1)
time.sleep(1)
drs.Config_nHRADC(4)
from common.pydrs import SerialDRS
from datetime import datetime
import time
import visa
# Arquivo de configuração
import crosstalk_config as conf
drs = SerialDRS()
now = datetime.now()
# https://www.topster.pt/texto-para-ascii/doom.html
print(' _____ ______ _ _ ______ _____ _____ _ ______ ')
print('| __ \| ___ \| | | || ___ )| _ | | ___|| | | ___ )')
print('| | \/| |_/ /| | | || |_/ /| | | | | |__ | | | |_/ /')
print('| | __ | / | | | || __/ | | | | | __| | | | __/ ')
print('| |_\ \| |\ \ | |_| || | \ \_/ / | |___ | |____| | ')
print(' \____/\_| \_| \___/ \_| \___/ \____/ \_____/\_| ')
time.sleep(3)
print(
' _____ _____ _ _ _ '
)
print(
'/ __ \ |_ _| | || | (_) '
)
print(
'| / \/ _ __ ___ ___ ___ ______ | | __ _ | || | __ _ _ __ __ _ '
)
from common.pydrs import SerialDRS
from DSOX_3024A import DSOX_3024A_USB
import time
drs = SerialDRS()
dso = DSOX_3024A_USB()
################################################################################
####################### LENDO ARQUIVO DE CONFIGURAÇÃO ##########################
################################################################################
_cfile = open('rippletest_config.csv', 'r')
config = _cfile.read()
_cfile.close()
config = config.split(';')
for i in config:
config[config.index(i)] = config[config.index(i)].split('|')
for j in config:
if config[config.index(j)][0] == 'COMPort':
drs_port = config[config.index(j)][1]
drs_port = drs_port.replace('\n', '')
drs_port = drs_port.split(',')
if len(drs_port) == 1:
drs_port = drs_port[0]
elif config[config.index(j)][0] == 'UdcAddr':
drs_addr = config[config.index(j)][1]
drs_addr = drs_addr.replace('\n', '')
class UDCTest(QThread):
DISAPPROVED = "Falha"
APPROVED = "OK"
START_TEST = 0
READ_RESULT = 1
SUCESS = 0
FAIL = 1
SLEEP_TIME = 1
test_complete = pyqtSignal(bool)
update_gui = pyqtSignal(str)
connection_lost = pyqtSignal()
send_partial_complete = pyqtSignal()
buzzer_signal = pyqtSignal(str)
led_signal = pyqtSignal(str)
eeprom = pyqtSignal(str)
flash = pyqtSignal(str)
ram = pyqtSignal(str)
adc = pyqtSignal(list)
rtc = pyqtSignal(str)
sensor_temp = pyqtSignal(str)
rs485 = pyqtSignal(str)
isol_plane = pyqtSignal(str)
io_expander = pyqtSignal(str)
ethernet_ping = pyqtSignal(str)
loopback = pyqtSignal(str)
def __init__(self, comport=None, baudrate=None, serial_number=None):
QThread.__init__(self)
self._comport = comport
self._baudarate = baudrate
self._serial_number = serial_number
self._led = None
self._buzzer = None
self._details = ""
self._loopback_fail = "\n"
self._index_res_ok = 3
self._send_partial_data = False
self._udc = SerialDRS()
@property
def send_partial_data(self):
return self._send_partial_data
@send_partial_data.setter
def send_partial_data(self, value):
self._send_partial_data = value
@property
def serial_number(self):
return self._serial_number
@serial_number.setter
def serial_number(self, value):
self._serial_number = value
@property
def led(self):
return self._led
@led.setter
def led(self, value):
self._led = value
@property
def buzzer(self):
return self._buzzer
@buzzer.setter
def buzzer(self, value):
self._buzzer = value
@property
def details(self):
return self._details
@details.setter
def details(self, value):
self._details = value
@property
def comport(self):
return self._comport
@comport.setter
def comport(self, value):
self._comport = value
@property
def baudrate(self):
return self._baudarate
@baudrate.setter
def baudrate(self, value):
self._baudrate = value
def open_serial_port(self):
if self._comport is None or self._baudrate is None:
return False
else:
return self._udc.Connect(self._comport, self._baudrate)
def close_serial_port(self):
if self._udc.is_open():
self._udc.Disconnect()
def test_communication(self):
time.sleep(0.2)
res = self._udc.UdcComTest(self.START_TEST, self.START_TEST)
print("Retorno teste com")
print(res)
if len(res) > 0:
if res[3] is self.START_TEST:
return True
else:
return False
else:
return False
def test_led(self):
self.update_gui.emit("Testando Leds...")
self._udc.UdcLedTest(self.START_TEST)
self.update_gui.emit("Leds Testados")
def test_buzzer(self):
self.update_gui.emit("Testando Buzzer...")
self._udc.UdcBuzzerTest(self.START_TEST)
self.update_gui.emit("Buzzer Testado")
def _test_eeprom(self):
self.update_gui.emit("Testando EEPROM...")
serial_str_list = list(str(self._serial_number))
serial_int_list = []
for item in serial_str_list:
serial_int_list.append(int(item))
result = self.DISAPPROVED
self._udc.UdcEepromTest(self.START_TEST, serial_int_list)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcEepromTest(self.READ_RESULT, serial_int_list)
print("Retorno Eeprom")
print(response)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.eeprom.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_flash(self):
self.update_gui.emit("Testando Flash...")
result = self.DISAPPROVED
self._udc.UdcFlashTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcFlashTest(self.READ_RESULT)
print("Retorno Flash")
print(response)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.flash.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_ram(self):
self.update_gui.emit("Testando RAM...")
result = self.DISAPPROVED
self._udc.UdcRamTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcRamTest(self.READ_RESULT)
print("Retorno Ram")
print(response)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.ram.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_adc(self):
result = [self.DISAPPROVED for i in range(8)]
result_bool = [False for i in range(8)]
for i in range(1, 9):
self.update_gui.emit("Testando ADC Canal " + str(i))
self._udc.UdcAdcTest(self.START_TEST, i)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcAdcTest(self.READ_RESULT, i)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result[i - 1] = self.APPROVED
else:
result[i - 1] = self.DISAPPROVED
else:
result[i - 1] = self.DISAPPROVED
self.update_gui.emit(result[i - 1])
self.adc.emit(result)
for i in range(8):
if result[i] is self.APPROVED:
result_bool[i] = True
return result_bool
def _test_rtc(self):
self.update_gui.emit("Testando RTC...")
result = self.DISAPPROVED
self._udc.UdcRtcTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcRtcTest(self.READ_RESULT)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.rtc.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_temperature_sensor(self):
self.update_gui.emit("Testando Sensor de Temperatura...")
result = self.DISAPPROVED
self._udc.UdcSensorTempTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcSensorTempTest(self.READ_RESULT)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.sensor_temp.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_rs485(self):
self.update_gui.emit("Testando UART/RS485...")
result = self.DISAPPROVED
self._udc.UdcUartTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcUartTest(self.READ_RESULT)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.rs485.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_alim_isol_plane(self):
self.update_gui.emit("Testando Alimentação Plano Isolado...")
result = self.DISAPPROVED
self._udc.UdcIsoPlaneTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcIsoPlaneTest(self.READ_RESULT)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.isol_plane.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_io_expander(self):
self.update_gui.emit("Testando Expansor de I/O...")
result = self.DISAPPROVED
self._udc.UdcIoExpanderTest(self.START_TEST)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcIoExpanderTest(self.READ_RESULT)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result = self.APPROVED
else:
result = self.DISAPPROVED
else:
result = self.DISAPPROVED
self.io_expander.emit(result)
self.update_gui.emit(result)
return (result is self.APPROVED)
def _test_ethernet_ping(self):
self.update_gui.emit("Testando Ping Ethernet...")
host = "192.168.1.4"
if platform.system().lower() == "windows":
ping_str = "-n 1"
else:
ping_str = "-c 1"
resposta = os.system("ping " + ping_str + " " + host)
if resposta is 0:
self.ethernet_ping.emit(self.APPROVED)
self.update_gui.emit(self.APPROVED)
return True
else:
self.ethernet_ping.emit(self.DISAPPROVED)
self.update_gui.emit(self.DISAPPROVED)
return False
def _test_periph_loopback(self):
self._loopback_fail = "\t"
self.update_gui.emit("Testando Loopbacks...")
result = self.DISAPPROVED
result_bool = [False for i in range(32)]
for i in range(1, 33):
self.update_gui.emit("Testando Loopback canal " + str(i))
self._udc.UdcLoopBackTest(self.START_TEST, i)
time.sleep(self.SLEEP_TIME)
response = self._udc.UdcLoopBackTest(self.READ_RESULT, i)
if (response is not None) and (len(response) > 3):
if response[self._index_res_ok] is self.SUCESS:
result_bool[i - 1] = True
self.update_gui.emit(self.APPROVED)
else:
result_bool[i - 1] = False
self._loopback_fail += "Erro Canal " + str(i) + '\t'
self.update_gui.emit(self.DISAPPROVED)
else:
result_bool[i - 1] = False
self._loopback_fail += "Erro Canal " + str(i) + '\t'
self.update_gui.emit(self.DISAPPROVED)
if False in result_bool:
result = self.DISAPPROVED
else:
result = self.APPROVED
self.loopback.emit(result)
return (result is self.APPROVED)
def _test_sequence(self):
result = False
self.update_gui.emit("Iniciando Testes...")
test_res_io_expander = self._test_io_expander()
test_res_eeprom = self._test_eeprom()
test_res_flash = self._test_flash()
test_res_ram = self._test_ram()
test_res_rtc = self._test_rtc()
test_res_temp = self._test_temperature_sensor()
test_res_isol_plane = self._test_alim_isol_plane()
test_res_adc = self._test_adc()
test_res_uart = self._test_rs485()
test_res_loopback = self._test_periph_loopback()
test_res_ethern_ping = self._test_ethernet_ping()
udc = UDC()
udc.serial_number = self._serial_number
self.update_gui.emit("Cadastrando UDC no Servidor...")
res = self._send_to_server(udc)
if res:
self.update_gui.emit("UDC Cadastrado com Sucesso!")
log = UDCLog()
log.serial_number_udc = self._serial_number
if test_res_io_expander:
log.io_expander = self.APPROVED
else:
log.io_expander = self.DISAPPROVED
if self._led:
log.leds = self.APPROVED
else:
log.leds = self.DISAPPROVED
if self._buzzer:
log.buzzer = self.APPROVED
else:
log.buzzer = self.DISAPPROVED
if test_res_eeprom:
log.eeprom = self.APPROVED
else:
log.eeprom = self.DISAPPROVED
if test_res_flash:
log.flash = self.APPROVED
else:
log.flash = self.DISAPPROVED
if test_res_ram:
log.ram = self.APPROVED
else:
log.ram = self.DISAPPROVED
if test_res_rtc:
log.rtc = self.APPROVED
else:
log.rtc = self.DISAPPROVED
if test_res_uart:
log.uart = self.APPROVED
else:
log.uart = self.DISAPPROVED
if test_res_temp:
log.temperature_sensor = self.APPROVED
else:
log.temperature_sensor = self.DISAPPROVED
if test_res_isol_plane:
log.control_aliment_isol_plane = self.APPROVED
else:
log.control_aliment_isol_plane = self.DISAPPROVED
if test_res_ethern_ping:
log.ethernet_ping = self.APPROVED
else:
log.ethernet_ping = self.DISAPPROVED
if test_res_adc[0]:
log.adc_ch_1 = self.APPROVED
else:
log.adc_ch_1 = self.DISAPPROVED
if test_res_adc[1]:
log.adc_ch_2 = self.APPROVED
else:
log.adc_ch_2 = self.DISAPPROVED
if test_res_adc[2]:
log.adc_ch_3 = self.APPROVED
else:
log.adc_ch_3 = self.DISAPPROVED
if test_res_adc[3]:
log.adc_ch_4 = self.APPROVED
else:
log.adc_ch_4 = self.DISAPPROVED
if test_res_adc[4]:
log.adc_ch_5 = self.APPROVED
else:
log.adc_ch_5 = self.DISAPPROVED
if test_res_adc[5]:
log.adc_ch_6 = self.APPROVED
else:
log.adc_ch_6 = self.DISAPPROVED
if test_res_adc[6]:
log.adc_ch_7 = self.APPROVED
else:
log.adc_ch_7 = self.DISAPPROVED
if test_res_adc[7]:
log.adc_ch_8 = self.APPROVED
else:
log.adc_ch_8 = self.DISAPPROVED
if test_res_loopback:
log.loopback = self.APPROVED
else:
log.loopback = self.DISAPPROVED + self._loopback_fail
if test_res_io_expander and self._led and self._buzzer and \
test_res_eeprom and test_res_flash and test_res_ram and \
test_res_rtc and test_res_temp and test_res_isol_plane and \
test_res_adc and test_res_uart and test_res_loopback and \
test_res_ethern_ping and \
test_res_adc[0] and test_res_adc[1] and test_res_adc[2] and \
test_res_adc[3] and test_res_adc[4] and test_res_adc[5] and \
test_res_adc[6] and test_res_adc[7]:
log.test_result = 'Aprovado'
result = True
else:
log.test_result = 'Reprovado'
result = False
self.update_gui.emit("Enviando dados de teste...")
server_response = self._send_to_server(log)
if server_response:
self.update_gui.emit("Dados Enviados com Sucesso!")
else:
self.update_gui.emit("Erro ao enviar dados")
self.test_complete.emit(result)
else:
self.update_gui.emit("Erro ao Cadastrar UDC no servidor!")
def _send_partial(self):
udc = UDC()
udc.serial_number = self._serial_number
log = UDCLog()
log.serial_number_udc = self._serial_number
log.test_result = 'Reprovado'
log.details = self._details
res = self._send_to_server(udc)
if res:
self._send_to_server(log)
self.send_partial_complete.emit()
def _send_to_server(self, item):
client = ElpWebClient()
client_data = item.data
client_method = item.method
client_response = client.do_request(client_method, client_data)
server_status = self._parse_response(client_response)
return server_status
def _parse_response(self, response):
res_key = 'StatusCode'
err_key = 'error'
if res_key in response.keys() and err_key not in response.keys():
return True
else:
return False
def run(self):
if self._send_partial_data:
self._send_partial()
else:
self._test_sequence()
self._udc.Disconnect()
