def upgrade_config(DLGID_CTRL,LIST_CONFIG):
'''
actualiza en gda las variables de dconfiguracion
'''
FUNCTION_NAME = 'UPGRADE_CONFIG'
## INSTANCIAS
logs = ctrl_logs(False,'servAppSelection',DLGID_CTRL,print_log)
# FUNCTIONS
def printConfigVars(LIST_CONFIG):
n = 4
for param in LIST_CONFIG:
if n < (len(LIST_CONFIG)):
logs.print_in(FUNCTION_NAME,LIST_CONFIG[n],LIST_CONFIG[n+1])
n += 2
def saveConfigVars(LIST_CONFIG):
logs.print_inf(FUNCTION_NAME, 'ACTUALIZO CONFIG EN GDA' )
n = 4
for param in LIST_CONFIG:
if n < (len(LIST_CONFIG)):
gda.InsertAutConf(DLGID_CTRL,LIST_CONFIG[n],LIST_CONFIG[n+1]) # escritura de valores en dbGda
n += 2
# MAIN
# imprimo en pantalla las variables de configuracion
printConfigVars(LIST_CONFIG)
# eliminto todas las variables de configuracion anteriores
#gda.DeleteAllAutConf(DLGID_CTRL)
# escribo nuevamente toda la configuracion en GDA
saveConfigVars(LIST_CONFIG)
def upgrade_config(DLGID, LIST_CONFIG):
''''''
FUNCTION_NAME = 'UPGRADE_CONFIG'
#
## INSTANCIAS
logs = ctrl_logs(False, 'servErrorAppSelection', DLGID, print_log)
#
# IMPRIMIR VARIABLES DE CONFIGURACION
n = 4
for param in LIST_CONFIG:
if n < (len(LIST_CONFIG)):
logs.print_in(FUNCTION_NAME, LIST_CONFIG[n], LIST_CONFIG[n + 1])
n += 2
#
## ELIMINO LAS VARIABLES DE CONFIGURACION ANTERIORES
if redis.hexist(f'{DLGID}_ERROR', 'TAG_CONFIG'):
#if gda.readAutConf(f'{DLGID}_ERROR','TAG_CONFIG'):
last_TAG_CONFIG = redis.hget(f'{DLGID}_ERROR', 'TAG_CONFIG')
#last_TAG_CONFIG = gda.readAutConf(f'{DLGID}_ERROR','TAG_CONFIG')
#
for param in last_TAG_CONFIG.split(','):
redis.hdel(f'{DLGID}_ERROR', param)
#
redis.hdel(f'{DLGID}_ERROR', 'TAG_CONFIG')
# ESCRIBO EN REDIS LAS VARIABLES DE CONFIGURACION
logs.print_inf(FUNCTION_NAME, 'ACTUALIZO CONFIG EN REDIS')
TAG_CONFIG = []
n = 4
for param in LIST_CONFIG:
if n < (len(LIST_CONFIG)):
redis.hset(f'{DLGID}_ERROR', LIST_CONFIG[n], LIST_CONFIG[n + 1])
#gda.WriteAutConf(f'{DLGID}_ERROR',LIST_CONFIG[n],LIST_CONFIG[n+1])
TAG_CONFIG.append(LIST_CONFIG[n])
n += 2
#
# ESCRIBO EN REDIS EL NOMBRE DE LAS VARIABLES DE CONFIGURACION PARA QUE PUEDAN SER LEIDAS
redis.hset(f'{DLGID}_ERROR', 'TAG_CONFIG', lst2str(TAG_CONFIG))
#gda.WriteAutConf(f'{DLGID}_ERROR','TAG_CONFIG',lst2str(TAG_CONFIG))
# LEO VARIABLES ESCRITAS
n = 4
check_config = []
for param in LIST_CONFIG:
if n < (len(LIST_CONFIG)):
check_config.append(LIST_CONFIG[n])
check_config.append(redis.hget(f'{DLGID}_ERROR', LIST_CONFIG[n]))
#check_config.append(gda.readAutConf(f'{DLGID}_ERROR',LIST_CONFIG[n]))
n += 2
#
# MUESTRO VARIABLES LEIDAS
n = 0
for param in check_config:
if n < (len(check_config)):
logs.print_out(FUNCTION_NAME, check_config[n], check_config[n + 1])
n += 2
def show_var_list(lst):
# instancio los logs con la informacion del LOG_LEVEL
LOG_LEVEL = config_var(lst).lst_get('LOG_LEVEL')
logs = ctrl_logs(False,'servAppSelection',DLGID_CTRL,print_log,LOG_LEVEL)
n = 0
for param in lst:
if n < (len(lst)):
logs.print_out(name_function,lst[n],lst[n+1])
n += 2
def show_var_list(lst):
LOG_LEVEL = config_var(LIST_CONFIG).lst_get('LOG_LEVEL')
logs = ctrl_logs(False, 'servErrorAppSelection', DLGID, print_log,
LOG_LEVEL)
if bool(lst):
n = 0
for param in lst:
if n < (len(lst)):
logs.print_out(name_function, lst[n], lst[n + 1])
n += 2
def read_config_var(DLGID):
''''''
FUNCTION_NAME = 'READ_CONFIG_VAR'
## INSTANCIAS
logs = ctrl_logs(False, 'servErrorAppSelection', DLGID, print_log)
redis = Redis()
#
# LEO LOS TAGS DE CONFIGURACION
if redis.hexist(f'{DLGID}_ERROR', 'TAG_CONFIG'):
#if gda.readAutConf(f'{DLGID}_ERROR','TAG_CONFIG'):
TAG_CONFIG = redis.hget(f'{DLGID}_ERROR', 'TAG_CONFIG')
#TAG_CONFIG = gda.readAutConf(f'{DLGID}_ERROR','TAG_CONFIG')
TAG_CONFIG = TAG_CONFIG.split(',')
else:
#logs.print_inf(FUNCTION_NAME,f'NO EXISTE {DLGID}_TAG_CONFIG IN serv_error_APP_selection')
#logs.print_inf(FUNCTION_NAME,'NO SE EJECUTA EL SCRIPT')
return ''
#
# LEO CONFIGURACION DE LA REDIS
#logs.print_inf(FUNCTION_NAME,'LEO CONFIG EN REDIS')
vars_config = []
for param in TAG_CONFIG:
vars_config.append(param)
vars_config.append(redis.hget(f'{DLGID}_ERROR', param))
#vars_config.append(gda.readAutConf(f'{DLGID}_ERROR',param))
#
'''
# MUESTRO VARIABLES LEIDAS
n = 0
for param in vars_config:
if n < (len(vars_config)):
logs.print_out(FUNCTION_NAME,vars_config[n],vars_config[n+1])
n += 2'''
#
# CONCATENO LAS VARIABLES DE EJECUCION Y DE CONFIGURACION
list_out = []
LIST_CONFIG = ['print_log', print_log, 'DLGID', DLGID, 'TYPE', TYPE]
n = 0
for param in LIST_CONFIG:
if n < 4:
list_out.append(LIST_CONFIG[n])
n += 1
for param in vars_config:
list_out.append(param)
return list_out
def control_process(LIST_CONFIG):
''''''
name_function = 'CONTROL_PROCESS'
conf = config_var(LIST_CONFIG)
# VARIABLES DE EJECUCION
DLGID_CTRL = conf.lst_get('DLGID_CTRL')
TYPE = conf.lst_get('TYPE')
print_log = str2bool(conf.lst_get('print_log'))
LOG_LEVEL = conf.lst_get('LOG_LEVEL')
#VARIABLES DE CONFIGURACION
ENABLE_OUTPUTS = str2bool(conf.lst_get('ENABLE_OUTPUTS'))
TYPE_IN_FREC = conf.lst_get('TYPE_IN_FREC')
DLGID_REF = conf.lst_get('DLGID_REF')
CHANNEL_REF = conf.lst_get('CHANNEL_REF')
DLGID_REF_1 = conf.lst_get('DLGID_REF_1')
CHANNEL_REF_1 = conf.lst_get('CHANNEL_REF_1')
## INSTANCIAS
logs = ctrl_logs(TYPE, 'CTRL_FREC_process', DLGID_CTRL, print_log,
LOG_LEVEL)
config = configparser.ConfigParser()
redis = Redis()
#gda = GDA(serv_APP_config['CONFIG']['working_mode'])
redis.no_execution('MER004')
'''
# INSTANCIA DE error_process
import importlib.util
#spec = importlib.util.spec_from_file_location("archivo", f"../{TYPE}/PROCESS/ctrl_library.py")
spec = importlib.util.spec_from_file_location("archivo", f"/datos/cgi-bin/spx/AUTOMATISMOS/{TYPE}/PROCESS/ctrl_library.py")
archivo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(archivo)
p = archivo.ctrl_process(LIST_CONFIG)'''
p = ctrlProcess(LIST_CONFIG)
# OBTENFO LA CARPETA EN DONDE SE ENCUENTRA EL ARCHIVO ACTUAL
current_path = os.path.dirname(os.path.abspath(__file__))
# LEO EL ARCHIVO DE CONFIGURACION
config.read(f"{current_path}/ctrl_config.ini")
#---------------------------------------------------------
##PROCESS
logs.basicLog(__doc__)
# ESCRIBO LA EJECUCION DEL SCRIPT
logs.print_log(f"{name_function}")
#logs.script_performance(f"{name_function}")
# MUESTRO VARIABLES DE ENTRADA
logs.print_in(name_function, 'print_log', print_log)
logs.print_in(name_function, 'DLGID_CTRL', DLGID_CTRL)
logs.print_in(name_function, 'TYPE', TYPE)
logs.print_in(name_function, 'ENABLE_OUTPUTS', ENABLE_OUTPUTS)
logs.print_in(name_function, 'TYPE_IN_FREC', TYPE_IN_FREC)
logs.print_in(name_function, 'DLGID_REF', DLGID_REF)
logs.print_in(name_function, 'CHANNEL_REF', CHANNEL_REF)
logs.print_in(name_function, 'DLGID_REF_1', DLGID_REF_1)
logs.print_in(name_function, 'CHANNEL_REF_1', CHANNEL_REF_1)
# ESCRIBO NUMERO DE EJECUCION
#redis.no_execution(DLGID_CTRL)
# CHEQUEO QUE EXISTAN LOS LINES DEL DATALOGGER DE CONTROL Y EL DE REFERENCIA.
if not (redis.hexist(DLGID_CTRL, 'LINE')):
#logs.script_performance(f'{name_function} ==> NO EXISTE LINE {DLGID_CTRL}')
logs.print_inf(name_function, f'NO EXISTE LINE {DLGID_CTRL}')
logs.print_inf(name_function, 'EJECUCION INTERRUMPIDA')
quit()
if not (redis.hexist(DLGID_REF, 'LINE')):
#logs.script_performance(f'NO EXISTE LINE {DLGID_REF}')
logs.print_inf(name_function, f'NO EXISTE LINE {DLGID_REF}')
logs.print_inf(name_function, 'EJECUCION INTERRUMPIDA')
quit()
#
logs.print_inf(name_function, 'CHEQUEO_ALARMAS')
p.chequeo_alarmas()
#
#logs.print_inf(name_function, 'CHEQUEO_SENSOR')
#p.chequeo_sensor()
#
logs.print_inf(name_function, 'MAIN')
# FUNCION MAIN
name_function = 'MAIN'
# CONDICIONES INICIALES
#
## ACTIVO BANDERA PARA QUE control_error NOTIFIQUE QUE SE ESTA TRABAJANDO CON REFERENCIA_1
redis.hset(DLGID_CTRL, 'flag_work_syst_ref_1', 'NO')
# REVISO SI ESTA TRABAJANDO EN MODO LOCAL EN EL TABLERO
if read_param(DLGID_CTRL, 'LM') == '1':
logs.print_inf(name_function, 'TRABAJO EN MODO LOCAL')
redis.hset(DLGID_CTRL, 'LOCAL_MODE', 'SI')
elif read_param(DLGID_CTRL, 'LM') == '0':
redis.hset(DLGID_CTRL, 'LOCAL_MODE', 'NO') #VISUALIZACION
#
# SI NO EXISTE LA VARIABLE DE SELECCION SW1 LA CREO CON VALOR AUTO
if not (redis.hexist(DLGID_CTRL, dic.get_dic('WEB_MODE', 'name'))):
redis.hset(DLGID_CTRL, dic.get_dic('WEB_MODE', 'name'),
dic.get_dic('WEB_MODE', 'True_value'))
# MUESTRO LOGS DE ADVERTENCIA
logs.print_inf(name_function, 'NO EXISTE LA VARIABLE SW1 EN REDIS')
logs.print_inf(
name_function, 'SE CREA LA VARIABLE CON VALOR [0]'.format(
dic.get_dic('WEB_MODE', 'True_value')))
#logs.script_performance('error in [0] [1] = ,'.format(name_function,dic.get_dic('WEB_MODE', 'name')))
#logs.script_performance('error in [0], SE CREA [1] = [2]'.format(name_function,dic.get_dic('WEB_MODE', 'name'),dic.get_dic('WEB_MODE', 'True_value')))
#
# LEO VAERIABLE WEB_MODE
WEB_MODE = redis.hget(DLGID_CTRL, dic.get_dic('WEB_MODE', 'name'))
# REVISO EL MODO DE TRABAJO WEB
if WEB_MODE == 'REMOTO':
logs.print_inf(name_function, 'TRABAJO EN MODO REMOTO')
p.modo_remoto()
elif WEB_MODE in [
dic.get_dic('WEB_MODE', 'value_1'),
dic.get_dic('WEB_MODE', 'value_1'),
]:
logs.print_inf(name_function,
'TRABAJO EN MODO SISTEMA DE EMERGENCIA')
# REVISO EL ESTADO DE ENABLE_OUTPUTS
if ENABLE_OUTPUTS:
emerg_system(DLGID_CTRL)
else:
logs.print_inf(
name_function,
f"SALIDAS DESCACTIVADAS [ENABLE_OUTPUTS = {ENABLE_OUTPUTS}]"
)
#logs.script_performance(f"{name_function} ==> SALIDAS DESCACTIVADAS [ENABLE_OUTPUTS = {ENABLE_OUTPUTS}]")
elif WEB_MODE == 'AUTO':
logs.print_inf(name_function, 'TRABAJO EN MODO AUTOMATICO')
#
# SI NO EXISTE LA VARIABLE TX_ERROR EN DLGID_REF LA CREO CON VALOR NO
if not (redis.hexist(DLGID_REF, dic.get_dic('TX_ERROR', 'name'))):
redis.hset(DLGID_REF, dic.get_dic('TX_ERROR', 'name'),
dic.get_dic('TX_ERROR', 'False_value'))
#
# LEO MAG_REF SELECCIONADA POR EL CLIENTE. SI NO EXISTE LMIN LO CREO CON VALOR 1
if not (redis.hexist(DLGID_CTRL, dic.get_dic('MAG_REF', 'name'))):
redis.hset(DLGID_CTRL, dic.get_dic('MAG_REF', 'name'),
dic.get_dic('MAG_REF', 'True_value'))
else:
MAG_REF = float(
redis.hget(DLGID_CTRL, dic.get_dic('MAG_REF', 'name')))
# LEO TX_ERROR Y # error_1min
TX_ERROR = redis.hget(DLGID_REF, dic.get_dic('TX_ERROR', 'name'))
error_1min = redis.hget(DLGID_REF, 'error_1min')
# CHEQUEO ERROR TX EN EL DLG DE REFERENCIA (SE DECLARA ERROR_TX CUANDO PASAN 10 MIN SIN TRANSMITIR)
if TX_ERROR == 'SI':
logs.print_inf(
name_function,
f'ERROR TX EN SISTEMA DE REFERENCIA [ {DLGID_REF} ]')
#logs.print_inf(name_function, 'AUTOMATISMO TRABAJADO CON SISTEMA DE EMERGENCIA')
#
# CHEQUEO QUE SE HAYA ESCRITO LA DIFERENCIA EN MAGNITUD ENTRE LOS SENSORES
if redis.hexist(DLGID_CTRL, 'delta_ref1_ref'):
#
# LEO LA DIFERENCIA ENTRE LAS MAGNITUDES DE REFERENCIA
delta_ref1_ref = float(
redis.hget(DLGID_CTRL, 'delta_ref1_ref'))
#
# CHEQUEO EL ESTADO DEL SENSOR DE REFERENCIA 1
if not (p.chequeo_sensor(DLGID_REF_1, CHANNEL_REF_1)):
logs.print_inf(
name_function,
'ERROR DE SENSOR EN SISTEMA DE REFERENCIA 1')
logs.print_inf(
name_function,
'AUTOMATISMO TRABAJADO CON SISTEMA DE EMERGENCIA')
emerg_system(DLGID_CTRL)
else:
logs.print_inf(
name_function,
'AUTOMATISMO TRABAJADO CON SISTEMA DE REFERENCIA 1'
)
#
# ACTIVO BANDERA PARA QUE control_error NOTIFIQUE QUE SE ESTA TRABAJANDO CON REFERENCIA_1
redis.hset(DLGID_CTRL, 'flag_work_syst_ref_1', 'SI')
#
# LLAMO AL CONTROL DEL SISTEMA
p.control_sistema(DLGID_REF_1, CHANNEL_REF_1,
MAG_REF + delta_ref1_ref)
#
else:
logs.print_inf(
name_function,
'AUTOMATISMO TRABAJADO CON SISTEMA DE EMERGENCIA')
emerg_system(DLGID_CTRL)
elif TX_ERROR == 'NO':
# ME ASEGURO QUE LA REFENCIA ME HAYA MANDADO UN DATO NUEVO
if error_1min == 'NO':
# CHEQUEO ERROR EN EL SENSOR
if not (p.chequeo_sensor(DLGID_REF, CHANNEL_REF)):
logs.print_inf(
name_function,
'ERROR DE SENSOR EN SISTEMA DE REFERENCIA')
logs.print_inf(
name_function,
'AUTOMATISMO TRABAJADO CON SISTEMA DE EMERGENCIA')
#
emerg_system(DLGID_CTRL)
else:
logs.print_inf(name_function, 'CONTROL_SISTEMA')
p.control_sistema(DLGID_REF, CHANNEL_REF, MAG_REF)
#
logs.print_inf(name_function, 'DELTA_MAG')
p.delta_mag()
else:
logs.print_inf(name_function,
'EN ESPERA DE DATOS DE LA REFERENCIA')
else:
logs.print_inf(
name_function, "error in [0], [1] = [2]".format(
name_function, dic.get_dic('TX_ERROR', 'name'),
TX_ERROR))
# DEJAR REGISTRO DEL ERROR
#logs.script_performance("error in [0], [1] = [2]".format(name_function,dic.get_dic('TX_ERROR', 'name'),TX_ERROR))
#
else:
logs.print_inf(
name_function, 'error in [0], [1] = [2]'.format(
name_function, dic.get_dic('WEB_MODE', 'name'), WEB_MODE))
# DEJAR REGISTRO DEL ERROR
#logs.script_performance('error in [0], [1] = [2]'.format(name_function,dic.get_dic('WEB_MODE', 'name'),WEB_MODE))
else:
logs.print_inf(
name_function,
f"error in {name_function}, LM = {read_param(DLGID_CTRL,'LM')}")
logs.print_inf(name_function, 'EJECUCION INTERRUMPIDA')
# DEJAR REGISTRO DEL ERROR
#logs.script_performance(f"error in {name_function}, LM = {read_param(DLGID_CTRL,'LM')}")
# LATCHEO LAS SALIDAS
p.latch__outpust(DLGID_CTRL)
# PREPARO DATA_DATE_TIME PARA MOSTRAR EN LA VISUALIZACION EN EL DATALOGGER DE CONTROL
logs.print_inf(name_function, 'SHOW_DATA_DATE_TIME')
p.show_DATA_DATE_TIME(DLGID_CTRL)
# PREPARO DATA_DATE_TIME PARA MOSTRAR EN LA VISUALIZACION EN EL DATALOGGER DE REFERENCIA
p.show_DATA_DATE_TIME(DLGID_REF)
# PREPARO PUMP1_STATE PARA MOSTRAR EL ESTADO DE LA BOMBA
logs.print_inf(name_function, 'SHOW_PUMP1_STATE')
p.show_pump1_state('BR1')
# MUESTRA LA FRECUENCIA ACTUAL A LA QUE SE ESTA TRABAJANDO
logs.print_inf(name_function, 'SHOW_WORK_FREQUENCY')
p.show_work_frequency()
#
# LIMPIO RESTOS DE CONFIGURACION DE LA REDIS
redis.del_key(f'{dlgid}_ERROR')
#
# IMPRIMO LOG EN CONSOLA
logs.print_inf(name_function,
f'ELIMINO {dlgid} PARA QUE NO SE EJECUTE')
except:
logs.print_inf(name_function, f'{dlgid} YA FUE ELIMINADO')
#----------------------------------------------------------------------------------------
name_function = 'APP_ERROR_SELECTION'
## INSTANCIAS
logs = ctrl_logs(False, 'servErrorAppSelection', DLGID, print_log)
redis = Redis()
n = -1
'''
n = -1 => Estado inicial
'''
while True:
# CHEQUEO SI ESTOY EN ESTADO UNICIAL (PRIMERA CORRIDA)
if n == -1:
if conf.lst_get('DLGID'):
# LLAMADA CON VARIABLES DE CONFIGURACION
## VARIABLES GLOBALES QUE LE ENTRAN A CORE
#logs.print_log(f"EXECUTE: {name_function}")
def error_process(LIST_CONFIG):
name_function = 'ERROR_PROCESS'
conf = config_var(LIST_CONFIG)
#VARIABLES DE EJECUCION
print_log = str2bool(conf.lst_get('print_log'))
DLGID = conf.lst_get('DLGID')
TYPE = conf.lst_get('TYPE')
LOG_LEVEL = conf.lst_get('LOG_LEVEL')
#VARIABLES DE CONFIGURACION
SWITCH_OUTPUTS = str2bool(conf.lst_get('SWITCH_OUTPUTS'))
TEST_OUTPUTS = str2bool(conf.lst_get('TEST_OUTPUTS'))
RESET_ENABLE = str2bool(conf.lst_get('RESET_ENABLE'))
EVENT_DETECTION = str2bool(conf.lst_get('EVENT_DETECTION'))
TIMER_POLL = str2bool(conf.lst_get('TIMER_POLL'))
## INSTANCIAS
#logs = ctrl_logs(TYPE,DLGID,print_log)
logs = ctrl_logs(TYPE, 'CTRL_FREC_error', DLGID, print_log, LOG_LEVEL)
redis = Redis()
#
# INSTANCIA DE error_process
import importlib.util
#spec = importlib.util.spec_from_file_location("archivo", f"../{TYPE}/PROCESS/ctrl_library.py")
spec = importlib.util.spec_from_file_location(
"archivo",
f"/datos/cgi-bin/spx/AUTOMATISMOS/{TYPE}/PROCESS/ctrl_library.py")
archivo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(archivo)
e = archivo.error_process(LIST_CONFIG)
#---------------------------------------------------------
##ERROR PROCESS
#logs.print_log(__doc__)
logs.basicLog(__doc__)
# ESCRIBO LA EJECUCION DEL SCRIPT
logs.print_inf(name_function, '')
# MUESTRO VARIABLES DE ENTRADA
logs.print_in(name_function, 'print_log', print_log)
logs.print_in(name_function, 'DLGID', DLGID)
logs.print_in(name_function, 'TYPE', TYPE)
#
if SWITCH_OUTPUTS:
logs.print_in(name_function, 'SWITCH_OUTPUTS', SWITCH_OUTPUTS)
if SWITCH_OUTPUTS:
logs.print_in(name_function, 'TEST_OUTPUTS', TEST_OUTPUTS)
if SWITCH_OUTPUTS:
logs.print_in(name_function, 'RESET_ENABLE', RESET_ENABLE)
if EVENT_DETECTION:
logs.print_in(name_function, 'EVENT_DETECTION', EVENT_DETECTION)
if EVENT_DETECTION: logs.print_in(name_function, 'TIMER_POLL', TIMER_POLL)
#
# ESCRIBO NUMERO DE EJECUCION
redis.no_execution(f'{DLGID}_ERROR')
# CHEQUEO ERROR TX
logs.print_inf(name_function, 'TEST_TX_ERRORS')
testTxResult = e.test_tx() # chequeo estado de transmision del equipo
if testTxResult != 'noLine':
if testTxResult:
# LLAMAO A FUNCIONES QUE SOLO CORREN CON DATALOGGER 8CH Y SIN ERRORES TX
if dlg_detection(DLGID) == '8CH':
#
# DETECCION DE EVENTOS
logs.print_inf(name_function, 'EVENT_DETECTION')
e.event_detection()
#
# ALTERNO LAS SALIDAS
logs.print_inf(name_function, 'SWITCH_OUTPUTS')
e.switch_outputs()
#
# TESTEO LAS SALIDAS
logs.print_inf(name_function, 'TEST_OUTPUTS')
state_test_outputs = e.test_outputs()
#
# PREPARO VARIABLES DE TIEMPO QUE SE MUESTRAN EN LA VISUALIZACION
logs.print_inf(name_function, 'PUMP1_TIME')
e.pump_time('BR1', 1)
#
elif dlg_detection(DLGID) == '5CH':
# DATALOGGER DE 5CH DETECTADO
#
logs.print_inf(name_function, 'DLG 5CH NO SE DETECTAN EVENTOS')
logs.print_inf(name_function, 'DLG 5CH NO SE ALTERNAN SALIDAS')
else:
# NO SE DETECTA EL TIPO DE DATALOGGER
#
logs.print_inf(name_function,
'NO SE DETECTA EL TIPO DE DATALOGGER')
logs.script_performance(
f'{name_function} => NO SE DETECTA EL TIPO DE DATALOGGER')
else:
logs.print_inf(name_function,
'NO SE DETECTAN EVENTOS POR ERROR TX')
else:
logs.print_inf(name_function, f'NO EXISTE VARIABLE LINE EN {DLGID}')
logs.print_inf(name_function, f'NO SE EJECUTA {name_function}')
#
logs.print_inf(name_function, 'VISUAL')
e.visual()
def control_process(LIST_CONFIG):
''''''
name_function = 'CONTROL_PROCESS'
processName = 'CTRL_PpotPaysandu'
conf = config_var(LIST_CONFIG)
# VARIABLES DE EJECUCION
DLGID_CTRL = conf.lst_get('DLGID_CTRL')
TYPE = conf.lst_get('TYPE')
print_log = str2bool(conf.lst_get('print_log'))
LOG_LEVEL = conf.lst_get('LOG_LEVEL')
#VARIABLES DE CONFIGURACION
ENABLE_OUTPUTS = str2bool(conf.lst_get('ENABLE_OUTPUTS'))
## INSTANCIAS
logs = ctrl_logs(TYPE, 'CTRL_PpotPaysandu', DLGID_CTRL, print_log,
LOG_LEVEL)
redis = Redis()
ctrl = ctrl_process(LIST_CONFIG)
gda = GDA(dbUrl)
#---------------------------------------------------------
## PROCESS ##
# ESCRIBO LA EJECUCION DEL SCRIPT
logs.basicLog(__doc__)
logs.print_log(f"{name_function}")
# MUESTRO VARIABLES DE ENTRADA
logs.print_in(name_function, 'print_log', print_log)
logs.print_in(name_function, 'DLGID_CTRL', DLGID_CTRL)
logs.print_in(name_function, 'TYPE', TYPE)
logs.print_in(name_function, 'ENABLE_OUTPUTS', ENABLE_OUTPUTS)
# CHEQUEO QUE EXISTA EL DATALOGGER DE CONTROL.
if not (redis.hexist(DLGID_CTRL, 'LINE')):
logs.print_inf(name_function, f'NO EXISTE LINE {DLGID_CTRL}')
logs.print_inf(name_function, 'EJECUCION INTERRUMPIDA')
quit()
# Garantizo que las variables que se van a usar en la visualizacion siempre existan
ctrl.setVisualVars()
# Garantizo que las variable de control esten siempre disponibles para el automatismo
ctrl.checkAndSetControlVars()
# Leo las variables de control
WEB_Mode = conf.lst_get('WEB_Mode')
WEB_ActionPump = conf.lst_get('WEB_ActionPump')
WEB_Frequency = int(conf.lst_get('WEB_Frequency'))
SOFT_Mode = ctrl.getAndUpdateMode(
WEB_Mode) # obtengo el modo actual de funcionamiento del sistema
#---------------------------------------------------------
## MAIN DEL FUNCIONAMIETO DEL SISTEMA ##
name_function = 'MAIN'
# muestro logs de las variables de entrada del software
logs.print_in(name_function, 'SOFT_Mode', SOFT_Mode)
logs.print_in(name_function, 'WEB_Mode', WEB_Mode)
logs.print_in(name_function, 'WEB_ActionPump', WEB_ActionPump)
logs.print_in(name_function, 'WEB_Frequency', WEB_Frequency)
# DETECTO MODO DE TRABAJO
if SOFT_Mode == 'EMERGENCIA':
logs.print_inf(name_function, 'TRABAJO EN MODO EMERGENCIA')
redis.hset(DLGID_CTRL, 'PLC_SoftMode', 'EMERGENCIA')
elif SOFT_Mode == 'REMOTO':
logs.print_inf(name_function, 'TRABAJO EN MODO REMOTO')
redis.hset(DLGID_CTRL, 'PLC_SoftMode',
'REMOTO') # guardo variable para la visualizacion web
#
# accion sobre la bomba
if not WEB_ActionPump in ['ON', 'OFF']:
logs.print_error(name_function, 'ACCION NO ADMITIDA')
else:
ctrl.pump(WEB_ActionPump)
#
# seteo de frecuencia si la comunicacion es estable
if WEB_ActionPump == 'ON':
if ctrl.getTxState():
ctrl.setFrequency(WEB_Frequency)
redis.hset(DLGID_CTRL, 'UnstableTx',
'NO') # guardo variable para la visualizacion web
else:
logs.print_inf(
name_function,
'NO SE ACTUALIZA LA FRECUENCIA POR PROBLEMAS TX')
redis.hset(
DLGID_CTRL, 'UnstableTx', 'SI'
) # activo alerta de transmision inestable para la visualizacion web
elif SOFT_Mode == 'LOCAL':
logs.print_inf(name_function,
"TRABAJANDO EN MODO LOCAL DESDE EL TABLERO")
redis.hset(DLGID_CTRL, 'PLC_SoftMode',
'LOCAL') # guardo variable para la visualizacion web
else:
logs.print_error(name_function, 'MODO DE TRABAJO NO ADMITIDO')
# Preparo para la visualizacion web los estados y alarmas del sistema
ctrl.showStatesAndAlarms()
logs.print_inf(name_function, 'ERROR AL CORRER LAS PERFORACIONES EN PERL')
# MAIN ----------------------------------------------------------------------------------------
'''
Las variables que siempren estan disponible para el MAIN son:
print_log = False
DLGID_CTRL = ...
TYPE = 'CHARGE'
LIST_CONFIG = ...
'''
name_function = 'APP_SELECTION'
## INSTANCIAS
logs = ctrl_logs(False,'servAppSelection',DLGID_CTRL,print_log)
redis = Redis()
gda = GDA(dbUrl)
# se ejecuta el process que atiende las automatismos en perl
run_perforation_process(DLGID_CTRL) # mine
# condicion que se cumple cuandos se llama desde el callback
if TYPE == 'CHARGE':
# armo la lista de configuracion para el process
LIST_CONFIG = ['print_log', print_log, 'DLGID_CTRL', DLGID_CTRL] + gda.getAllAutConf(DLGID_CTRL)
# leo el valor de TYPE
def error_process(LIST_CONFIG):
name_function = 'ERROR_PROCESS'
conf = config_var(LIST_CONFIG)
#VARIABLES DE EJECUCION
print_log = str2bool(conf.lst_get('print_log'))
DLGID = conf.lst_get('DLGID')
TYPE = conf.lst_get('TYPE')
LOG_LEVEL = conf.lst_get('LOG_LEVEL')
#VARIABLES DE CONFIGURACION
SWITCH_OUTPUTS = str2bool(conf.lst_get('SWITCH_OUTPUTS'))
TEST_OUTPUTS = str2bool(conf.lst_get('TEST_OUTPUTS'))
RESET_ENABLE = str2bool(conf.lst_get('RESET_ENABLE'))
EVENT_DETECTION = str2bool(conf.lst_get('EVENT_DETECTION'))
TIMER_POLL = str2bool(conf.lst_get('TIMER_POLL'))
## INSTANCIAS
#logs = ctrl_logs(TYPE,DLGID,print_log)
logs = ctrl_logs(TYPE,'CTRL_FREC_error',DLGID,print_log,LOG_LEVEL)
redis = Redis()
e = errorProcess(LIST_CONFIG)
#---------------------------------------------------------
##ERROR PROCESS
logs.basicLog(__doc__)
#logs.print_log(__doc__)
# ESCRIBO LA EJECUCION DEL SCRIPT
logs.print_inf(name_function,'')
# MUESTRO VARIABLES DE ENTRADA
logs.print_in(name_function, 'print_log', print_log)
logs.print_in(name_function, 'DLGID', DLGID)
logs.print_in(name_function, 'TYPE', TYPE)
#
if SWITCH_OUTPUTS: logs.print_in(name_function, 'SWITCH_OUTPUTS', SWITCH_OUTPUTS)
if SWITCH_OUTPUTS: logs.print_in(name_function, 'TEST_OUTPUTS', TEST_OUTPUTS)
if SWITCH_OUTPUTS: logs.print_in(name_function, 'RESET_ENABLE', RESET_ENABLE)
if EVENT_DETECTION: logs.print_in(name_function, 'EVENT_DETECTION', EVENT_DETECTION)
if EVENT_DETECTION: logs.print_in(name_function, 'TIMER_POLL', TIMER_POLL)
#
# ESCRIBO NUMERO DE EJECUCION
redis.no_execution(f'{DLGID}_ERROR')
# CHEQUEO ERROR TX
logs.print_inf(name_function, 'TEST_TX_ERRORS')
testTxResult = e.test_tx() # chequeo estado de transmision del equipo
if testTxResult != 'noLine':
if testTxResult:
# Condicion que se cumple cuando el equipo no presenta errores TX
pass
else:
pass
else:
logs.print_inf(name_function, f'NO EXISTE VARIABLE LINE EN {DLGID}')
logs.print_inf(name_function, f'NO SE EJECUTA {name_function}')
