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
'''
#
## 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 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 __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 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 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 __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)
# 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
'''
DRIVER PARA EL TRABAJO CON EL DATALOGGER
Created on 16 mar. 2020
@author: Yosniel Cabrera
Version 2.1.4 15-04-2021 16:43
'''
#CONEXIONES
from __CORE__.drv_redis import Redis
from __CORE__.mypython import lst2str
# INSTANCIAS
redis = Redis()
# FUNCIONES
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()
class errorProcess(object):
'''
FUNCIONES USADAS POR ctrl_error_frec.py
'''
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 test_tx(self):
'''
detecta errores tx y RTC
return '' => si no existe el line del datalogger
return False => si hay errores TX de cualquier tipo
return True => cualquier otra opcion
'''
name_function = 'TEST_TX_ERRORS'
# CHEQUEO DE ERROR TX
#
# CHEQUEO SI EXISTE EL LINE EN EL DATALOGGER
if not(self.redis.hexist(self.DLGID, 'LINE')):
return 'noLine'
# DEVUELVO last_line CON EL LINE ANTERIOR Y current_line CON EL LINE ACTUAL
if self.redis.hexist(f'{self.DLGID}_ERROR', 'last_line'):
last_line = self.redis.hget(f'{self.DLGID}_ERROR', 'last_line')
current_line = self.redis.hget(self.DLGID, 'LINE')
self.redis.hset(f'{self.DLGID}_ERROR', 'last_line', current_line)
else:
last_line = self.redis.hget(self.DLGID, 'LINE')
self.redis.hset(f'{self.DLGID}_ERROR', 'last_line', last_line)
current_line = last_line
return True
# ASIGNO EL VALOR DE LA BATERIA PARA MOSTRARLO EN LOS LOGS
if read_param(self.DLGID, 'BAT'):
bat = read_param(self.DLGID, 'BAT')
else:
bat = read_param(self.DLGID, 'bt')
def error_1min_TX(self):
'''
return True si hubo error de TX durante un minuto
return False si no hubo error de TX durante un minuto
'''
if last_line == current_line:
#
return True
else:
#
self.logs.print_inf(name_function, 'TX OK')
#
return False
def RTC_error(self,error_1min):
'''
return False: si no se comprueba el RTC por error_1min
si no hay errores RTC
return True: si hay errores TRC
'''
# COMPRUEBO ERROR RTC SOLO SI NO HAY ERROR TX
if error_1min: return False
# DEVUELVO LOS VALORES DE last_fecha_data y last_hora_data asi como fecha_data y hora_data
if self.redis.hexist(f'{self.DLGID}_ERROR', 'last_fecha_data') & self.redis.hexist(f'{self.DLGID}_ERROR', 'last_hora_data'):
last_fecha_data = self.redis.hget(f'{self.DLGID}_ERROR', 'last_fecha_data')
last_hora_data = self.redis.hget(f'{self.DLGID}_ERROR', 'last_hora_data')
fecha_data = read_param(self.DLGID, 'DATE')
hora_data = read_param(self.DLGID, 'TIME')
#
# ACTUALIZO last_fecha_data Y last_hora_data CON LOS VALORES ACTUALES
self.redis.hset(f'{self.DLGID}_ERROR', 'last_fecha_data', fecha_data)
self.redis.hset(f'{self.DLGID}_ERROR', 'last_hora_data', hora_data)
else:
fecha_data = read_param(self.DLGID, 'DATE')
hora_data = read_param(self.DLGID, 'TIME')
last_fecha_data = fecha_data
last_hora_data = hora_data
#
# ACTUALIZO last_fecha_data Y last_hora_data CON LOS VALORES ACTUALES
self.redis.hset(f'{self.DLGID}_ERROR', 'last_fecha_data', fecha_data)
self.redis.hset(f'{self.DLGID}_ERROR', 'last_hora_data', hora_data)
#
return False
#
# CHEQUEO QUE NO ESTE CAMBIANDO LA FECHA Y HORA
if fecha_data == last_fecha_data and hora_data == last_hora_data:
self.logs.print_inf(name_function, 'RTC ERROR')
self.logs.dlg_performance(f'< RTC ERROR >')
return True
else:
self.logs.print_inf(name_function, 'RTC OK')
return False
def error_10min_TX(self,error_1min):
'''
return True si hubo error de TX durante mas 10 minuto
return False si se restablece la cominicacion
'''
if error_1min:
# INICIALIZO EL CONTADOR DE MINUTOS CON ERORR TX
if not(self.redis.hexist(f'{self.DLGID}_ERROR','count_error_tx')):
self.redis.hset(f'{self.DLGID}_ERROR', 'count_error_tx', 1)
# LEO EL CONTADOS DE TIEMPO
count_error_tx = int(self.redis.hget(f'{self.DLGID}_ERROR','count_error_tx'))
# VEO EL ESTADO DEL CONTADOR
if count_error_tx >= 10:
#
return True
else:
self.logs.print_inf(name_function, f'CONTADOR DE ERROR TX [{count_error_tx}]')
count_error_tx += 1
self.redis.hset(f'{self.DLGID}_ERROR','count_error_tx',count_error_tx)
#
return False
else:
if self.redis.hexist(f'{self.DLGID}_ERROR','count_error_tx'):
self.redis.hdel(f'{self.DLGID}_ERROR','count_error_tx')
#
return False
def error_TPOLL_TX(self,timer_poll,error_1min):
'''
return True si hubo error de TX durante mas TPOLL minutos
return False si se restablece la cominicacion
'''
if error_1min:
# INICIALIZO EL CONTADOR DE MINUTOS CON ERORR TX
if not(self.redis.hexist(f'{self.DLGID}_ERROR','count_error_tx')):
self.redis.hset(f'{self.DLGID}_ERROR', 'count_error_tx', 1)
# LEO EL CONTADOS DE TIEMPO
count_error_tx = int(self.redis.hget(f'{self.DLGID}_ERROR','count_error_tx'))
# VEO EL ESTADO DEL CONTADOR
if count_error_tx >= timer_poll:
#
return True
else:
self.logs.print_inf(name_function, f'CONTADOR DE ERROR TX [{count_error_tx}]')
count_error_tx += 1
self.redis.hset(f'{self.DLGID}_ERROR','count_error_tx',count_error_tx)
#
return False
else:
if self.redis.hexist(f'{self.DLGID}_ERROR','count_error_tx'):
self.redis.hdel(f'{self.DLGID}_ERROR','count_error_tx')
#
return False
# SI TENGO TIMER_POLL
if self.config.lst_get('TIMER_POLL'):
# LERO EL VALOR DE TPOLL PASADO
timer_poll = int(self.config.lst_get('TIMER_POLL'))
#
# CHEQUEO ERROR TX DURANTE UN MINUTO
error_1min = error_1min_TX(self)
#
# CHEQUEO ERROR DE RTC
RTC_error(self,error_1min)
#
# CHEQUEO ERRORES TX EN EL TPOLL DADO
error_TPOLL = error_TPOLL_TX(self,timer_poll,error_1min)
#
else:
# CHEQUEO ERROR TX DURANTE UN MINUTO
error_1min = error_1min_TX(self)
#
# CHEQUEO ERROR DE RTC
RTC_error(self,error_1min)
#
# CHEQUEO ERROR TX DURANTE 10 MINUTOS
error_10min = error_10min_TX(self,error_1min)
#
# TRABAJO LOS LOGS
if self.config.lst_get('TIMER_POLL'):
if error_TPOLL:
# MUESTRO LOG EN CONSOLA
self.logs.print_inf(name_function, f'TX STOPPED FOR MORE THAN {timer_poll} MIN')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< MAS DE {timer_poll} MIN CAIDO >')
#
return False
else:
return True
else:
if error_10min:
#
# MUESTRO LOG EN CONSOLA
self.logs.print_inf(name_function, 'TX STOPPED FOR MORE THAN 10 MIN')
self.logs.print_out(name_function, 'TX_ERROR', 'SI')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< MAS DE 10 MIN CAIDO > ')
#
# ESCRIBO EN REDIS LA ALARMA TX_ERROR CON VALOR DE ALARMA PRENDIDA
self.redis.hset(self.DLGID,'TX_ERROR', 'SI')
#
return False
else:
#
# ESCRIBO EN REDIS LA ALARMA TX_ERROR CON VALOR DE ALARMA APAGADA
self.redis.hset(self.DLGID, 'TX_ERROR', 'NO')
#
#MUESTRO LOGS EN CONSOLA DE QUE SE ESCRIBIO LA ALARMA DE ERROR TX EN REDIS
self.logs.print_out(name_function,'TX_ERROR', 'NO')
#
if error_1min:
# MUESTRO LOG EN CONSOLA
self.logs.print_inf(name_function, 'TX STOPPED')
#
# ESCRIBO EN REDIS ALARMA DE 1MIN EL EQUIPO CAIDO
self.redis.hset(self.DLGID, 'error_1min', 'SI')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< ERROR TX >')
#
return False
else:
#
# ESCRIBO EN REDIS ALARMA DE 1MIN QUE INDICA QUE EL DATO QUE ESTA LLEGADNO ES VALIDO
self.redis.hset(self.DLGID, 'error_1min', 'NO')
#
return True
class ctrl_process(object):
'''
FUNCIONES USADAS POR ctrl_process.py
'''
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 getAndUpdateMode(self,WEB_Mode):
'''
funcion para obtener el modo de trabajo y actualizarlo en caso necesario
'''
name_function = 'GET_AND_UPDATE_MODE'
# entradas
self.logs.print_in(name_function, 'WEB_Mode', WEB_Mode)
def readPlcMode():
"""
lee el modo de trabajo en que actualmente se encuentra el tablero de control
0 -> EMERGENCIA
1 -> LOCAL
2 -> REMOTO
"""
# leo el modo en que actualmente esta trabajando el PLC
MOD = read_param(self.DLGID_CTRL,'MOD')
MOD = '102'
if MOD == "100": return "EMERGENCIA"
elif MOD == "101": return "LOCAL"
elif MOD == "102": return "REMOTO"
else:
self.logs.print_error(name_function, 'MODO DE TRABAJO NO ADMITIDO: MOD = {0}'.format(MOD))
self.logs.print_error(name_function, 'NO SE EJECUTA EL SCRIPT')
quit()
def IsWebModeChanged():
"""
detecta si hubo un cambio en el modo de trabajo web
"""
if not self.redis.hexist(self.DLGID_CTRL,'Last_WEB_Mode'):
self.redis.hset(self.DLGID_CTRL,'Last_WEB_Mode',WEB_Mode)
Last_WEB_Mode = self.redis.hget(self.DLGID_CTRL,'Last_WEB_Mode')
if Last_WEB_Mode != WEB_Mode:
self.redis.hset(self.DLGID_CTRL,'Last_WEB_Mode',WEB_Mode)
return True
else:
return False
def setToPlcMode(WEB_Mode):
"""
se escribe el registro UMOD del PLC para que el mismo actualice el modo
"""
if WEB_Mode == "EMERGENCIA":
mbusWrite(self.DLGID_CTRL,'2097','interger',105)
elif WEB_Mode == "REMOTO":
mbusWrite(self.DLGID_CTRL,'2097','interger',107)
else:
pass
def IsPlcModeUpdated():
"""
se compara el modo de trabajo de la web con el modo actual de trabajo del PLC.
Si son iguales se retorna true, en caso contrario false
"""
plcMode = readPlcMode()
if plcMode != "LOCAL":
if WEB_Mode == plcMode:
return True
else:
return False
else:
# el plc esta trabajando en modo local por lo que no se puede decir que este desactualizado con la web
# ya que la misma no trabaja en este modo
# se asume que estan actualizados
return True
def updateWebMode(UMOD):
"""
Se actualiza en la web el modo de la siguiente forma
101-> EMERGENCIA
103-> LOCAL
103-> REMOTO
En caso de valor 102 return True para indicar que se esta trabajando en modo local
"""
if UMOD == "101":
self.logs.print_inf(name_function,"SE ACTUALIZA EL MODO EN LA WEB")
self.gda.WriteAutConf(self.DLGID_CTRL,'WEB_Mode','EMERGENCIA')
self.redis.hset(self.DLGID_CTRL,'Last_WEB_Mode','EMERGENCIA')
mbusWrite(self.DLGID_CTRL,'2097','interger',100)
elif UMOD == "102":
self.logs.print_inf(name_function,"MODO LOCAL EN EL TABLERO")
self.logs.print_inf(name_function,"NO SE TIENE CONTROL REMOTO")
elif UMOD == "103":
self.logs.print_inf(name_function,"SE ACTUALIZA EL MODO EN LA WEB")
self.gda.WriteAutConf(self.DLGID_CTRL,'WEB_Mode','REMOTO')
self.redis.hset(self.DLGID_CTRL,'Last_WEB_Mode','REMOTO')
mbusWrite(self.DLGID_CTRL,'2097','interger',100)
def IsUpdatePlcModePending():
'''
retorna true en caso de haber pendiente una actualizacion de modo hacia el PLC
'''
if self.redis.hexist(self.DLGID_CTRL,'UpdatePlcModePending'):
UpdatePlcModePending = self.redis.hget(self.DLGID_CTRL,'UpdatePlcModePending')
else:
self.redis.hset(self.DLGID_CTRL,'UpdatePlcModePending','NO')
UpdatePlcModePending = 'NO'
if UpdatePlcModePending == 'SI':
return True
else:
return False
# MAIN
# actualizo el modo para el software a partir del modo en que se encuentra el plc
SOFT_Mode = readPlcMode()
self.logs.print_in(name_function, 'MOD', SOFT_Mode)
if IsWebModeChanged():
self.logs.print_inf(name_function,"HUBO CAMBIO DE MODO EN LA WEB")
# mando a escribir el modo al plc
self.logs.print_inf(name_function,"SE MANDA A ACTUALIZAR EL MODO EN EL PLC")
setToPlcMode(WEB_Mode)
# activo una bandera para idicar que se esta en un proceso de cambio de modo hacia el PLC
self.redis.hset(self.DLGID_CTRL,'UpdatePlcModePending','SI')
else:
# verifico que este en proceso una actualizacion de modo en el plc
if IsUpdatePlcModePending():
# chequeo si se actualizo el modo del PLC. Si no lo hizo lo vuelvo a escribir.
self.logs.print_inf(name_function,"PROCESO DE ACTUALIZACION DE MODO HACIA EL PLC PENDIENTE")
if not IsPlcModeUpdated():
self.logs.print_inf(name_function,"SE MANDA NUEVAMENTE!!! A ACTUALIZAR EL MODO EN EL PLC")
setToPlcMode(WEB_Mode)
else:
self.logs.print_inf(name_function,"MODO EN EL PLC ACTUALIZADO DE FORMA CORRECTA")
self.redis.hset(self.DLGID_CTRL,'UpdatePlcModePending','NO')
else:
# chequep si hay pedido para actualizar en la web
UMOD = read_param(self.DLGID_CTRL,'UMOD')
#UMOD = '101'
if UMOD == '100':
self.logs.print_inf(name_function,"MODOS DE TRABAJO ACTUALIZADOS")
elif UMOD in ['101','102','103']:
# Actualizo el modo web
self.logs.print_inf(name_function,"HUBO CAMBIO DE MODO EN EL PLC")
updateWebMode(UMOD)
else:
self.logs.print_error(name_function,"VALOR NO ADMITIDO PARA ACTUALIZACION DE MODOS: UMOD = {0}".format(UMOD))
self.logs.print_error(name_function,"SE IGNORA ESTE VALOR")
self.logs.print_out(name_function, 'SOFT_Mode', SOFT_Mode)
return SOFT_Mode
def pump(self,actionOnthePump):
'''
funcion que manda a prender o apagar la bomba
'''
name_function = 'MAIN'
if actionOnthePump == 'ON':
self.logs.print_inf(name_function, 'PRENDO BOMBA')
mbusWrite(self.DLGID_CTRL,'2096','interger',101) # escribo el valor 2 en el registro 2097 para mandar a prender la bomba
elif actionOnthePump == 'OFF':
self.logs.print_inf(name_function, 'APAGO BOMBA')
mbusWrite(self.DLGID_CTRL,'2096','interger',100) # escribo el valor 0 en el registro 2097 para mandar a apagar la bomba
def getTxState(self):
'''
devuelve true si la transmision es continua
devuelve false si la transmision es inestable
'''
nameFunction = 'getTxState'
#READ INPUTS VALUES
# leo el valor del contador de restablecimiento de errores de la redis
countRecoveryTx = 0 # default value
if self.redis.hexist(self.DLGID_CTRL,'countRecoveryTx'):
countRecoveryTx = int(self.redis.hget(self.DLGID_CTRL,'countRecoveryTx'))
else:
self.redis.hset(self.DLGID_CTRL,'countRecoveryTx',countRecoveryTx)
#
# leo si esta alarmada la tx por errores
error_1min = 'NO' # default value
if self.redis.hexist(self.DLGID_CTRL,'error_1min'):
error_1min = self.redis.hget(self.DLGID_CTRL,'error_1min')
else:
self.redis.hset(self.DLGID_CTRL,'error_1min',error_1min)
# MAIN
IsStableTx = False
if error_1min == 'NO':
if countRecoveryTx >= 3:
IsStableTx = True
else:
countRecoveryTx += 1
self.logs.print_inf(nameFunction,'ESPERANDO QUE ESTABLICEN LAS COMUNICACIONES')
self.logs.print_out(nameFunction,'countRecoveryTx',countRecoveryTx)
else:
countRecoveryTx = 0
self.logs.print_inf(nameFunction,'COMUNICACIONES INESTABLES')
# WRITE OUTPUT VARS
self.redis.hset(self.DLGID_CTRL,'countRecoveryTx',countRecoveryTx)
return IsStableTx
def setFrequency(self,WEB_Frequency):
'''
funcion que manda a setear la frecuencia de trabajo del variador
'''
name_function = 'MAIN'
UFREQ = int(read_param(self.DLGID_CTRL,'UFREQ'))
# leo la variable IsfrequecyUpdating
if not self.redis.hexist(self.DLGID_CTRL,'IsfrequecyUpdating'):
self.redis.hset(self.DLGID_CTRL,'IsfrequecyUpdating','NO')
IsfrequecyUpdating = self.redis.hget(self.DLGID_CTRL,'IsfrequecyUpdating')
else:
IsfrequecyUpdating = self.redis.hget(self.DLGID_CTRL,'IsfrequecyUpdating')
# leo la variable lastUpdatedFrequecy
if not self.redis.hexist(self.DLGID_CTRL,'lastUpdatedFrequecy'):
self.redis.hset(self.DLGID_CTRL,'lastUpdatedFrequecy',0)
lastUpdatedFrequecy = int(self.redis.hget(self.DLGID_CTRL,'lastUpdatedFrequecy'))
else:
lastUpdatedFrequecy = int(self.redis.hget(self.DLGID_CTRL,'lastUpdatedFrequecy'))
# leo la variable countFrames
if not self.redis.hexist(self.DLGID_CTRL,'countFrames'):
self.redis.hset(self.DLGID_CTRL,'countFrames',0)
countFrames = int(self.redis.hget(self.DLGID_CTRL,'countFrames'))
else:
countFrames = int(self.redis.hget(self.DLGID_CTRL,'countFrames'))
if UFREQ == 100:
if IsfrequecyUpdating == 'NO':
if WEB_Frequency != 0:
self.logs.print_inf(name_function, 'SE MANDA A ACTUALIZAR LA FRECUENCIA {0}'.format(WEB_Frequency))
mbusWrite(self.DLGID_CTRL,'2098','interger',WEB_Frequency+100)
self.redis.hset(self.DLGID_CTRL,'IsfrequecyUpdating','SI')
self.redis.hset(self.DLGID_CTRL,'lastUpdatedFrequecy',WEB_Frequency)
self.redis.hset(self.DLGID_CTRL,'countFrames',0)
else:
self.logs.print_inf(name_function, 'NO HAY PEDIDO DE FRECUENCIA PARA ACTUALIZAR')
else:
# dejo un frame de por medio para esperar un dato valido de UFREQ
countFrames += 1
if countFrames >= 2:
if lastUpdatedFrequecy == WEB_Frequency:
self.gda.WriteAutConf(self.DLGID_CTRL,'WEB_Frequency',0)
self.logs.print_inf(name_function, 'FRECUENCIA ACTUALIZADA CORRECTAMENTE')
self.redis.hset(self.DLGID_CTRL,'IsfrequecyUpdating','NO')
#
# pongo en cero el registro modbus para evitar que se mande por error un valor y se comience un proceso de actualizacio de frecuencia
mbusWrite(self.DLGID_CTRL,'2098','interger',100)
else:
deltaFrequency = WEB_Frequency - lastUpdatedFrequecy
self.logs.print_inf(name_function, 'NUEVO VALOR DE ACTUALIZACION DE FRECUENCIA')
self.logs.print_inf(name_function, 'SE CONTINUA EL PROCESO DE VARIAR LA FRECUENCIA')
self.logs.print_inf(name_function, 'SE MANDA A ACTUALIZAR LA FRECUENCIA {0}'.format(deltaFrequency))
mbusWrite(self.DLGID_CTRL,'2098','interger',deltaFrequency)
self.redis.hset(self.DLGID_CTRL,'lastUpdatedFrequecy',WEB_Frequency)
self.redis.hset(self.DLGID_CTRL,'countFrames',0)
else:
self.logs.print_inf(name_function, 'SE ESPERA UN NUEVO FRAME CON VALOR VALIDO EN UFREQ')
self.redis.hset(self.DLGID_CTRL,'countFrames',countFrames)
#
# pongo en cero el registro modbus para evitar que se mande por error un valor y se comience un proceso de actualizacio de frecuencia
mbusWrite(self.DLGID_CTRL,'2098','interger',100)
else:
if UFREQ >= 50 and UFREQ <= 150:
print(UFREQ)
self.logs.print_inf(name_function, 'ACTUALIZACION DE FRECUENCIA EN CURSO')
self.logs.print_inf(name_function, 'SE ESPERA QUE SE TERMINE DE ACTUALIZAR LA FRECUENCIA')
self.redis.hset(self.DLGID_CTRL,'countFrames',2)
#
# pongo en cero el registro modbus para evitar que se mande por error un valor y se comience un proceso de actualizacio de frecuencia
mbusWrite(self.DLGID_CTRL,'2098','interger',100)
else:
self.logs.print_error(name_function, "VALOR INCORRECTO: UFREQ = {0}".format(UFREQ))
self.logs.print_error(name_function,"SE IGNORA ESTE VALOR")
def showStatesAndAlarms(self):
'''
funcion que lee el byte que deja el plc en el LINE y lo traduce a sus correspondientes alarmas y estados
'''
name_function = 'SHOW_STATES_&_ALARMS'
self.logs.print_inf('MAIN',name_function)
def IsValidStates(wordState):
'''
devuelve False se es invalida la palabra de estados recibida
'''
validData = True
# Condiciones para que el dato de estado leidosea valido
## 1- que esten prensente los 16 bits
bitAmount = 0
for bit in wordState:
bitAmount += 1
if bitAmount != 16:
validData = False
## 2- que la palabra comience por 101
bitPosition = 15
for bitValue in wordState:
if bitPosition == 15:
if bitValue != '1':
validData = False
if bitPosition == 14:
if bitValue != '0':
validData = False
if bitPosition == 13:
if bitValue != '1':
validData = False
if bitPosition == 13:
break
bitPosition -= 1
return validData
decStates = int(read_param(self.DLGID_CTRL,'ST'))
binStates = dec2bin(decStates)
if IsValidStates(binStates):
listOfAlarmsAndStates = [
# desctription trueValue falseValue bit
'AlrLowFlow', 'SI', 'NO', #0
'StatePump', 'ON', 'OFF', #1
'AlrLowPressure', 'SI', 'NO', #2
'AlrLowCau', 'SI', 'NO', #3
'AlrLowFlow', 'SI', 'NO', #4
'AlrVarFail', 'SI', 'NO', #5
'StateVar', 'OK', 'FAIL', #6
'StateLineVar', 'OK', 'FAIL', #7
]
NumberOfZerosForFill = int(len(listOfAlarmsAndStates)/3) - len(binStates)
if NumberOfZerosForFill > 0:
# completo con ceros binStates
while NumberOfZerosForFill > 0:
binStates = '0{0}'.format(binStates)
NumberOfZerosForFill -= 1
# escribo los valores de alarmas para cada uno de los bits segun declaracion en listOfAlarmsAndStates
bit = len(binStates)-1
for valueBit in binStates:
if not bit in [15, 14, 13]: # ignoro las posiciones de cabecera de control
if bit < int(len(listOfAlarmsAndStates)/3): # ignoro las posiciones que no tenga estado declarados en listOfAlarmsAndStates
if valueBit == '1':
self.redis.hset(self.DLGID_CTRL,listOfAlarmsAndStates[3*bit],listOfAlarmsAndStates[3*bit+1])
self.logs.print_out(name_function,listOfAlarmsAndStates[3*bit],listOfAlarmsAndStates[3*bit+1])
else:
self.redis.hset(self.DLGID_CTRL,listOfAlarmsAndStates[3*bit],listOfAlarmsAndStates[3*bit+2])
self.logs.print_out(name_function,listOfAlarmsAndStates[3*bit],listOfAlarmsAndStates[3*bit+2])
bit -= 1
else:
self.logs.print_error(name_function,'DATOS DE ESTADOS INVALIDO: ST = {0}'.format(decStates))
def setVisualVars(self):
'''
garantizo que las variables de visualizacion siempre existan
'''
if not self.redis.hexist(self.DLGID_CTRL,'PLC_SoftMode'):
self.redis.hset(self.DLGID_CTRL,'PLC_SoftMode','REMOTO')
if not self.redis.hexist(self.DLGID_CTRL,'TX_ERROR'):
self.redis.hset(self.DLGID_CTRL,'TX_ERROR','NO')
if not self.redis.hexist(self.DLGID_CTRL,'StatePump'):
self.redis.hset(self.DLGID_CTRL,'StatePump','OFF')
if not self.redis.hexist(self.DLGID_CTRL,'AlrLowPressure'):
self.redis.hset(self.DLGID_CTRL,'AlrLowPressure','NO')
if not self.redis.hexist(self.DLGID_CTRL,'AlrLowFlow'):
self.redis.hset(self.DLGID_CTRL,'AlrLowFlow','NO')
if not self.redis.hexist(self.DLGID_CTRL,'AlrLowCau'):
self.redis.hset(self.DLGID_CTRL,'AlrLowCau','NO')
if not self.redis.hexist(self.DLGID_CTRL,'AlrVarFail'):
self.redis.hset(self.DLGID_CTRL,'AlrVarFail','NO')
if not self.redis.hexist(self.DLGID_CTRL,'StateVar'):
self.redis.hset(self.DLGID_CTRL,'StateVar','OK')
if not self.redis.hexist(self.DLGID_CTRL,'StateLineVar'):
self.redis.hset(self.DLGID_CTRL,'StateLineVar','OK')
if not self.redis.hexist(self.DLGID_CTRL,'UnstableTx'):
self.redis.hset(self.DLGID_CTRL,'UnstableTx','NO')
def checkAndSetControlVars(self):
'''
garantizo que las variables de control siempre existan
'''
# WEB_Mode
if not self.config.lst_get('WEB_Mode'):
self.gda.InsertAutConf(self.DLGID_CTRL, 'WEB_Mode', 'REMOTO')
# WEB_ActionPump
if not self.config.lst_get('WEB_ActionPump'):
self.gda.InsertAutConf(self.DLGID_CTRL, 'WEB_ActionPump', 'OFF')
# WEB_Frequency
if not self.config.lst_get('WEB_Frequency'):
self.gda.InsertAutConf(self.DLGID_CTRL, 'WEB_Frequency', 0)
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}')
class error_process(object):
'''
FUNCIONES USADAS POR ctrl_error_frec.py
'''
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.LOG_LEVEL = self.config.lst_get('LOG_LEVEL')
self.DLGID = self.config.lst_get('DLGID')
self.TYPE = self.config.lst_get('TYPE')
#
#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 test_tx(self):
'''
detecta errores tx y RTC
return '' => si no existe el line del datalogger
return False => si hay errores TX de cualquier tipo
return True => cualquier otra opcion
'''
name_function = 'TEST_TX_ERRORS'
# CHEQUEO DE ERROR TX
#
# CHEQUEO SI EXISTE EL LINE EN EL DATALOGGER
if not (self.redis.hexist(self.DLGID, 'LINE')):
return 'noLine'
# DEVUELVO last_line CON EL LINE ANTERIOR Y current_line CON EL LINE ACTUAL
if self.redis.hexist(f'{self.DLGID}_ERROR', 'last_line'):
last_line = self.redis.hget(f'{self.DLGID}_ERROR', 'last_line')
current_line = self.redis.hget(self.DLGID, 'LINE')
self.redis.hset(f'{self.DLGID}_ERROR', 'last_line', current_line)
else:
last_line = self.redis.hget(self.DLGID, 'LINE')
self.redis.hset(f'{self.DLGID}_ERROR', 'last_line', last_line)
current_line = last_line
return True
# ASIGNO EL VALOR DE LA BATERIA PARA MOSTRARLO EN LOS LOGS
if read_param(self.DLGID, 'BAT'):
bat = read_param(self.DLGID, 'BAT')
else:
bat = read_param(self.DLGID, 'bt')
def error_1min_TX(self):
'''
return True si hubo error de TX durante un minuto
return False si no hubo error de TX durante un minuto
'''
if last_line == current_line:
#
return True
else:
#
self.logs.print_inf(name_function, 'TX OK')
#
return False
def RTC_error(self, error_1min):
'''
return False: si no se comprueba el RTC por error_1min
si no hay errores RTC
return True: si hay errores TRC
'''
# COMPRUEBO ERROR RTC SOLO SI NO HAY ERROR TX
if error_1min: return False
# DEVUELVO LOS VALORES DE last_fecha_data y last_hora_data asi como fecha_data y hora_data
if self.redis.hexist(f'{self.DLGID}_ERROR',
'last_fecha_data') & self.redis.hexist(
f'{self.DLGID}_ERROR', 'last_hora_data'):
last_fecha_data = self.redis.hget(f'{self.DLGID}_ERROR',
'last_fecha_data')
last_hora_data = self.redis.hget(f'{self.DLGID}_ERROR',
'last_hora_data')
fecha_data = read_param(self.DLGID, 'DATE')
hora_data = read_param(self.DLGID, 'TIME')
#
# ACTUALIZO last_fecha_data Y last_hora_data CON LOS VALORES ACTUALES
self.redis.hset(f'{self.DLGID}_ERROR', 'last_fecha_data',
fecha_data)
self.redis.hset(f'{self.DLGID}_ERROR', 'last_hora_data',
hora_data)
else:
fecha_data = read_param(self.DLGID, 'DATE')
hora_data = read_param(self.DLGID, 'TIME')
last_fecha_data = fecha_data
last_hora_data = hora_data
#
# ACTUALIZO last_fecha_data Y last_hora_data CON LOS VALORES ACTUALES
self.redis.hset(f'{self.DLGID}_ERROR', 'last_fecha_data',
fecha_data)
self.redis.hset(f'{self.DLGID}_ERROR', 'last_hora_data',
hora_data)
#
return False
#
# CHEQUEO QUE NO ESTE CAMBIANDO LA FECHA Y HORA
if fecha_data == last_fecha_data and hora_data == last_hora_data:
self.logs.print_inf(name_function, 'RTC ERROR')
self.logs.dlg_performance(f'< RTC ERROR >')
return True
else:
self.logs.print_inf(name_function, 'RTC OK')
return False
def error_10min_TX(self, error_1min):
'''
return True si hubo error de TX durante mas 10 minuto
return False si se restablece la cominicacion
'''
if error_1min:
# INICIALIZO EL CONTADOR DE MINUTOS CON ERORR TX
if not (self.redis.hexist(f'{self.DLGID}_ERROR',
'count_error_tx')):
self.redis.hset(f'{self.DLGID}_ERROR', 'count_error_tx', 1)
# LEO EL CONTADOS DE TIEMPO
count_error_tx = int(
self.redis.hget(f'{self.DLGID}_ERROR', 'count_error_tx'))
# VEO EL ESTADO DEL CONTADOR
if count_error_tx >= 10:
#
return True
else:
self.logs.print_inf(
name_function,
f'CONTADOR DE ERROR TX [{count_error_tx}]')
count_error_tx += 1
self.redis.hset(f'{self.DLGID}_ERROR', 'count_error_tx',
count_error_tx)
#
return False
else:
if self.redis.hexist(f'{self.DLGID}_ERROR', 'count_error_tx'):
self.redis.hdel(f'{self.DLGID}_ERROR', 'count_error_tx')
#
return False
def error_TPOLL_TX(self, timer_poll, error_1min):
'''
return True si hubo error de TX durante mas TPOLL minutos
return False si se restablece la cominicacion
'''
if error_1min:
# INICIALIZO EL CONTADOR DE MINUTOS CON ERORR TX
if not (self.redis.hexist(f'{self.DLGID}_ERROR',
'count_error_tx')):
self.redis.hset(f'{self.DLGID}_ERROR', 'count_error_tx', 1)
# LEO EL CONTADOS DE TIEMPO
count_error_tx = int(
self.redis.hget(f'{self.DLGID}_ERROR', 'count_error_tx'))
# VEO EL ESTADO DEL CONTADOR
if count_error_tx >= timer_poll:
#
return True
else:
self.logs.print_inf(
name_function,
f'CONTADOR DE ERROR TX [{count_error_tx}]')
count_error_tx += 1
self.redis.hset(f'{self.DLGID}_ERROR', 'count_error_tx',
count_error_tx)
#
return False
else:
if self.redis.hexist(f'{self.DLGID}_ERROR', 'count_error_tx'):
self.redis.hdel(f'{self.DLGID}_ERROR', 'count_error_tx')
#
return False
# SI TENGO TIMER_POLL
if self.config.lst_get('TIMER_POLL'):
# LERO EL VALOR DE TPOLL PASADO
timer_poll = int(self.config.lst_get('TIMER_POLL'))
#
# CHEQUEO ERROR TX DURANTE UN MINUTO
error_1min = error_1min_TX(self)
#
# CHEQUEO ERROR DE RTC
RTC_error(self, error_1min)
#
# CHEQUEO ERRORES TX EN EL TPOLL DADO
error_TPOLL = error_TPOLL_TX(self, timer_poll, error_1min)
#
else:
# CHEQUEO ERROR TX DURANTE UN MINUTO
error_1min = error_1min_TX(self)
#
# CHEQUEO ERROR DE RTC
RTC_error(self, error_1min)
#
# CHEQUEO ERROR TX DURANTE 10 MINUTOS
error_10min = error_10min_TX(self, error_1min)
#
# TRABAJO LOS LOGS
if self.config.lst_get('TIMER_POLL'):
if error_TPOLL:
# MUESTRO LOG EN CONSOLA
self.logs.print_inf(
name_function,
f'TX STOPPED FOR MORE THAN {timer_poll} MIN')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(
f'< MAS DE {timer_poll} MIN CAIDO > [BAT = {bat}]')
#
return False
else:
return True
else:
if error_10min:
#
# MUESTRO LOG EN CONSOLA
self.logs.print_inf(name_function,
'TX STOPPED FOR MORE THAN 10 MIN')
self.logs.print_out(name_function,
dic.get_dic('TX_ERROR', 'name'),
dic.get_dic('TX_ERROR', 'True_value'))
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(
f'< MAS DE 10 MIN CAIDO > [BAT = {bat}]')
#
# ESCRIBO EN REDIS LA ALARMA TX_ERROR CON VALOR DE ALARMA PRENDIDA
self.redis.hset(self.DLGID, dic.get_dic('TX_ERROR', 'name'),
dic.get_dic('TX_ERROR', 'True_value'))
#
return False
else:
#
# ESCRIBO EN REDIS LA ALARMA TX_ERROR CON VALOR DE ALARMA APAGADA
self.redis.hset(self.DLGID, dic.get_dic('TX_ERROR', 'name'),
dic.get_dic('TX_ERROR', 'False_value'))
#
#MUESTRO LOGS EN CONSOLA DE QUE SE ESCRIBIO LA ALARMA DE ERROR TX EN REDIS
self.logs.print_out(name_function,
dic.get_dic('TX_ERROR', 'name'),
dic.get_dic('TX_ERROR', 'False_value'))
#
if error_1min:
# MUESTRO LOG EN CONSOLA
self.logs.print_inf(name_function, 'TX STOPPED')
#
# ESCRIBO EN REDIS ALARMA DE 1MIN EL EQUIPO CAIDO
self.redis.hset(self.DLGID, 'error_1min', 'SI')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< ERROR TX > [BAT = {bat}]')
#
return False
else:
#
# ESCRIBO EN REDIS ALARMA DE 1MIN QUE INDICA QUE EL DATO QUE ESTA LLEGADNO ES VALIDO
self.redis.hset(self.DLGID, 'error_1min', 'NO')
#
return True
def visual(self):
pass
def event_detection(self):
name_function = 'EVENT_DETECTION'
# SI EVENT_DETECTION ES False INTERRUMPO LA FUNCION
if not (self.EVENT_DETECTION == None):
if not (self.EVENT_DETECTION):
self.logs.print_inf(name_function,
'EVENT_DETECTION INHABILITADO')
return
# PIERTA DEL GABINETE
if read_param(self.DLGID, 'GA') == '1':
self.logs.print_inf(name_function, 'GABINETE_ABIERTO')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< {name_function} > GABINETE_ABIERTO')
# FALLA ELECTRICA
if read_param(self.DLGID, 'FE') == '1':
self.logs.print_inf(name_function, 'FALLA_ELECTRICA')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< {name_function} > FALLA_ELECTRICA')
# FALLA TERMICA 1
if read_param(self.DLGID, 'FT1') == '1':
self.logs.print_inf(name_function, 'FALLA_TERMICA_1')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< {name_function} > FALLA_TERMICA_1')
# TRABAJO EN MODO LOCAL
if read_param(self.DLGID, 'LM') == '1':
self.logs.print_inf(name_function, 'MODO_LOCAL')
#
# ESCRIBO EN EL LOG
self.logs.dlg_performance(f'< {name_function} > MODO_LOCAL')
# TRABAJO EN MODO REMOTO
if self.redis.hget(self.DLGID,
dic.get_dic('WEB_MODE', 'name')) == dic.get_dic(
'WEB_MODE', 'False_value'):
#
# CHEQUEO QUE SE ESTE MANDANDO A PRENDER LA BOMBA
if self.redis.hget(self.DLGID,
dic.get_dic('PUMP_1_WEB_MODE',
'name')) == dic.get_dic(
'PUMP_1_WEB_MODE',
'True_value'):
#
# ESCRIBO EN EL LOG
PUMP_FREC = self.redis.hget(self.DLGID,
dic.get_dic('PUMP_FREC', 'name'))
self.logs.print_inf(
name_function,
f'MODO REMOTO => PRENDER BOMBA [ PUMP_FREC = {PUMP_FREC} ]'
)
self.logs.dlg_performance(
f'< {name_function} > MODO REMOTO => PRENDER BOMBA [ PUMP_FREC = {PUMP_FREC} ]'
)
#
elif self.redis.hget(self.DLGID,
dic.get_dic('PUMP_1_WEB_MODE',
'name')) == dic.get_dic(
'PUMP_1_WEB_MODE',
'False_value'):
# ESCRIBO EN EL LOG
self.logs.print_inf(name_function,
f'MODO REMOTO => APAGAR BOMBA')
self.logs.dlg_performance(
f'< {name_function} > MODO REMOTO => APAGAR BOMBA')
# TRABAJO EN MODO EMERGENCIA
if self.redis.hget(
self.DLGID, dic.get_dic('WEB_MODE', 'name')) == dic.get_dic(
'WEB_MODE', 'value_1') or self.redis.hget(
self.DLGID, dic.get_dic('WEB_MODE',
'name')) == dic.get_dic(
'WEB_MODE', 'value_2'):
#
# ESCRIBO EN EL LOG
self.logs.print_inf(name_function, f'MODO BOYA O TIMER')
self.logs.dlg_performance(f'< {name_function} > MODO BOYA O TIMER')
# TRABAJO CON EL SISTEMA DE REFERENCIA_1
if self.redis.hget(self.DLGID, 'flag_work_syst_ref_1') == 'SI':
#
FREC = self.redis.hget(self.DLGID, 'FREC')
#
# ESCRIBO EN EL LOG
self.logs.print_inf(
name_function,
f'TRABAJO CON LA REFERENCIA_1 [ FREC = {FREC} ]')
self.logs.dlg_performance(
f'< {name_function} > TRABAJO CON LA REFERENCIA_1 [ FREC = {FREC} ]'
)
# TRABAJO CON FRECUENCIA MAXIMA
if int(self.redis.hget(self.DLGID, 'FREC')) == 7:
self.logs.dlg_performance(
f'< {name_function} > SE ALCANZA FRECUENCIA MAXIMA')
def switch_outputs(self):
name_function = 'SWITCH_OUTPUTS'
#
# SI ESTA HABILITADO EL SWITCH_OUTPUTS
if not (self.SWITCH_OUTPUTS):
self.logs.print_inf(name_function, 'SWITCH_OUTPUTS INHABILITADO')
#
# ELIMINO EL MONITOR DE ESTADOS DE REDIS EN CASO DE QUE EXISTA
if self.redis.hexist(f'{self.DLGID}_ERROR', 'outputs_states'):
self.redis.hdel(f'{self.DLGID}_ERROR', 'outputs_states')
return
# PREPARO INDICADOR DE ESTADOS
if not (self.redis.hexist(f'{self.DLGID}_ERROR', 'outputs_states')):
self.redis.hset(f'{self.DLGID}_ERROR', 'outputs_states', 0)
outputs_states = 0
else:
outputs_states = int(
self.redis.hget(f'{self.DLGID}_ERROR', 'outputs_states'))
# DETECTO QUE TIPO DE AUTOMATISMO TENGO PARA EJECUTAR EL SWITCH DE LAS SALIDAS
if self.TYPE == 'CTRL_FREC':
# PASO POR ESTADOS
if outputs_states == 0:
DO_0 = 0
DO_1 = 0
elif outputs_states == 1:
DO_0 = 1
DO_1 = 0
elif outputs_states == 2:
DO_0 = 0
DO_1 = 1
elif outputs_states == 3:
DO_0 = 1
DO_1 = 1
if outputs_states == 3:
outputs_states = 0
else:
outputs_states += 1
# MUESTRO LOGS EN CONSOLA
self.logs.print_out(name_function, 'DO_0', DO_0)
self.logs.print_out(name_function, 'DO_1', DO_1)
# MANDO A SETEAR LAS SALIDAS
set_outs(self.DLGID, DO_0, DO_1)
# LATCHEO LAS SALIDAS
error_process.latch__outpust(self, self.DLGID)
else:
self.logs.print_inf(name_function, 'AUTOMATISMO NO RECONOCIDO')
self.logs.print_out(name_function, 'TYPE', self.TYPE)
return
# ESCRIBO EL VALO DEL ESTADO
self.redis.hset(f'{self.DLGID}_ERROR', 'outputs_states',
outputs_states)
def test_outputs(self):
'''
return True => SI EL TESTEO FUE SATISFACTORIO
return False => SI HUBO ERRORES E/S
retur None => SI TEST_OUTPUTS INHABILITADO
SI SE TRABAJA EN MODO LOCAL O HAY FALLA ELECTRICA
OTROS ERRORES
'''
name_function = 'TEST_OUTPUTS'
# SI TEST_OUTPUTS ES False INTERRUMPO LA FUNCION
# DEJO QUE SE TESTEEN LAS SALIDAS SI NO SE CARGA TEST_OUTPUTS
if not (self.TEST_OUTPUTS == None):
if not (self.TEST_OUTPUTS):
self.logs.print_inf(name_function, 'TEST_OUTPUTS INHABILITADO')
return None
# LEO EL VALOR ANTERIOR DE LAS SALIDAS
last_OUTPUTS = self.redis.hget(self.DLGID, 'last_OUTPUTS')
#
# CHEQUEO EL VALOR ANTERIOR DE LAS SALIDAS ES VALIDO
if not (last_OUTPUTS):
self.logs.print_inf(name_function,
f'NO EXISTE last_OUTPUTS en {self.DLGID}')
self.logs.print_inf(name_function, 'NO SE TESTEAN SALIDAS')
return None
#
# SELECCIONO EL TEST DE ACUERDO AL TIPO DE AUTOMATISMO
if self.TYPE == 'CTRL_FREC':
# DEFINO SALIDAS A TESTEAR
DO_0 = get_outs(self.DLGID, last_OUTPUTS, 0)
DO_1 = get_outs(self.DLGID, last_OUTPUTS, 1)
#
# DEFINO ENTRADAS A VERIFICAR
BR1 = int(read_param(self.DLGID, 'BR1'))
TM = int(read_param(self.DLGID, 'TM'))
FT1 = int(read_param(self.DLGID, 'FT1'))
# PREVEO QUE NO SE TESTEEN LAS SALIDAS BAJO MODO LOCAL O FALLA ELECTRICA
if read_param(self.DLGID, 'LM') == '1' or read_param(
self.DLGID, 'FE') == '1':
self.logs.print_in(name_function, 'LM',
read_param(self.DLGID, 'LM'))
self.logs.print_in(name_function, 'FE',
read_param(self.DLGID, 'FE'))
self.logs.print_inf(
name_function,
'NO SE TESTEAN SALIDAS POR TRABAJO EN MODO LOCAL O FALLA ELECTRICA'
)
return None
# STATE: MODO DE EMERGENCIA
if DO_0 == 0:
if TM == 0:
if not (BR1 == 0 and FT1 == 0):
self.logs.dlg_performance(
f'< ERROR_E/S > [ TM = {TM} ], [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
self.logs.print_inf(
name_function,
f'< ERROR_E/S > [ TM = {TM} ] - [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
return False
else:
self.logs.print_inf(name_function, 'OUTPUTS OK')
return True
elif TM == 1:
if not (BR1 == 1 or FT1 == 1):
self.logs.dlg_performance(
f'< ERROR_E/S > [ TM = {TM} ], [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
self.logs.print_inf(
name_function,
f'< ERROR_E/S > [ TM = {TM} ] - [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
return False
else:
self.logs.print_inf(name_function, 'OUTPUTS OK')
return True
else:
self.logs.print_inf(
name_function,
f'VALOR NO RECONOCIDO EN TM [ TM = {TM} ]')
self.logs.script_performance(
f'VALOR NO RECONOCIDO EN TM [ TM = {TM} ]')
return None
elif DO_0 == 1:
if DO_1 == 0:
if not (BR1 == 0 and FT1 == 0):
self.logs.dlg_performance(
f'< ERROR_E/S > [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
self.logs.print_inf(
name_function,
f'< ERROR_E/S > [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
return False
else:
self.logs.print_inf(name_function, 'OUTPUTS OK')
return True
elif DO_1 == 1:
if not (BR1 == 1 or FT1 == 1):
self.logs.dlg_performance(
f'< ERROR_E/S > [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
self.logs.print_inf(
name_function,
f'< ERROR_E/S > [ DO_1 = {DO_1}, DO_0 = {DO_0} ] <=> [ BR1 = {BR1}, FT1 = {FT1} ]'
)
return False
else:
self.logs.print_inf(name_function, 'OUTPUTS OK')
return True
else:
self.logs.print_inf(
name_function,
f'VALOR NO RECONOCIDO EN DO_1 [ DO_1 = {DO_1} ]')
self.logs.script_performance(
f'VALOR NO RECONOCIDO EN DO_1 [ DO_1 = {DO_1} ]')
return None
# MODO DE CONTROL
else:
self.logs.print_inf(
name_function,
f'VALOR NO RECONOCIDO EN D0_0 [ DO_0 = {DO_0} ]')
self.logs.script_performance(
f'VALOR NO RECONOCIDO EN D0_0 [ DO_0 = {DO_0} ]')
return None
def latch__outpust(self, dlgid):
if self.redis.hexist(dlgid, 'current_OUTPUTS'):
last_OUTPUTS = self.redis.hget(dlgid, 'current_OUTPUTS')
self.redis.hset(dlgid, 'last_OUTPUTS', last_OUTPUTS)
if self.redis.hget(dlgid, 'OUTPUTS') != '-1':
current_OUTPUTS = self.redis.hget(dlgid, 'OUTPUTS')
self.redis.hset(dlgid, 'current_OUTPUTS', current_OUTPUTS)
def pump_time(self, channel_pump_name, no_pump):
#
name_function = f'PUMP{no_pump}_TIME'
#
from datetime import datetime, date, time, timedelta
#
pump_state = int(read_param(self.DLGID, channel_pump_name))
#
# PREPARO VARIABLES DE TIEMPO
#
## TIEMPO TOTAL
if not (self.redis.hexist(f'{self.DLGID}_ERROR',
f'pump{no_pump}_total_time')):
self.redis.hset(f'{self.DLGID}_ERROR', f'pump{no_pump}_total_time',
'2020,1,1,0,0,0,0')
pump_total_time = datetime(2020, 1, 1, 0, 0, 0, 0)
#
# ESCRIBO LA VARIABLE DE VISUALIZACION
self.redis.hset(self.DLGID,
dic.get_dic(f'PUMP{no_pump}_TOTAL_TIME', 'name'),
'0 horas')
else:
# OBTENGO pump_total_time EN FORMATO datetime
str_pump_total_time = self.redis.hget(f'{self.DLGID}_ERROR',
f'pump{no_pump}_total_time')
lst_pump_total_time = str_pump_total_time.split(',')
pump_total_time = datetime(int(lst_pump_total_time[0]),
int(lst_pump_total_time[1]),
int(lst_pump_total_time[2]),
int(lst_pump_total_time[3]),
int(lst_pump_total_time[4]),
int(lst_pump_total_time[5]),
int(lst_pump_total_time[6]))
#
# INCREMENTO 1 MINUTO EN pump_total_time SI LA BOMBA ESTA PRENDIDA
if pump_state == 1:
# SUMO UN MINUTO AL CONTEO DE TIEMPO
pump_total_time = pump_total_time + timedelta(minutes=1)
#
# VEO LA DIFERENCIA DE TIEMPO RESPECTO A LA REFERENCIA INICIAL
delta_total_time = pump_total_time - datetime(
2020, 1, 1, 0, 0, 0, 0)
#
# CONVIERTO LA DIFERENCIA A HORAS
delta_total_time_hours = int(delta_total_time.days * 24 +
delta_total_time.seconds / 3600)
#
# ESCRIBO LA VARIABLE DE VISUALIZACION
self.redis.hset(
self.DLGID, dic.get_dic(f'PUMP{no_pump}_TOTAL_TIME',
'name'),
f'{delta_total_time_hours} horas')
#
self.logs.print_out(
name_function,
dic.get_dic(f'PUMP{no_pump}_TOTAL_TIME', 'name'),
f'{delta_total_time_hours} horas')
#
# GUARDO pump_total_time EN REDIS
str_pump_total_time = f'{pump_total_time.year},{pump_total_time.month},{pump_total_time.day},{pump_total_time.hour},{pump_total_time.minute},{pump_total_time.second},{pump_total_time.microsecond}'
self.redis.hset(f'{self.DLGID}_ERROR', f'pump{no_pump}_total_time',
str_pump_total_time)
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'
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()
class ctrlProcess(object):
'''
FUNCIONES USADAS POR ctrl_process_frec.py
'''
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 chequeo_alarmas(self):
name_function = 'CHEQUEO_ALARMAS'
# PIERTA DEL GABINETE
if read_param(self.DLGID_CTRL, 'GA') == '1':
self.logs.print_inf(name_function, 'GABINETE_ABIERTO')
# ESCRIBO LA ALARMA EN REDIS
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('GABINETE_ABIERTO', 'name'),
dic.get_dic('TX_ERROR', 'True_value'))
elif read_param(self.DLGID_CTRL, 'GA') == '0':
# ESCRIBO LA ALARMA EN REDIS
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('GABINETE_ABIERTO', 'name'),
dic.get_dic('TX_ERROR', 'False_value'))
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, GA = {read_param(self.DLGID_CTRL,'GA')}"
)
# DEJAR REGISTRO DEL ERROR
self.logs.script_performance(
f"error in {name_function}, GA = {read_param(self.DLGID_CTRL,'GA')}"
)
# FALLA ELECTRICA
if read_param(self.DLGID_CTRL, 'FE') == '1':
self.logs.print_inf(name_function, 'FALLA ELECTRICA')
# ESCRIBO LA ALARMA EN REDIS
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('FALLA_ELECTRICA', 'name'),
dic.get_dic('FALLA_ELECTRICA', 'True_value'))
elif read_param(self.DLGID_CTRL, 'FE') == '0':
# ESCRIBO LA ALARMA EN REDIS
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('FALLA_ELECTRICA', 'name'),
dic.get_dic('FALLA_ELECTRICA', 'False_value'))
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, FE = {read_param(self.DLGID_CTRL,'FE')}"
)
# DEJAR REGISTRO DEL ERROR
self.logs.script_performance(
f"error in {name_function}, FE = {read_param(self.DLGID_CTRL,'FE')}"
)
# FALLA TERMICA 1
if read_param(self.DLGID_CTRL, 'FT1') == '1':
self.logs.print_inf(name_function, 'FALLA TERMICA 1')
# ESCRIBO LA ALARMA EN REDIS
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('FALLA_TERMICA_1', 'name'),
dic.get_dic('FALLA_ELECTRICA', 'True_value'))
elif read_param(self.DLGID_CTRL, 'FT1') == '0':
# ESCRIBO LA ALARMA EN REDIS
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('FALLA_TERMICA_1', 'name'),
dic.get_dic('FALLA_ELECTRICA', 'False_value'))
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, FT1 = {read_param(self.DLGID_CTRL,'FT1')}"
)
# DEJAR REGISTRO DEL ERROR
self.logs.script_performance(
f"error in {name_function}, FT1 = {read_param(self.DLGID_CTRL,'FT1')}"
)
def chequeo_sensor(self, dlgid, channel_came):
name_function = 'CHEQUEO_SENSOR'
# SI NO EXISTE LA VARIABLE ERR_SENSOR EN DLGID_REF LA CREO CON VALOR NO
if not (self.redis.hexist(self.DLGID_REF, 'ERR_SENSOR')):
self.redis.hset(self.DLGID_REF, 'ERR_SENSOR', 'NO')
return True
def modo_remoto(self):
name_function = 'MODO_REMOTO'
pump_state = False
#
# SI NO EXISTE PUMP_FREC LO CREO CON VALOR 100%
if not (self.redis.hexist(self.DLGID_CTRL,
dic.get_dic('PUMP_FREC', 'name'))):
self.redis.hset(self.DLGID_CTRL, dic.get_dic('PUMP_FREC', 'name'),
dic.get_dic('PUMP_FREC', 'True_value'))
PUMP_FREC = 7
else:
PUMP_FREC = int((int(
self.redis.hget(self.DLGID_CTRL,
dic.get_dic('PUMP_FREC', 'name')))) / 100 * 7)
# SI NO EXISTE SW2 LO CREO CON VALOR OFF
if not (self.redis.hexist(self.DLGID_CTRL, 'SW2')):
self.redis.hset(self.DLGID_CTRL, 'SW2', 'OFF')
#
# REVISO LA ACCION TOMADA EN EL SERVER RESPECTO A LA BOMBA
if self.redis.hget(self.DLGID_CTRL, 'SW2') == 'ON':
self.logs.print_inf(name_function,
f'PRENDER BOMBA [ PUMP_FREC = {PUMP_FREC} ]')
#
pump_state = True
#
elif self.redis.hget(self.DLGID_CTRL, 'SW2') == 'OFF':
self.logs.print_inf(name_function, 'APAGAR BOMBA')
#
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, SW2 = {read_param(self.DLGID_CTRL,'SW2')}"
)
# DEJAR REGISTRO DEL ERROR
self.logs.script_performance(
f"error in {name_function}, SW2 = {read_param(self.DLGID_CTRL,'SW2')}"
)
# REVISO ACCION DE LAS SALIDAS
if self.ENABLE_OUTPUTS:
if pump_state:
# SETEO LA FRECUENCIA A LA QUE SE QUIERE PRENDER LA BOMBA
if self.TYPE_IN_FREC == 'NPN':
douts(self.DLGID_CTRL, not_dec(PUMP_FREC, 3))
elif self.TYPE_IN_FREC == 'PNP':
douts(self.DLGID_CTRL, PUMP_FREC)
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, TYPE_IN_FREC = {self.TYPE_IN_FREC}"
)
self.logs.script_performance(
f"error in {name_function}, TYPE_IN_FREC = {self.TYPE_IN_FREC}"
)
# MANDOLA ACCION A LA BOMBA
pump1(self.DLGID_CTRL, pump_state)
else:
self.logs.print_inf(
name_function,
f"SALIDAS DESCACTIVADAS [ENABLE_OUTPUTS = {self.ENABLE_OUTPUTS}]"
)
self.logs.script_performance(
f"{name_function} ==> SALIDAS DESCACTIVADAS [ENABLE_OUTPUTS = {self.ENABLE_OUTPUTS}]"
)
def control_sistema(self, dlgid_ref, channel_ref, MAG_REF):
name_function = 'CONTROL_SISTEMA'
WND = 0.1 # VENTANA DE FRECUENCIA ABIERTA
# SI NO EXISTE LMIN LO CREO CON VALOR 1
if not (self.redis.hexist(self.DLGID_CTRL,
dic.get_dic('MAG_REF', 'name'))):
self.redis.hset(self.DLGID_CTRL, dic.get_dic('MAG_REF', 'name'),
dic.get_dic('MAG_REF', 'True_value'))
#
#ESTABLEZCO LMIN Y LMAX A PARTIR DE WND
LMIN = MAG_REF - WND
LMAX = MAG_REF + WND
#
# LEO EL CANAL DE REFERENCIA
if self.redis.hexist(dlgid_ref, 'LINE'):
REF = float(read_param(dlgid_ref, channel_ref))
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, {self.CHANNEL_REF} = {read_param(self.DLGID_CTRL,self.CHANNEL_REF)}"
)
# MUESTRO LOGS
self.logs.print_in(name_function, 'ENABLE_OUTPUTS',
self.ENABLE_OUTPUTS)
self.logs.print_in(name_function, 'TYPE_IN_FREC', self.TYPE_IN_FREC)
self.logs.print_in(name_function, 'MAG_REF', MAG_REF)
self.logs.print_in(name_function, 'WND', WND)
self.logs.print_in(name_function, 'REF', REF)
# SI NO FREC LMIN LO CREO CON VALOR 0
if not (self.redis.hexist(self.DLGID_CTRL, 'FREC')):
self.redis.hset(self.DLGID_CTRL, 'FREC', 0)
# LEO EL VALOR DE LA FRECUENCIA ACTUAL
FREC = int(self.redis.hget(self.DLGID_CTRL, 'FREC'))
self.logs.print_in(name_function, 'LAST_FREC', FREC)
if REF < LMIN:
self.logs.print_inf(name_function, 'PRESION BAJA')
if FREC < 7:
FREC += 1
self.logs.print_inf(name_function, 'SE AUMENTA LA FRECUENCIA')
#
else:
self.logs.print_inf(name_function,
'SE ALCANZA FRECUENCIA MAXIMA')
#self.logs.dlg_performance(f'< {name_function} > SE ALCANZA FRECUENCIA MAXIMA')
elif REF > LMAX:
self.logs.print_inf(name_function, 'PRESION ALTA')
if FREC > 0:
FREC -= 1
self.logs.print_inf(name_function,
'SE DISMINUYE LA FRECUENCIA')
else:
self.logs.print_inf(name_function,
'PRESION DENTRO DEL RANGO SELECCIONADO')
# MANDO A PRENDER LA BOMBA
pump1(self.DLGID_CTRL, True)
# CHEQUEO SI LAS SALIDAS TIENEN QUE ACOPLARSE A ENTRADAS NPN o PNP Y MANDO A SETEAR EN CASO DE ENABLE_OUTPUTS
if self.ENABLE_OUTPUTS:
if self.TYPE_IN_FREC == 'NPN':
douts(self.DLGID_CTRL, not_dec(FREC, 3))
elif self.TYPE_IN_FREC == 'PNP':
douts(self.DLGID_CTRL, FREC)
else:
self.logs.print_inf(
name_function,
f"error in {name_function}, TYPE_IN_FREC = {self.TYPE_IN_FREC}"
)
self.logs.script_performance(
f"error in {name_function}, TYPE_IN_FREC = {self.TYPE_IN_FREC}"
)
else:
self.logs.print_inf(
name_function,
f"SALIDAS DESCACTIVADAS [ENABLE_OUTPUTS = {self.ENABLE_OUTPUTS}]"
)
self.logs.script_performance(
f"{name_function} ==> SALIDAS DESCACTIVADAS [ENABLE_OUTPUTS = {self.ENABLE_OUTPUTS}]"
)
# GUARODO LA FRECUENCIA ACTUAL DE TRABAJO
self.logs.print_out(name_function, 'CURR_FREC', FREC)
self.redis.hset(self.DLGID_CTRL, 'FREC', FREC)
def latch__outpust(self, dlgid):
name_function = 'LATCH_OUTPUTS'
if self.redis.hexist(dlgid, 'current_OUTPUTS'):
last_OUTPUTS = self.redis.hget(dlgid, 'current_OUTPUTS')
self.redis.hset(dlgid, 'last_OUTPUTS', last_OUTPUTS)
if self.redis.hexist(dlgid, 'OUTPUTS'):
if self.redis.hget(dlgid, 'OUTPUTS') != '-1':
current_OUTPUTS = self.redis.hget(dlgid, 'OUTPUTS')
self.redis.hset(dlgid, 'current_OUTPUTS', current_OUTPUTS)
else:
self.logs.print_inf(name_function,
f'NO EXISTE OUTPUTS EN {self.DLGID_CTRL}')
self.logs.print_inf(name_function, 'EJECUCION INTERRUMPIDA')
quit()
def show_DATA_DATE_TIME(self, dlgid):
#
name_function = 'SHOW_DATA_DATE_TIME'
#
DATA_DATE_TIME = f"{read_param(dlgid, 'DATE')}_{read_param(dlgid, 'TIME')}"
#
self.redis.hset(dlgid, dic.get_dic('DATA_DATE_TIME', 'name'),
DATA_DATE_TIME)
#
self.logs.print_out(name_function, f'[{dlgid}] - DATA_DATE_TIME',
DATA_DATE_TIME)
def show_pump1_state(self, channel_pump_name):
#
name_function = 'SHOW_PUMP1_STATE'
#
pump1_state = int(read_param(self.DLGID_CTRL, channel_pump_name))
#
if pump1_state == 1:
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('PUMP1_STATE', 'name'),
dic.get_dic('PUMP1_STATE', 'True_value'))
self.logs.print_out(name_function,
dic.get_dic('PUMP1_STATE', 'name'),
dic.get_dic('PUMP1_STATE', 'True_value'))
elif pump1_state == 0:
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('PUMP1_STATE', 'name'),
dic.get_dic('PUMP1_STATE', 'False_value'))
self.logs.print_out(name_function,
dic.get_dic('PUMP1_STATE', 'name'),
dic.get_dic('PUMP1_STATE', 'False_value'))
def show_work_frequency(self):
name_function = 'SHOW_WORK_FREQUENCY'
#str_PROGRAMMED_FREC = self.redis.hget(self.DLGID_CTRL, 'PROGRAMMED_FREC')
#str_PROGRAMMED_FREC = self.conf.lst_get('DLGID_CTRL')
lst_PROGRAMMED_FREC = self.PROGRAMMED_FREC.split('/')
if self.redis.hexist(self.DLGID_CTRL, 'FREC'):
FREC = int(self.redis.hget(self.DLGID_CTRL, 'FREC'))
WORKING_FREQUENCY = lst_PROGRAMMED_FREC[FREC]
else:
self.logs.print_inf(
name_function,
f'NO EXISTE LA VARIABLE FREC EN {self.DLGID_CTRL}')
self.logs.print_inf(name_function,
'NO SE MUESTRA FRECUENCIA DE TRABAJO')
return False
if FREC == 0:
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('WORKING_FREC', 'name'),
f'[MIN] {WORKING_FREQUENCY} Hz')
self.logs.print_out(name_function,
dic.get_dic('WORKING_FREC', 'name'),
f'[MIN] {WORKING_FREQUENCY} Hz')
elif FREC == 7:
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('WORKING_FREC', 'name'),
f'[MAX] {WORKING_FREQUENCY} Hz')
self.logs.print_out(name_function,
dic.get_dic('WORKING_FREC', 'name'),
f'[MAX] {WORKING_FREQUENCY} Hz')
else:
self.redis.hset(self.DLGID_CTRL,
dic.get_dic('WORKING_FREC',
'name'), f'{WORKING_FREQUENCY} Hz')
self.logs.print_out(name_function,
dic.get_dic('WORKING_FREC', 'name'),
f'{WORKING_FREQUENCY} Hz')
def pump_time(self, channel_pump_name, no_pump):
#
name_function = f'PUMP{no_pump}_TIME'
#
from datetime import datetime, date, time, timedelta
#
pump_state = int(read_param(self.DLGID_CTRL, channel_pump_name))
#
# PREPARO VARIABLES DE TIEMPO
#
## TIEMPO TOTAL
if not (self.redis.hexist(self.DLGID_CTRL,
f'pump{no_pump}_total_time')):
self.redis.hset(self.DLGID_CTRL, f'pump{no_pump}_total_time',
'2020,1,1,0,0,0,0')
pump_total_time = datetime(2020, 1, 1, 0, 0, 0, 0)
#
# ESCRIBO LA VARIABLE DE VISUALIZACION
self.redis.hset(self.DLGID_CTRL,
dic.get_dic(f'PUMP{no_pump}_TOTAL_TIME', 'name'),
'0 horas')
else:
# OBTENGO pump_total_time EN FORMATO datetime
str_pump_total_time = self.redis.hget(self.DLGID_CTRL,
f'pump{no_pump}_total_time')
lst_pump_total_time = str_pump_total_time.split(',')
pump_total_time = datetime(int(lst_pump_total_time[0]),
int(lst_pump_total_time[1]),
int(lst_pump_total_time[2]),
int(lst_pump_total_time[3]),
int(lst_pump_total_time[4]),
int(lst_pump_total_time[5]),
int(lst_pump_total_time[6]))
#
# INCREMENTO 1 MINUTO EN pump_total_time SI LA BOMBA ESTA PRENDIDA
if pump_state == 1:
# SUMO UN MINUTO AL CONTEO DE TIEMPO
pump_total_time = pump_total_time + timedelta(minutes=1)
#
# VEO LA DIFERENCIA DE TIEMPO RESPECTO A LA REFERENCIA INICIAL
delta_total_time = pump_total_time - datetime(
2020, 1, 1, 0, 0, 0, 0)
#
# CONVIERTO LA DIFERENCIA A HORAS
delta_total_time_hours = int(delta_total_time.days * 24 +
delta_total_time.seconds / 3600)
#
# ESCRIBO LA VARIABLE DE VISUALIZACION
self.redis.hset(
self.DLGID_CTRL,
dic.get_dic(f'PUMP{no_pump}_TOTAL_TIME', 'name'),
f'{delta_total_time_hours} horas')
#
self.logs.print_out(
name_function,
dic.get_dic(f'PUMP{no_pump}_TOTAL_TIME', 'name'),
f'{delta_total_time_hours} horas')
#
# GUARDO pump_total_time EN REDIS
str_pump_total_time = f'{pump_total_time.year},{pump_total_time.month},{pump_total_time.day},{pump_total_time.hour},{pump_total_time.minute},{pump_total_time.second},{pump_total_time.microsecond}'
self.redis.hset(self.DLGID_CTRL, f'pump{no_pump}_total_time',
str_pump_total_time)
def delta_mag(self):
'''
Escribe en DLGID_CTRL/delta_ref_ref1 la diferencia entre las magnitudes de la referencia y la referencia 1
'''
name_function = 'DELTA_MAG'
if (self.DLGID_REF_1 != '' and self.CHANNEL_REF_1 != ''):
#
mag_in_ref = float(read_param(self.DLGID_REF, self.CHANNEL_REF))
mag_in_ref_1 = float(
read_param(self.DLGID_REF_1, self.CHANNEL_REF_1))
delta_ref1_ref = round(mag_in_ref_1 - mag_in_ref, 2)
#
# ESCRIBO EN REDIS LA DIFERENCIA
self.redis.hset(self.DLGID_CTRL, 'delta_ref1_ref', delta_ref1_ref)
#
# IMPRIMO LOGS
self.logs.print_out(name_function, 'delta_ref1_ref',
delta_ref1_ref)
else:
self.redis.hdel(self.DLGID_CTRL, 'delta_ref1_ref')
self.logs.print_inf(name_function,
'NO HAY SISTEMA DE REFERENCIA 1')