def emerg_system(dlgid):
'''
DESCRIPTION
Se encarga de poner a funcionar el sitema de emergencia
LEYENDA:
dlgid => datalogger id
EJ: pump1('MER006',True)
'''
## INSTANCIAS
redis = Redis()
#
# CHEQUEO SI EXISTE OUTPUTS, SI NO EXSITE LO CREO CON VALOR 0
if not (redis.hexist(dlgid, 'OUTPUTS')):
redis.hset(dlgid, 'OUTPUTS', 0)
# LEO LA SALIDA ACTUAL SETEADA
last_out = redis.hget(dlgid, 'OUTPUTS')
# APLICO LA MASCARA 1111010
last_out = int(last_out) & int('1111010', 2)
#
#
# MANDO A SETEAR LAS SALIDAS DEL DATALOGGER
redis.hset(dlgid, 'OUTPUTS', last_out)
def douts(dlgid, out_dec):
'''
DESCRIPTION
Se encarga de poner en la salida digital (d2,d1,d0) el valor que se le pasa en decimal sin afectar las otras entradas
LEYENDA:
dlgid => datalogger id
out_dec => numero decimal que se va a querer porner en las salidas digitales (d2,d1,d0)
EJ: douts(MER006,7)
'''
## INSTANCIAS
redis = Redis()
#
# LEO LA SALIDA ACTUAL SETEADA
last_out = redis.hget(dlgid, 'OUTPUTS')
# APLICO LA MASCARA 0000011
last_out = int(last_out) & int('0000011', 2)
#
#
#
# APLICO LA MASCARA 0000111 A no_dec
out_dec = int(out_dec) & int('0000111', 2)
# HAGO UN BITWISE LEFT 3 UNIDADES
out_dec = out_dec << 3
#
#
# CONCATENO LOS DOS PRIMEROS BITS CON LA SALIDA DIGITAL
out = out_dec | last_out
#
#
# MANDO A SETEAR LAS SALIDAS DEL DATALOGGER
redis.hset(dlgid, 'OUTPUTS', out)
def pump1(dlgid, action):
'''
DESCRIPTION
Se encarga de prender o apagar la bomba 1 del sistema
LEYENDA:
dlgid => datalogger id
action => [True (PRENDER BOMBA) | False (APAGAR BOMBA)]
EJ: pump1('MER006',True)
'''
## INSTANCIAS
redis = Redis()
#
#
# LEO LA SALIDA ACTUAL SETEADA
last_out = redis.hget(dlgid, 'OUTPUTS')
# APLICO LA MASCARA 1111100
last_out = int(last_out) & int('1111100', 2)
#
#
# VEO QUE ACCION ES LA SELECCIONADA
if action: out = last_out | int('11', 2)
else: out = last_out | int('1', 2)
#
#
# MANDO A SETEAR LAS SALIDAS DEL DATALOGGER
redis.hset(dlgid, 'OUTPUTS', out)
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 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 __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 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'
else:
def read_param(dlgid, param):
'''
DESCRIPTION
Se encarga de leer del datalogger el canal con el nombre 'param'
devuelve un string
LEYENDA:
dlgid => datalogger id
param => nombre del canal que se quiere leer
si se quiere leer la fecha param = DATE
si se quiere leer la hora param = TIME
EJ: read_param('MER001','PA')
'''
def head_detect(line, key_word):
'''
DETECTA SI LA CABECERA DEL line HAY ESTE key_word
'''
i = 0
match = 0
for char in key_word:
if line[i] == char:
match += 1
i += 1
if match == 9: return True
else: return False
## INSTANCIAS
redis = Redis()
# LEO LINE
if redis.hexist(dlgid, 'LINE'):
line = redis.hget(dlgid, 'LINE')
else:
return None
# DETECTO SI EXISTE CABECERA LINE
if head_detect(line, 'LINE=DATE'):
parsed_line = line.split(';')
#
# CREO UNA LISTA A PARTIR DE SEPARAR LOS CAMPOS DEL LINE
n = 0
my_list = []
for elements in parsed_line:
fields = elements.split(':')
my_list.append(fields[0])
try:
my_list.append(fields[1])
except:
pass
n = n + 1
# VEO SI SE ESTA SELECCIONADO DATE O TIME
if param == 'DATE': out = f'20{my_list[1]}'
else:
try:
out = my_list[my_list.index(param) + 1]
except:
out = ''
#return out
else:
parsed_line = line.split(',')
#
# CREO UNA LISTA A PARTIR DE SEPARAR LOS CAMPOS DEL LINE
n = 0
my_list = []
for elements in parsed_line:
fields = elements.split('=')
my_list.append(fields[0])
try:
my_list.append(fields[1])
except:
pass
n = n + 1
#
# VEO SI SE ESTA SELECCIONADO DATE O TIME
if param == 'DATE': out = my_list[1]
elif param == 'TIME': out = my_list[2]
else:
try:
out = my_list[my_list.index(param) + 1]
except:
out = ''
#return out
# aplico validacion de datos modbus
if out == '9999':
if redis.hexist(dlgid, "lastValidData_{0}".format(param)):
out = redis.hget(dlgid, "lastValidData_{0}".format(param))
else:
redis.hset(dlgid, "lastValidData_{0}".format(param), out)
return out
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()
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}')