def __init__(self,LIST_CONFIG):
'''
Constructor
'''
#
self.config = config_var(LIST_CONFIG)
#
#VARIABLES DE EJECUCION
self.print_log = self.config.lst_get('print_log')
self.DLGID = self.config.lst_get('DLGID')
self.TYPE = self.config.lst_get('TYPE')
self.LOG_LEVEL = self.config.lst_get('LOG_LEVEL')
#
#VARIABLES DE CONFIGURACION
self.SWITCH_OUTPUTS = str2bool(self.config.lst_get('SWITCH_OUTPUTS'))
self.TEST_OUTPUTS = str2bool(self.config.lst_get('TEST_OUTPUTS'))
self.RESET_ENABLE = str2bool(self.config.lst_get('RESET_ENABLE'))
self.EVENT_DETECTION = str2bool(self.config.lst_get('EVENT_DETECTION'))
self.TIMER_POLL = str2bool(self.config.lst_get('TIMER_POLL'))
#
# INSTANCIAS
self.logs = ctrl_logs(self.TYPE,'CTRL_FREC_error',self.DLGID,self.print_log,self.LOG_LEVEL)
self.redis = Redis()
def __init__(self, LIST_CONFIG):
'''
Constructor
'''
#
## DEFINICION DE VARIABLES DE LA CLASE
self.config = config_var(LIST_CONFIG)
self.print_log = self.config.lst_get('print_log')
self.LOG_LEVEL = self.config.lst_get('LOG_LEVEL')
self.DLGID_CTRL = self.config.lst_get('DLGID_CTRL')
self.TYPE = self.config.lst_get('TYPE')
self.ENABLE_OUTPUTS = self.config.lst_get('ENABLE_OUTPUTS')
self.ENABLE_OUTPUTS = str2bool(self.config.lst_get('ENABLE_OUTPUTS'))
self.TYPE_IN_FREC = self.config.lst_get('TYPE_IN_FREC')
self.DLGID_REF = self.config.lst_get('DLGID_REF')
self.CHANNEL_REF = self.config.lst_get('CHANNEL_REF')
self.TYPE_IN_FREC = self.config.lst_get('TYPE_IN_FREC')
self.DLGID_REF_1 = self.config.lst_get('DLGID_REF_1')
self.CHANNEL_REF_1 = self.config.lst_get('CHANNEL_REF_1')
self.PROGRAMMED_FREC = self.config.lst_get('PROGRAMMED_FREC')
## INSTANCIAS
self.logs = ctrl_logs(self.TYPE, 'CTRL_FREC_process', self.DLGID_CTRL,
self.print_log, self.LOG_LEVEL)
self.redis = Redis()
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 __init__(self,LIST_CONFIG):
'''
Constructor
'''
#
## DEFINICION DE VARIABLES DE LA CLASE
self.config = config_var(LIST_CONFIG)
self.print_log = self.config.lst_get('print_log')
self.DLGID_CTRL = self.config.lst_get('DLGID_CTRL')
self.TYPE = self.config.lst_get('TYPE')
self.ENABLE_OUTPUTS = self.config.lst_get('ENABLE_OUTPUTS')
self.ENABLE_OUTPUTS = str2bool(self.config.lst_get('ENABLE_OUTPUTS'))
self.LOG_LEVEL = self.config.lst_get('LOG_LEVEL')
## INSTANCIAS
self.logs = ctrl_logs(self.TYPE,'CTRL_PpotPaysandu',self.DLGID_CTRL,self.print_log,self.LOG_LEVEL)
self.redis = Redis()
self.gda = GDA(dbUrl)
def run_error_process(LIST_CONFIG):
if bool(LIST_CONFIG):
# INSTANCIO config_var CON EL NUEVO LIST_CONFIG
conf = config_var(LIST_CONFIG)
#
TYPE = conf.lst_get('TYPE')
import importlib.util
#
'''
spec = importlib.util.spec_from_file_location("archivo", f"/datos/cgi-bin/spx/AUTOMATISMOS/{TYPE}/PROCESS/ctrl_error.py")
archivo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(archivo)
call_error_process = True'''
try:
#spec = importlib.util.spec_from_file_location("archivo", f"../{TYPE}/PROCESS/ctrl_error.py")
#spec = importlib.util.spec_from_file_location("archivo", f"/datos/cgi-bin/spx/AUTOMATISMOS/{TYPE}/PROCESS/ctrl_error.py")
spec = importlib.util.spec_from_file_location(
"archivo",
'{0}/{1}/PROCESS/ctrl_error.py'.format(project_path, TYPE))
archivo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(archivo)
call_error_process = True
except:
logs.print_inf(
name_function,
f'NO SE ENCUENTRA ../{TYPE}/PROCESS/ctrl_error.py O EL MISMO TIENE ERRORES'
)
call_error_process = False
#
if call_error_process:
# try:
# archivo.error_process(LIST_CONFIG)
# except:
# logs.print_inf(name_function, f'ERROR AL CORRER ../{TYPE}/PROCESS/ctrl_error.py - error_process(LIST_CONFIG)')
archivo.error_process(LIST_CONFIG)
def run_ctrl_process(LIST_CONFIG):
if bool(LIST_CONFIG):
#
# INSTANCIO config_var CON EL NUEVO LIST_CONFIG Y LEO TYPE
conf = config_var(LIST_CONFIG)
TYPE = conf.lst_get('TYPE')
#
import importlib.util
'''
try:
spec = importlib.util.spec_from_file_location("archivo",'{0}/{1}/PROCESS/ctrl_process.py'.format(project_path,TYPE))
archivo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(archivo)
archivo.control_process(LIST_CONFIG)
except:
logs.print_inf(name_function, f'NO SE ENCUENTRA ../{TYPE}/PROCESS/ctrl_process.py O EL MISMO TIENE ERRORES')
exit(0)'''
spec = importlib.util.spec_from_file_location("archivo",'{0}/{1}/PROCESS/ctrl_process.py'.format(project_path,TYPE))
archivo = importlib.util.module_from_spec(spec)
spec.loader.exec_module(archivo)
archivo.control_process(LIST_CONFIG)
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()
#----------------------------------------------------------------------------------------
# CONFIGURO LAS ENTRADAS DE CONFIGURACION
if __name__ == '__main__':
# DETECTO LLAMADA CON Y SIN PARAMETROS
try:
# LLAMADA CON PAR[AMETROS
STR_CONFIG = sys.argv[1]
LIST_CONFIG = str2lst(STR_CONFIG)
#
except:
# LLAMADA SIN PARAMETROS
LIST_CONFIG = ''
#
# INSTANCIA DE config_var
conf = config_var(LIST_CONFIG)
redis = Redis()
gda = GDA(dbUrl)
#
# CHEQUEO QUE TIPO DE LLAMADA SE ESTA HACIENDO
if bool(LIST_CONFIG):
if conf.lst_get('DLGID'):
# LLAMADA CON VARIABLES DE EJECUCION Y CONFIGURACION
print_log = conf.lst_get('print_log')
DLGID = conf.lst_get('DLGID')
TYPE = conf.lst_get('TYPE')
else:
# LLAMADA SOLO CON EL ID DEL DATALOGGER
print_log = True
DLGID = sys.argv[1]
TYPE = 'CHARGE'
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()
if __name__ == '__main__':
# LEO EL STR DE CONFIGURACION
try:
STR_CONFIG = sys.argv[1]
LIST_CONFIG = STR_CONFIG.split(',')
except:
print('HELP')
print(' ARGUMENT = DLGID_CTRL')
print(' EX:')
print(' ./serv_APP_selection.py DLGID_CTRL')
quit()
#
# INSTANCIAS
conf = config_var(STR_CONFIG)
redis = Redis()
#
#
# CHEQUEO QUE TIPO DE LLAMADA SE ESTA HACIENDO
## SI SE LE PASA UN str ASIGNO VALORES ENTRADOS
if conf.str_get('DLGID_CTRL'):
print_log = conf.str_get('print_log')
DLGID_CTRL = conf.str_get('DLGID_CTRL')
if conf.str_get('TYPE'):
TYPE = conf.str_get('TYPE')
else:
TYPE = 'CHARGE'
## SE SE LE PASA UN SOLO ARGUMENTO SE LO ASIGNO A DLGID
else:
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}')