class EjecutarPrograma():
def __init__(self, listaDeVariables):
self.listaDeVariables = listaDeVariables
self.TON_02 = Temporizador("TON_02", 0.05)
self.TON_03 = Temporizador("TON_03", 4)
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def run(self):
self.funcionando = True
while (self.funcionando):
self.TON_02.entrada = not self.TON_02.salida
self.TON_02.actualizar()
if self.TON_02.salida:
self.listaDeVariables.imprimirX()
print("", end="\t")
self.listaDeVariables.imprimirY()
print("")
self.TON_03.entrada = not self.TON_03.salida
self.TON_03.actualizar()
if self.TON_03.salida:
print(">>>>>>>>>>>>>>>>>>>>>>>>>Cambiando Estado")
#print (">>>>>>>>>>>>>>>>>>>>>>>>>Valor actual ", self.listaDeVariables.Y[3].obtenerValor())
self.listaDeVariables.Y[3].establecerValor(
not self.listaDeVariables.Y[3].obtenerValor())
class ActualizarVariables (threading.Thread):
def __init__(self, nombre = None, objeto = None, controlador = None, args=()):
threading.Thread.__init__ (self, name = nombre)
self.controlador = controlador
self.contador = 0
self.TON_00 = Temporizador("TON_00", 0.1)
self.TON_01 = Temporizador("TON_01", 0.5)
def run (self):
self.funcionando = True
while (self.funcionando):
self.TON_00.entrada = not self.TON_00.salida
self.TON_00.actualizar()
if self.TON_00.salida and self.contador < 100:
self.contador += 1
if self.contador == 3:
self.controlador.interfaz.notebook.selectpage(2)
self.controlador.interfaz.notebook.selectpage(1)
self.controlador.interfaz.notebook.selectpage(0)
#print ("Imprimiendo contador %d" %self.contador)
self.TON_01.entrada = not self.TON_01.salida
self.TON_01.actualizar()
if self.TON_01.salida:
pass
#TODO: actualizarFecha()
time.sleep(0.001)
print ("Hilo terminado", self.name)
def detener (self):
self.funcionando = False
class EjecutarPrograma():
def __init__(self, listaDeVariables):
self.listaDeVariables = listaDeVariables
self.TON_01 = Temporizador("TON_01", 0.5)
self.TON_02 = Temporizador("TON_02", 0.5)
self.TON_03 = Temporizador("TON_03", 2)
self.TON_04 = Temporizador("TON_04", 15)
self.aux = 0
self.aux_2 = 0
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def run(self):
self.funcionando = True
while (self.funcionando):
self.TON_02.entrada = not self.TON_02.salida
self.TON_02.actualizar()
if self.TON_02.salida:
"""
print ("\n", end='')
self.listaDeVariables.imprimirX(8)
print ("", end="\t")
self.listaDeVariables.imprimirY(8)
print ("", end="\t")
self.listaDeVariables.imprimirZ()
print ("", end=" ")
"""
self.TON_01.entrada = self.aux
self.TON_01.actualizar()
class Cajero:
"""
Clase utulizada para administrar el cajero
"""
def __init__(self, variables):
self.tipo_controladora = ""
self.encriptacion = ""
self.nombre_sucursal = ""
self.localidad_sucursal = ""
self.server_ip_address = ""
self.ip_address = ""
self.id = ""
self.id_sucursal = ""
self.politicas = ""
#-------------------- Leer configuracion
self.vizualizar = ""
#-------------------- Modo operacion
self.listaDeVariables = variables
self.controladora = ""
#-------------------- Diccionatrios
self.informacion = ""
self.variables = ""
self.interfaz = ""
self.inicializar()
#-------------------- Secuencia cobro
self.secuencia_cobro = 0
self.monto_ingresar = 0
self.monto_ingresado = 0
self.monto_a_dispensar = 0
self.descuento = 0
#-------------------- Secuencia lectura boleto
self.boleto = ""
self.folio = ""
self.expedidora = ""
self.hora_entrada = ""
self.fecha_entrada = ""
self.tiempo_total = ""
self.TON_01 = Temporizador("TON_01", 2.5)
print("Iniciando Cajero.")
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def run(self):
self.funcionando = True
listaDeVariables_tmp = 0
while (self.funcionando):
time.sleep(1)
self.TON_01.entrada = not self.TON_01.salida
self.TON_01.actualizar()
print(" #-------------------- Secuencia de cobro: ",
self.secuencia_cobro)
if self.secuencia_cobro == 0:
#-------------------- Validar lectura de boleto
boleto_valido = self.validar_lectura_boleto()
if boleto_valido == 1:
self.secuencia_cobro = 1
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 1:
#-------------------- Validar estado de dispositivos
validacion = self.validar_estado_dispositivos()
if validacion == 1:
self.secuencia_cobro = 2
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 2:
#-------------------- Habilitar dispositivos de cobro
self.habilitar_dispositivos_cobro()
resultado = 1
if resultado == 1:
listaDeVariables_tmp = self.listaDeVariables
self.secuencia_cobro = 3
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 3:
#-------------------- Actualizar variables
monto_completado = self.actualiza_cobro(listaDeVariables_tmp)
self.variables.update(interfaz=2)
if monto_completado == 1:
self.secuencia_cobro = 4
else:
self.secuencia_cobro = 3
if self.secuencia_cobro == 4:
#-------------------- Entregar cambio y validar operacion
operacion_validada = self.validar_operacion()
if operacion_validada == 1:
self.secuencia_cobro = 7
else:
self.secuencia_cobro = 5
if self.secuencia_cobro == 5:
#-------------------- Operacion no valida: Entregar comprobante de error y pedir asistencia
combrobante_error = self.secuencia_error()
if combrobante_error == 1:
self.secuencia_cobro = 7
else:
print("No se pudo expedir el comprobante de error")
if self.secuencia_cobro == 7:
#-------------------- Cajero suspendido
self.cajero_suspendido()
if self.secuencia_cobro == 8:
#-------------------- Ofrecer ticket , registrar operacion y reiniciar valores
operacion_finalizada = self.finalizar_operacion()
self.secuencia_cobro = 0
fecha = time.strftime("%Y-%m-%d %H:%M:%S")
self.variables.update(monto_ingresar=self.monto_ingresar)
self.variables.update(monto_ingresado=self.monto_ingresado)
self.variables.update(monto_a_dispensar=self.monto_a_dispensar)
self.variables.update(folio=self.folio)
self.variables.update(hora_entrada=self.hora_entrada)
self.variables.update(tiempo_total=self.tiempo_total)
self.variables.update(descuento=self.descuento)
self.variables.update(fecha=fecha)
#sensores.update(monto=i)
#response = cajero.enviar(informacion)
response = self.enviar(self.variables)
print(response)
def inicializar(self):
shutil.copy(ruta + "configParser/configuracion.ini",
ruta + "configParser/configuracion_respaldo.ini")
shutil.copy(ruta + "configParser/sensores.ini",
ruta + "configParser/sensores_respaldo.ini")
self.tipo_controladora = 0
#-------------------- Leer configuracion
self.vizualizar = viewData('configuracion.ini')
self.leer_configuracion()
#-------------------- Modo operacion
self.controladora = self.establecerControladora(self.listaDeVariables)
#-------------------- Establecer interfaz
self.interfaz = Interfaz('http://127.0.0.1:8000/hook/',
{'Content-Type': 'application/json'})
self.interfaz.establecer_lista_de_variables(self.listaDeVariables)
time.sleep(5)
self.informacion = dict(
interfaz=0,
X_02=self.listaDeVariables.dispositivos[0].variables[2].
obtenerValor(),
X_01=self.listaDeVariables.dispositivos[0].variables[1].
obtenerValor(),
X_03=self.listaDeVariables.dispositivos[0].variables[3].
obtenerValor(),
X_04=self.listaDeVariables.dispositivos[0].variables[4].
obtenerValor(),
X_05=self.listaDeVariables.dispositivos[0].variables[5].
obtenerValor(),
X_06=self.listaDeVariables.dispositivos[0].variables[6].
obtenerValor(),
X_07=self.listaDeVariables.dispositivos[0].variables[7].
obtenerValor(),
)
self.variables = dict(
monto_ingresar=1,
monto_ingresado=1,
monto_a_dispensar=0,
folio=0,
hora_entrada=0,
tiempo_total="",
interfaz=1,
descuento=0,
X_08=self.listaDeVariables.dispositivos[0].variables[8].
obtenerValor(),
X_09=self.listaDeVariables.dispositivos[0].variables[9].
obtenerValor(),
X_10=self.listaDeVariables.dispositivos[0].variables[10].
obtenerValor(),
X_11=self.listaDeVariables.dispositivos[0].variables[11].
obtenerValor(),
X_12=self.listaDeVariables.dispositivos[0].variables[12].
obtenerValor(),
X_13=self.listaDeVariables.dispositivos[0].variables[13].
obtenerValor(),
X_14=self.listaDeVariables.dispositivos[0].variables[14].
obtenerValor(),
X_15=self.listaDeVariables.dispositivos[0].variables[15].
obtenerValor(),
X_16=self.listaDeVariables.dispositivos[0].variables[16].
obtenerValor(),
X_17=self.listaDeVariables.dispositivos[0].variables[17].
obtenerValor(),
X_18=self.listaDeVariables.dispositivos[0].variables[18].
obtenerValor(),
X_19=self.listaDeVariables.dispositivos[0].variables[19].
obtenerValor(),
X_20=self.listaDeVariables.dispositivos[0].variables[20].
obtenerValor(),
X_21=self.listaDeVariables.dispositivos[0].variables[21].
obtenerValor(),
X_22=self.listaDeVariables.dispositivos[0].variables[22].
obtenerValor(),
)
self.deshabilitar_dispositivos_cobro()
time.sleep(2)
pass
#def establecerControladora(self,listaDeVariables):
def establecerControladora(self, tipo):
if self.tipo_controladora == 0:
#controladora = Controladora(listaDeVariable s, tarjeta = Controladora.TARJETA_DE_INTERFAZ_ARDUINO)
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_ARDUINO,
tipoDeControladora=Controladora.CONTROLADORA_PARA_CAJERO)
if self.tipo_controladora == 1:
controladora = Controladora(listaDeVariables,
tarjeta=Controladora.TARJETA_DE_PULSO)
if self.tipo_controladora == 2:
controladora = Controladora(
listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_BLANCA)
if self.tipo_controladora == 3:
controladora = Controladora(
listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_ARDUINO)
return controladora
def leer_configuracion(self):
#self.vizualizar.getInfo()
self.tipo_controladora = int(
self.vizualizar.getValue('CONTROLADORA', 'tipo_tc'))
self.encriptacion = int(
self.vizualizar.getValue('GENERAL', 'encriptacion'))
self.nombre_sucursal = self.vizualizar.getValue(
'GENERAL', 'nombre_sucursal')
self.localidad_sucursal = self.vizualizar.getValue(
'GENERAL', 'localidad_sucursal')
self.server_ip_address = self.vizualizar.getValue(
'RED', 'server_ip_address')
self.ip_address = self.vizualizar.getValue('RED', 'ip_addeess')
self.id = int(self.vizualizar.getValue('GENERAL', 'id'))
self.id_sucursal = int(
self.vizualizar.getValue('GENERAL', 'id_sucursal'))
self.politicas = self.vizualizar.getValue('GENERAL', 'politicas')
def enviar(self, datos):
self.interfaz.enviar(Interfaz.PROCESO, datos)
print(self.interfaz.response)
return self.interfaz.response
def operacion_cobro(self):
pass
def actualiza_cobro(self, listaDeVariables_tmp):
variables_tmp = dict(
X_10_tmp=listaDeVariables_tmp.dispositivos[0].variables[10].
obtenerValor(),
X_13_tmp=listaDeVariables_tmp.dispositivos[0].variables[13].
obtenerValor(),
X_16_tmp=listaDeVariables_tmp.dispositivos[0].variables[16].
obtenerValor(),
X_19_tmp=listaDeVariables_tmp.dispositivos[0].variables[19].
obtenerValor(),
X_22_tmp=listaDeVariables_tmp.dispositivos[0].variables[22].
obtenerValor(),
)
#ingreso_1 = (int(self.variables.get('X_10')) - int(variables_tmp.get('X_10_tmp')))*int(self.variables.get('X_08'))
#ingreso_2 = (int(self.variables.get('X_13')) - int(variables_tmp.get('X_13_tmp')))*int(self.variables.get('X_11'))
#ingreso_3 = (int(self.variables.get('X_16')) - int(variables_tmp.get('X_16_tmp')))*int(self.variables.get('X_14'))
#ingreso_4 = (int(self.variables.get('X_19')) - int(variables_tmp.get('X_19_tmp')))*int(self.variables.get('X_17'))
#ingreso_5 = (int(self.variables.get('X_22')) - int(variables_tmp.get('X_22_tmp')))*int(self.variables.get('X_20'))
ingreso_1 = (int(variables_tmp.get('X_10_tmp')) - int(
self.variables.get('X_10'))) * int(self.variables.get('X_08'))
ingreso_2 = (int(variables_tmp.get('X_13_tmp')) - int(
self.variables.get('X_13'))) * int(self.variables.get('X_11'))
ingreso_3 = (int(variables_tmp.get('X_16_tmp')) - int(
self.variables.get('X_16'))) * int(self.variables.get('X_14'))
ingreso_4 = (int(variables_tmp.get('X_19_tmp')) - int(
self.variables.get('X_19'))) * int(self.variables.get('X_17'))
ingreso_5 = (int(variables_tmp.get('X_22_tmp')) - int(
self.variables.get('X_22'))) * int(self.variables.get('X_20'))
print("Denominacion 1:", ingreso_1)
print("Denominacion 2:", ingreso_2)
print("Denominacion 3:", ingreso_3)
print("Denominacion 4:", ingreso_4)
print("Denominacion 5:", ingreso_5)
self.monto_ingresado = ingreso_1 + ingreso_2 + ingreso_3 + ingreso_4 + ingreso_5
#self.monto_ingresado = self.monto_ingresado * (-1)
self.monto_a_dispensar = self.monto_ingresar - self.monto_ingresado
print("Monto ingresado:", self.monto_ingresado)
print("Diferencia monto:", self.monto_a_dispensar)
return self.monto_a_dispensar
def probar(self):
return 0
def validar_estado_dispositivos(self):
return 1
def validar_operacion(self):
if self.monto_a_dispensar:
self.dispensar_dinero(self.monto_a_dispensar)
return 1
def calcular_tarifa(self):
horaBoleto = self.hora_entrada.split(':', 2)
fechaAMD = self.fecha_entrada.split('-')
print(fechaAMD)
fechaAMD = fechaAMD[2] + "-" + fechaAMD[1] + "-" + fechaAMD[0]
dh = self.restar_hora(horaBoleto, fechaAMD.split('-'))
dias = dh[0]
horas = dh[1]
tiempo_total = dh[2]
print("Tiempo_total: ", dias, horas)
self.tiempo_total = tiempo_total
#self.tiempo_total = str(dias)+" "+str(horas)
self.monto_ingresar = 15
def recargar(self):
return 0
def dispensar_dinero(self, monto):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
Monedero.MONEDERO_DAR_CAMBIO, monto)
def recibir_dinero(self):
return 1
#self.listaDeVariables.dispositivos[5].ejecutarInstruccion(Monedero.MONEDERO_DAR_CAMBIO, monto)
def validar_lectura_boleto(self):
#self.boleto = "M,60,1,26'03'2020,10Ñ30Ñ12"
leerArch = open(ruta + "lectura.txt", "r")
folio = leerArch.readline().rstrip("\n")
if (folio != ''):
self.boleto = "M,60,1,26'03'2020,10Ñ30Ñ12"
self.boleto = self.boleto.replace("'", '-')
self.boleto = self.boleto.replace("Ñ", ':')
boleto_tmp = self.boleto.split(',')
self.folio = boleto_tmp[1]
self.expedidora = boleto_tmp[2]
self.hora_entrada = boleto_tmp[4]
self.fecha_entrada = boleto_tmp[3]
print("Boleto detectado: ", self.boleto)
print("Folio: ", self.folio, self.expedidora, self.hora_entrada,
self.fecha_entrada)
self.calcular_tarifa()
leerArch.close()
leerArch = open(ruta + "lectura.txt", "w")
leerArch.write('')
leerArch.close()
return 1
else:
leerArch.close()
return 0
def registrar_pago(self):
return 1
def ejecutar_programa(self):
pass
def secuencia_error(self):
return 1
def finalizar_operacion(self):
return 1
def cajero_suspendido(self):
return 1
def deshabilitar_dispositivos_cobro(self):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
self.listaDeVariables.dispositivos[0].MONEDERO_DESHABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(
self.listaDeVariables.dispositivos[1].BILLETERO_DESHABILITAR)
def habilitar_dispositivos_cobro(self):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
self.listaDeVariables.dispositivos[0].MONEDERO_HABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(
self.listaDeVariables.dispositivos[1].BILLETERO_HABILITAR)
def restar_hora(self, horab, fechab):
fechaBoleto = datetime.strptime(
str(fechab[0]) + str(fechab[1]) + str(fechab[2]), '%Y%m%d').date()
horaBoleto = datetime.strptime(
str(horab[0]) + ':' + str(horab[1]) + ':' + str(horab[2]),
'%H:%M:%S').time()
fechaActual = datetime.now().date()
horaActual = datetime.now().time()
horayFechaBoleto = datetime.now().combine(fechaBoleto, horaBoleto)
horayFechaActual = datetime.now().combine(fechaActual, horaActual)
restaFechas = horayFechaActual - horayFechaBoleto
aux_dif = (str(restaFechas).split('.', 1))[0]
dias = int(restaFechas.days)
horas = int(restaFechas.seconds / 3600)
print("****RES:", restaFechas)
return dias, horas, aux_dif
class EjecutarPrograma():
def __init__(self, listaDeVariables):
self.listaDeVariables = listaDeVariables
self.TON_01 = Temporizador("TON_01", 0.5)
self.TON_02 = Temporizador("TON_02", 0.5)
self.TON_03 = Temporizador("TON_03", 2)
self.TON_04 = Temporizador("TON_04", 15)
self.aux = 0
self.aux_2 = 0
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def run(self):
self.funcionando = True
while (self.funcionando):
self.TON_02.entrada = not self.TON_02.salida
self.TON_02.actualizar()
if self.TON_02.salida:
"""
print ("\n", end='')
self.listaDeVariables.imprimirX(8)
print ("", end="\t")
self.listaDeVariables.imprimirY(8)
print ("", end="\t")
self.listaDeVariables.imprimirZ()
print ("", end=" ")
"""
self.TON_01.entrada = self.aux
self.TON_01.actualizar()
if self.TON_01.salida:
self.aux = 0
if self.listaDeVariables.X[3].obtenerValor() and not self.aux:
#print ("Se enviara instruccion")
#self.listaDeVariables.dispositivos[0].ejecutarInstruccion(Monedero.MONEDERO_IMPRIMIR)
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
self.listaDeVariables.dispositivos[0].
MONEDERO_SOLICITAR_CAMBIO, 2)
self.aux = 1
self.TON_03.entrada = not self.TON_03.salida
self.TON_03.actualizar()
if self.TON_03.salida:
# print (">>>>>>>>>>>>>>>>>>>>>>>>>Cambiando Estado", end='', flush=True)
# print (">>>>>>>>>>>>>>>>>>>>>>>>>Valor actual ", self.listaDeVariables.Y[3].obtenerValor())
# self.listaDeVariables.Y[3].establecerValor(not self.listaDeVariables.Y[3].obtenerValor())
pass
self.TON_04.entrada = not self.TON_04.salida
self.TON_04.actualizar()
if self.TON_04.salida:
print("Se activo TON_04")
if self.aux_2:
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
Monedero.MONEDERO_HABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(
Billetero.BILLETERO_HABILITAR)
self.aux_2 = 0
else:
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
Monedero.MONEDERO_DESHABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(
Billetero.BILLETERO_DESHABILITAR)
self.aux_2 = 1
class Tanque:
"""
Clase utulizada para administrar el Tanque
"""
#-------------------- Identificadores de dispositivos
MONEDERO_MDB = 1
BILLETERO_MDB = 2
HOPPER_01_CCTALK = 3
HOPPER_02_CCTALK = 4
HOPPER_03_CCTALK = 5
VALIDADOR_CCTALK = 6
BILLETERO_ACEPTADOR_ID003 = 7
BILLETERO_RECICLADOR_ID003 = 8
def __init__(self, variables, zona_id, tanque_id):
self.zona_id = zona_id
self.tanque_id = tanque_id
self.tipo_controladora = ""
self.encriptacion = ""
self.nombre_sucursal = ""
self.localidad_sucursal = ""
self.server_ip_address = ""
self.ip_address = ""
self.id = ""
self.id_sucursal = ""
self.politicas = ""
self.puerto = ""
self.reloj = ""
self.logs = ""
#-------------------- Leer configuracion
self.vizualizar = ""
#-------------------- Modo operacion
self.listaDeVariables = variables
self.tarjeta_controladora = ""
#-------------------- Diccionatrios
self.informacion = ""
self.variables = ""
#-------------------- Secuencia operacion
self.secuencia_operacion = 0
self.duracion = 0
self.nivel_completado = 0
self.horario_inicio = 0
self.horario_fin = 0
self.minutos_faltantes = 0
self.minutos_tratamiento = 0
self.contador_segundos = 0
self.hora_inicio_operacion = 0
self.estado_operacion = 1
#-------------------- Secuencia lectura boleto
#-------------------- Modelos
self.invernadero = ""
self.zona = ""
self.tratamiento = []
self.horario = ""
self.nutriente = ""
self.planta = ""
self.tanque = []
self.sensor = []
self.solucion = []
#-------------------- Interfaces
self.vista = ""
self.api = ""
self.inicializar()
self.TON_01 = Temporizador("TON_01", 2.5)
print("Iniciando Cajero.")
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def __str__(self):
return "Tanque {}: ".format(self.tanque_id)
def run(self):
self.funcionando = True
listaDeVariables_tmp = 0
self.hora_inicio_operacion = datetime.strptime(
time.strftime("%H:%M:%S"), '%H:%M:%S')
self.hora_inicio_operacion = time.time()
while (self.funcionando):
time.sleep(.8)
self.TON_01.entrada = not self.TON_01.salida
self.TON_01.actualizar()
print(" #-------------------- Secuencia de operacion: ",
self.secuencia_operacion)
#print(" #-------------------- conexion a internet: ",self.servidor.estado_internet)
#print(" #-------------------- conexion a servidor: ",self.servidor.estado_servidor)
if self.secuencia_operacion == 0:
#-------------------- Validar tratamiento
self.variables.update(cancelar_pago=0)
#self.variables.update(operacion_recarga=0)
self.variables.update(estado_operacion=self.estado_operacion)
invernadero_id = 4
tratamiento_valido = self.validar_operacion()
#self.dispensar_cambio2(583)
if tratamiento_valido == 1:
self.secuencia_operacion = 1
else:
self.secuencia_operacion = 0
if self.secuencia_operacion == 1:
#-------------------- Validar sensores
validacion = self.validar_sensores()
if validacion == 1:
self.secuencia_operacion = 2
else:
self.secuencia_operacion = 0
if self.secuencia_operacion == 2:
#-------------------- Aplicar tratamiento
validacion = self.validar_sensores()
if validacion == 1:
self.secuencia_operacion = 3
else:
self.secuencia_operacion = 0
if self.secuencia_operacion == 3:
#-------------------- Operacion nivel bajo
monto_completado = self.actualiza_cobro(listaDeVariables_tmp)
self.variables.update(interfaz=2)
if monto_completado == 1:
self.secuencia_operacion = 4
else:
self.secuencia_operacion = 3
if self.secuencia_operacion == 4:
#-------------------- Operacion llenado
operacion_validada = self.validar_operacion()
if operacion_validada == 1:
self.secuencia_operacion = 8
else:
self.secuencia_operacion = 5
if self.secuencia_operacion == 5:
#-------------------- Operacion vaciado
combrobante_error = self.secuencia_error()
if combrobante_error == 1:
self.secuencia_operacion = 7
else:
print("No se pudo expedir el comprobante de error")
if self.secuencia_operacion == 6:
#-------------------- Operacion ajuste nivel
self.variables.update(interfaz=1)
self.variables.update(cancelar_pago=2)
secuencia_exitosa = self.secuencia_ajuste_nivel()
if secuencia_exitosa == 1:
self.secuencia_operacion = 0
else:
self.secuencia_operacion = 7
print("Ocurrio un error [6]")
if self.secuencia_operacion == 7:
#-------------------- Error en la operacion
self.cajero_suspendido()
if self.secuencia_operacion == 8:
#-------------------- Finalizar operacion y reiniciar valores
operacion_finalizada = self.finalizar_operacion()
self.secuencia_operacion = 0
if self.secuencia_operacion == 9:
#-------------------- Operacion recarga
self.variables.update(operacion_recarga=2)
#self.variables.update(interfaz=2)
#operacion_finalizada = self.recargar()
fecha = time.strftime("%Y-%m-%d %H:%M:%S")
"""
self.variables.update(monto_ingresar=self.monto_ingresar)
self.variables.update(monto_ingresado=self.monto_ingresado)
self.variables.update(monto_a_dispensar=self.monto_a_dispensar)
self.variables.update(folio=self.folio)
self.variables.update(hora_entrada=self.hora_entrada)
print("te",self.tiempo_estacionado)
self.variables.update(tiempo_estacionado=self.tiempo_estacionado)
self.variables.update(descuento=self.descuento)
self.variables.update(fecha=fecha)
"""
self.variables.update(ph=self.listaDeVariables.X[1].obtenerValor())
self.variables.update(ec=self.listaDeVariables.X[2].obtenerValor())
self.variables.update(
temperatura=self.listaDeVariables.X[3].obtenerValor())
self.variables.update(
nivel=self.listaDeVariables.X[4].obtenerValor())
self.variables.update(
nivel_completado=round((self.nivel_completado * 100) /
self.minutos_tratamiento, 1))
self.variables.update(minutos_tratamiento=self.minutos_tratamiento)
self.variables.update(fecha=fecha)
self.leer_sensores(11)
#sensores.update(monto=i)
#response = cajero.enviar(informacion)
respuesta = self.enviar(self.variables)
self.validar_respuesta(respuesta)
#print(respuesta)
def inicializar(self):
#shutil.copy(ruta+"configParser/configuracion.ini", ruta+"configParser/configuracion_respaldo.ini")
#shutil.copy(ruta+"configParser/sensores.ini", ruta+"configParser/sensores_respaldo.ini")
#-------------------- Establecer vista
self.vista = Interfaz('http://127.0.0.1:8000/hook/')
self.vista.establecer_lista_de_variables(self.listaDeVariables)
body = ""
metodo = "POST"
self.vista.establecer_metodo(metodo)
self.vista.establecer_encabezado({'Content-Type': 'application/json'})
#-------------------- Establecer API
self.api = Interfaz('http://127.0.0.1:8000/api/')
self.api.establecer_lista_de_variables(self.listaDeVariables)
body = ""
metodo = "GET"
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
self.tipo_controladora = 0
#-------------------- Leer configuracion
#self.vizualizar = viewData('configuracion.ini')
self.leer_configuracion(self.zona_id)
#-------------------- Modo operacion
#####self.tarjeta_controladora = self.establecer_tarjeta_controladora(self.listaDeVariables)
#-------------------- configurar dispositivos
self.configurar_dispositivos()
#-------------------- configurar servidores
self.configurar_servidores()
self.configurar_reloj()
self.logs = GuardarLogs("log")
time.sleep(5)
self.variables = dict(
interfaz=6,
operacion_recarga=0,
nivel=0,
ph=0,
ec=0,
temperatura=0,
estado_operacion=0,
z_01=0, # Alerta Nivel
z_02=0, # Alerta PH
z_03=0, # Alerta EC
z_04=0, # Alerta Temperatura
z_05=0, # Alerta Solucion 1
z_06=0, # Alerta Solucion 2
z_07=0, # Alerta Solucion 3
z_08=0, # Alerta Solucion 4
z_09=0, # Alerta Solucion 5
z_10=0, # Alerta Placa de control
z_11=0, # Alerta Flujo de agua
z_12=0, # Alerta Bomba de extraccion
)
def obtenerEquipo(self, equipo):
return self.equipo
def obtenerControladora(self, controladora):
return self.controladora
def obtenerTarifas(self, tarifa):
return self.tarifa
def obtenerSensores(self, sensor):
return self.sensor
def obtenerDispositivos(self, dispositivo):
return self.dispositivo
def obtenerVista(self, vista):
return self.vista
def establecerPuerto(self, puerto):
self.puerto = puerto
def establecerEquipo(self, equipo):
self.equipo = equipo
def establecerControladora(self, controladora):
self.controladora = controladora
def establecerTarifas(self, tarifa):
self.tarifa = tarifa
def establecerSensores(self, sensor):
self.sensor = sensor
def establecerDispositivos(self, dispositivo):
self.dispositivo = dispositivo
def establecerVista(self, vista):
self.vista = vista
def establecer_tarjeta_controladora(self, tipo):
if self.controladora[0]['modo_operacion'] == "Expedidor":
if self.controladora[0]['tipo'] == "Controladora Arduino":
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_ARDUINO,
tipoDeControladora=Controladora.
CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
elif self.controladora[0]['tipo'] == "Controladora Raspberry":
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_BLANCA,
tipoDeControladora=Controladora.
CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
elif self.controladora[0][
'tipo'] == "Controladora Raspberry Negra":
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_NEGRA,
tipoDeControladora=Controladora.
CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
elif self.controladora[0]['tipo'] == "Controladora Pulso":
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_PULSO,
tipoDeControladora=Controladora.
CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
return 0
def obtener_tanque(self, zona_id):
#-------------------- Obtener tanques por zona seleccionada
body = ""
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/tanque/?zona={}'.format(
self.zona['id']))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
respuestas = self.api.enviar(Interfaz.PROCESO, body)
for i, respuesta in enumerate(respuestas):
if respuesta['activo'] == True:
if respuesta['id'] == self.tanque_id:
self.tanque = respuesta
#self.tanque.append(respuesta)
return self.tanque
def obtener_sensor(self, tanque_id):
#-------------------- Leer sensores por tanque seleccionado
body = ""
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/sensor/?tanque={}'.format(tanque_id))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
respuestas = self.api.enviar(Interfaz.PROCESO, body)
for i, respuesta in enumerate(respuestas):
if respuesta['activo'] == True:
self.sensor.append(respuesta)
return self.sensor
def obtener_solucion(self, soluciones):
#-------------------- Leer sensores por tanque seleccionado
for i, solucion in enumerate(soluciones):
body = ""
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/solucion/{}'.format(solucion))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado(
{'Content-Type': 'application/json'})
respuesta = self.api.enviar(Interfaz.PROCESO, body)
self.solucion.append(respuesta)
return self.solucion
def obtener_horario(self, horario):
body = ""
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/horario/{}/'.format(horario))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
self.horario = self.api.enviar(Interfaz.PROCESO, body)
def leer_configuracion(self, zona_id):
#interfaz_api = Interfaz('http://127.0.0.1:8000/api/')
### ------------------------------- Leer configuracion de equipo
body = ""
metodo = "GET"
self.api.establecer_url('http://127.0.0.1:8000/api/')
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
modelos = self.api.enviar(Interfaz.PROCESO, body)
#datos = self.api.response[0]
#print(response)
#-------------------- Leer tratamiento por zona seleccionada
body = ""
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/zona/{}/'.format(zona_id))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
respuesta = self.api.enviar(Interfaz.PROCESO, body)
self.zona = respuesta
#-------------------- Leer tratamiento por zona seleccionada
body = ""
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/tratamiento/{}/'.format(
self.zona['tratamiento_id']))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
respuesta = self.api.enviar(Interfaz.PROCESO, body)
self.tratamiento = respuesta
self.obtener_horario(self.tratamiento['horario_id'])
self.obtener_tanque(self.zona['id'])
sensores = self.obtener_sensor(self.tanque['id'])
soluciones = self.obtener_solucion(self.tratamiento['solucion_id'])
self.duracion = int(self.tratamiento['duracion'])
self.nivel_completado = int(self.tratamiento['nivel_completado'])
self.horario_inicio = datetime.strptime(self.horario['horario_inicio'],
'%H:%M:%S')
self.horario_fin = datetime.strptime(self.horario['horario_fin'],
'%H:%M:%S')
self.minutos_tratamiento = (
(self.horario_fin - self.horario_inicio).seconds) / 60
self.minutos_faltantes = self.minutos_tratamiento * self.duracion
self.minutos_tratamiento = self.minutos_tratamiento * self.duracion
"""
#-------------------- Leer sensores por tanque seleccionado
body = ""
metodo = "GET"
self.api.establecer_url('http://127.0.0.1:8000/api/sensor/?tanque={}'.format(self.tanque[0]['id']))
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
respuestas = self.api.enviar(Interfaz.PROCESO,body)
self.sensor = respuestas
if isinstance(modelos, (dict)):
print("### -------------------------------Configuracion de equipo ")
for i,modelo in enumerate(modelos):
if modelo != 'transaccion' and modelo != 'servicio':
self.api.establecer_url('http://127.0.0.1:8000/api/{}/'.format(modelo))
campos = self.api.enviar(Interfaz.PROCESO,body)
if modelo == "invernadero":
self.invernaderos = campos
if modelo == "zona":
self.zona = campos
if modelo == "tratamiento":
self.tratamiento = campos
if modelo == "horario":
self.horario = campos
if modelo == "solucion":
self.solucion = campos
if modelo == "nutriente":
self.nutriente = campos
if modelo == "tanque":
self.tanque = campos
if modelo == "sensor":
self.sensor = campos
if isinstance(campos, (list)):
for i,campo in enumerate(campos):
print("### -------------------------------Configuracion de {} {}".format(modelo,i+1))
for valor in campo:
print(valor + " : " + str(campo[valor]))
for i,tratamiento in enumerate(self.tratamiento):
if tratamiento['activo'] == True:
#if tratamiento[]
self.tratamiento = self.leer_tratamiento(tratamiento['tratamiento_id'])
for i,zona in enumerate(self.zona):
if zona['activo'] == True:
self.zona = zona
for i,tratamiento in enumerate(self.tratamiento):
if tratamiento['activo'] == True:
if tratamiento['id'] == self.zona['tratamiento_id']:
self.tratamiento = tratamiento
self.duracion = int(self.tratamiento['duracion'])
self.nivel_completado = int(self.tratamiento['nivel_completado'])
self.horario_inicio = datetime.strptime(self.horario[0]['horario_inicio'], '%H:%M:%S')
self.horario_fin = datetime.strptime(self.horario[0]['horario_fin'], '%H:%M:%S')
self.minutos_tratamiento = ((self.horario_fin - self.horario_inicio).seconds)/60
self.minutos_faltantes = self.minutos_tratamiento * self.duracion
self.minutos_tratamiento = self.minutos_tratamiento * self.duracion
for i,tanque in enumerate(self.tanque):
if tanque['activo'] == True:
if tanque['zona_id'] == self.zona['id']:
self.tanque = tanque
for i,sensor in enumerate(self.sensor):
if sensor['activo'] == True:
if sensor['tanque_id'] == self.tanque['id']:
self.sensor
self.tratamiento = self.leer_tratamiento(sensor['tratamiento_id'])
return 0
"""
def enviar(self, datos):
self.vista.enviar(Interfaz.PROCESO, datos)
#print(self.vista.response)
return self.vista.response
def operacion_cobro(self):
pass
def configurar_reloj(self):
self.reloj = Reloj(self.horario['intervalo_descanso'],
self.horario['tiempo_descanso'])
return 1
def configurar_servidores(self):
#self.servidor = Servidor()
return 1
def configurar_dispositivos(self):
return 1
def leer_sensores(self, ids):
contador = 0
print("IDS", ids)
#print(self.puerto.puertoAbierto)
for i, sensor in enumerate(self.sensor):
if sensor['tipo'] == "NIVEL":
pass
#print("Direccion de envio: {} ".format(sensor['puerto']))
if sensor['tipo'] == "PH":
pass
#print("Direccion de envio: {} ".format(sensor['puerto']))
if sensor['tipo'] == "Conductividad electrica":
pass
#print("Direccion de envio: {} ".format(sensor['puerto']))
if self.puerto.puertoAbierto:
#while contador <= 1:
#print ("{}: Deshabilitando".format(self))
a = "&{},{},{}*".format(1, 'sensores', ids)
#a = "&{},{},{}*".format(5,'extraer',2000)
#a = "&{},{},{}*".format(9,'dosificar',9)
print(a.encode())
self.puerto.write(a.encode())
time.sleep(.025)
#time.sleep(1)
try:
#Try para la decodificacion
validacion = 0
r = self.puerto.read(50).decode('utf-8')
#r = b'0'
print("{}: {}".format("Datos", r))
if r:
#print(r[0])
if validacion == 0:
if r[0] == '&':
validacion = 1
if validacion == 1:
#print("#############",r[len(r)-3:len(r)-2])
if r[len(r) - 3:len(r) - 2] == '*':
validacion = 2
r = r[1:len(r) - 3]
#print(r)
else:
print("Datos invalidos")
if validacion == 2:
sensor = r.split(",")
#print(sensor)
if sensor[0]:
self.listaDeVariables.X[1].establecerValor(
float(sensor[0])) # Sensor PH
else:
self.listaDeVariables.X[1].establecerValor(
str(-1)) # Sensor PH
if sensor[1]:
self.listaDeVariables.X[2].establecerValor(
float(sensor[1])) # Sensor Ec
else:
self.listaDeVariables.X[2].establecerValor(
str(-1)) # Sensor Ec
if sensor[2]:
self.listaDeVariables.X[3].establecerValor(
float(sensor[2])) # Sensor Ec
else:
self.listaDeVariables.X[3].establecerValor(
str(-1)) # Sensor Temperatura
if sensor[3]:
self.listaDeVariables.X[4].establecerValor(
float(sensor[3])) # Sensor Nivel
else:
self.listaDeVariables.X[4].establecerValor(
str(-1)) # Sensor Nivel
except:
print("No se puede decodificar")
#contador += 1
def validar_sensores(self):
nivel = self.variables.get('nivel')
ph = self.variables.get('ph')
ec = self.variables.get('ec')
temperatura = self.variables.get('temperatura')
self.puerto
# NOTA: Que el nivel maximo de agua contemple la reduccion de EC (Agua) y elevacion de PH (Agua)
for i, sensor in enumerate(self.sensor):
if sensor['tipo'] == "NIVEL":
if nivel:
if nivel <= float(sensor['valor_minimo']):
print(colored("nivel bajo detectado", 'yellow'), nivel)
self.variables.update(z_01=1)
if nivel >= float(sensor['valor_maximo']):
print(colored("nivel alto detectado", 'yellow'), nivel)
self.variables.update(z_01=1)
else:
self.variables.update(z_01=2)
else:
print(
colored(
"Sensor de nivel fuera de posicion o desconectado",
'yellow'), nivel)
self.variables.update(z_01=-1)
if sensor['tipo'] == "PH":
#ph = 8
if ph:
ph_base = (float(sensor['valor_maximo']) +
float(sensor['valor_minimo'])) / 2
if ph <= float(sensor['valor_minimo']):
print(colored("Ph bajo detectado. ", 'yellow'), ph)
self.variables.update(z_02=1)
if ph >= float(sensor['valor_maximo']):
print(colored("Ph alto detectado", 'yellow'), ph)
self.ajustar_tratamiento(ph, ph_base, "Ph reductor")
self.variables.update(z_02=1)
else:
self.variables.update(z_02=2)
else:
print(
colored(
"Sensor de ph fuera de posicion o desconectado",
'yellow'), ph)
self.variables.update(z_02=-1)
if sensor['tipo'] == "Conductividad electrica":
if ec:
ec_base = (float(sensor['valor_maximo']) +
float(sensor['valor_minimo'])) / 2
if float(ec) <= float(sensor['valor_minimo']):
print(colored("EC bajo detectado", 'yellow'), ec)
self.ajustar_tratamiento(ec, ec_base, "Ec elevador")
self.variables.update(z_03=1)
if float(ec) >= float(sensor['valor_maximo']):
print(colored("EC alto detectado", 'yellow'), ec)
self.variables.update(z_03=1)
else:
self.variables.update(z_03=2)
else:
print(
colored(
"Sensor de EC fuera de posicion o desconectado",
'yellow'), ec)
self.variables.update(z_03=-1)
if sensor['tipo'] == "TEMPERATURA":
if temperatura:
if temperatura <= float(sensor['valor_minimo']):
print(colored("temperatura bajo detectado", 'yellow'),
temperatura)
self.variables.update(z_04=1)
if temperatura >= float(sensor['valor_maximo']):
print(colored("temperatura alto detectado", 'yellow'),
temperatura)
self.variables.update(z_04=1)
else:
self.variables.update(z_04=2)
else:
print(
colored(
"Sensor de temperatura fuera de posicion o desconectado",
'yellow'), temperatura)
self.variables.update(z_04=-1)
if nivel <= self.tratamiento['ajuste_nivel']:
#LOG2
#self.secuencia_operacion = 5
print(colored("Ajuste al nivel detectado", 'yellow'), nivel)
try:
self.logs.print(self.variables)
except:
print("No se pudieron guardar los logs")
return 0
def ajustar_tratamiento(self, valor_actual, valor_base, tipo):
for i, solucion in enumerate(self.solucion):
if solucion['tipo'] == tipo:
direccion = solucion[
'direccion'] #Ej: ph = 1 grado , tds = 100 ppm
aplicacion = float(
solucion['aplicacion']) #Ej: ph = 1 grado , tds = 100 ppm
escala = float(
solucion['escala']) #Ej: ph = 1 grado , tds = 100 ppm
litros_actuales = float(
self.tanque['valor_actual']
) #Cantidad de litros actuales en el tanque
#factor = (litros_actuales * aplicacion)/1000
factor = litros_actuales * aplicacion
if "reductor" in solucion['tipo']:
valor_a_ajustar = valor_actual - valor_base
else:
valor_a_ajustar = valor_base - valor_actual
cantidad_a_ajustar = (valor_a_ajustar * factor) / escala
print(
colored(
"direccion: {} aplicacion: {} escala: {} litros_actuales: {} factor: {} valor_a_ajustar: {} cantidad_a_ajustar: {}"
.format(direccion, aplicacion, escala, litros_actuales,
factor, valor_a_ajustar, cantidad_a_ajustar),
'blue'))
self.aplicar_solucion(cantidad_a_ajustar, direccion, tipo)
def aplicar_solucion(self, cantidad_a_ajustar, direccion, tipo):
aplicaciones = cantidad_a_ajustar
a = ""
if tipo == "Ph reductor":
a = "{},{},{}*".format(direccion, 'dosificar', aplicaciones)
if tipo == "Ec elevador":
"""
Considerando 12v a la entrada se calcula que se aplicarian 440 Litros x Hora
Equivalente a:
7.3333333333 Litros x Minuto.
Equivalente a:
122.222222222 mililitros x 1000 milisegundos (segundo)
"""
factor_bomba = 122.22
aplicaciones = (aplicaciones * 1000) / 12
print("Mililitros a aplicar: ", aplicaciones)
a = "&{},{},{}*".format(direccion, 'extraer', aplicaciones)
if tipo == "Solucion nutritiva":
a = "&{},{},{}*".format(direccion, "establecer",
cantidad_a_ajustar)
print(a.encode())
self.puerto.write(a.encode())
"""time.sleep(.025)
try:
#Try para la decodificacion
validacion = 0
r = self.puerto.read(25).decode('utf-8')
#r = b'0'
print ("{}: {}".format("Datos", r))
if r:
print(r[0])
except:
print("No se pudo decodificar")
"""
def validar_respuesta(self, respuesta):
#print("Respuesta: ",respuesta['status'])
#print("Respuesta: ",type(respuesta),respuesta)
#if respuesta['cancelar_pago'] == 1:
# self.secuencia_operacion = 6
try:
#print("Respuesta: ",type(respuesta),respuesta)
if respuesta['operacion_recarga'] == 1:
time.sleep(.1)
self.leer_sensores(15)
self.variables.update(operacion_recarga=2)
else:
self.variables.update(operacion_recarga=0)
except:
pass
#if respuesta['descuento'] > 0:
# self.descuento = respuesta['descuento']
return 1
def validar_operacion(self):
#Anotacion: No funciona el horario nocturno debido a que hay que considerar que el horario_fin corresponde al dia de mañana
#self.boleto = "M,60,1,26'03'2020,10Ñ30Ñ12"
#for i,zona in enumerate(self.zona):
if self.zona['activo'] == True:
if self.zona['id'] == self.zona_id:
if self.tratamiento:
hora_actual = datetime.strptime(time.strftime("%H:%M:%S"),
'%H:%M:%S')
# print("porcentaje completado: ",colored(self.nivel_completado,'red'))
# print("porcentaje tratamiento: ",colored(self.minutos_tratamiento,'red'))
# print("horario inicio: ",colored(self.horario_inicio.time(),'red'))
# print("horario fin: ",colored(self.horario_fin.time(),'red'))
# print("hora actual: ",colored(hora_actual,'red'))
# print("hora actual: ",colored(self.horario['intervalo_descanso'],'red'))
# print("hora actual: ",colored(self.horario['tiempo_descanso'],'red'))
#print("hora actual: {} {} ".format(hora_actual,self.hora_inicio_operacion),colored("....",'red'))
#self.contador_segundos = int(elapsed_time)
if self.nivel_completado < self.minutos_tratamiento:
print("Minutos completados",
colored(self.nivel_completado, 'green'))
#if hora_actual > self.horario_inicio.time() and hora_actual < self.horario_fin.time():
if self.horario_inicio <= hora_actual <= self.horario_fin:
#self.contador_segundos = self.contador_segundos + 1
#self.contador_segundos = int(time.time () - self.hora_inicio_operacion)
self.contador_segundos = self.reloj.obtener_segundos(
)
self.estado_operacion = self.reloj.obtener_estado()
direccion = 0
for i, solucion in enumerate(self.solucion):
if "Nutritiva" in solucion['tipo']:
direccion = solucion[
'direccion'] #Ej: ph = 1 grado , tds = 100 ppm
if self.estado_operacion:
print(colored("[Operando]: ", 'green'),
self.contador_segundos)
self.aplicar_solucion(1, direccion,
"Solucion nutritiva")
else:
print(colored("[Descanso]: ", 'red'),
self.contador_segundos)
self.aplicar_solucion(0, direccion,
"Solucion nutritiva")
operacion_validada = False
'''
if self.contador_segundos % 60 == 0 and self.estado_operacion:
print(colored("Horario valido: ",'green'),self.contador_segundos)
self.nivel_completado = self.nivel_completado + 1
self.actualizar_nivel()
#LOG1
print(colored("Actualizando valores",'magenta'),self.nivel_completado)
operacion_validada = True
'''
'''
if self.contador_segundos % 60 == 0 and self.estado_operacion and self.contador_segundos:
print(colored("Horario valido: ",'green'),self.contador_segundos)
self.nivel_completado = self.nivel_completado + 1
self.actualizar_nivel()
#LOG1
print(colored("Actualizando valores",'magenta'),self.nivel_completado)
operacion_validada = True
if self.contador_segundos == (self.horario['intervalo_descanso']*60) and self.estado_operacion:
print(colored("Deteniendo: ",'red'),self.horario['intervalo_descanso']*60)
self.contador_segundos = 0
self.hora_inicio_operacion = time.time()
self.estado_operacion = 0
if not self.estado_operacion:
tiempo_total = self.horario['tiempo_descanso']*60
print(colored("Tiempo de descanso: ",'red'),self.contador_segundos,tiempo_total)
#if self.contador_segundos % tiempo_total == 0:
if self.contador_segundos == tiempo_total:
self.contador_segundos = 0
self.hora_inicio_operacion = time.time()
self.estado_operacion = 1
'''
if self.contador_segundos % 59 == 0 and self.estado_operacion and self.contador_segundos:
print(colored("Horario valido: ", 'green'),
self.contador_segundos)
self.nivel_completado = self.nivel_completado + 1
self.actualizar_nivel()
#LOG1
print(
colored("Actualizando valores", 'magenta'),
self.nivel_completado)
operacion_validada = True
if operacion_validada:
return 1
else:
return 0
else:
print(
colored("Horario de operacion terminado: ",
'red'), hora_actual)
return 0
else:
print("Tratamiento terminado: ",
colored(self.nivel_completado, 'red'))
return 0
else:
print(colored("No se encontro un tratamiento: ", 'red'))
else:
print(colored("No se encontro la zona: ", 'red'))
else:
print(colored("No se encontro ningun invernadero: ", 'red'))
def leer_tratamiento(self, tratamiendo_id):
for i, tratamiento in enumerate(self.tratamiento):
if tratamiento['activo'] == True:
if tratamiento['id'] == tratamiendo_id:
print("Tratamiento seleccionado: ", tratamiendo_id)
return tratamiento
return 0
def actualizar_nivel(self):
metodo = "GET"
self.api.establecer_url(
'http://127.0.0.1:8000/api/tratamiento/{}/'.format(
self.tratamiento['id']))
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
body = self.api.enviar(Interfaz.PROCESO, "")
body.update(nivel_completado=self.nivel_completado)
metodo = "PUT"
self.api.establecer_url(
'http://127.0.0.1:8000/api/tratamiento/{}/'.format(
self.tratamiento['id']))
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
response = self.api.enviar(Interfaz.PROCESO, body)
print("Respuesta: ", response)
def reiniciar_variables(self):
#-------------------- Secuencia cobro
self.secuencia_operacion = 0
self.monto_ingresar = 0
self.monto_ingresado = 0
self.monto_a_dispensar = 0
self.descuento = 0
self.cancelar_pago = 0
self.tarifa_seleccionada = 0
def ejecutar_programa(self):
pass
def secuencia_error(self):
return 1
def secuencia_ajuste_nivel(self):
return 1
def finalizar_operacion(self):
self.reiniciar_variables()
return 1
def restar_hora(self, horab, fechab):
horab = horab.split(':', 2)
fechab = fechab.split('-')
fechaBoleto = datetime.strptime(
str(fechab[0]) + str(fechab[1]) + str(fechab[2]), '%Y%m%d').date()
horaBoleto = datetime.strptime(
str(horab[0]) + ':' + str(horab[1]) + ':' + str(horab[2]),
'%H:%M:%S').time()
fechaActual = datetime.now().date()
horaActual = datetime.now().time()
horayFechaBoleto = datetime.now().combine(fechaBoleto, horaBoleto)
horayFechaActual = datetime.now().combine(fechaActual, horaActual)
restaFechas = horayFechaActual - horayFechaBoleto
aux_dif = (str(restaFechas).split('.', 1))[0]
dias = int(restaFechas.days)
segundos = restaFechas.seconds
return dias, segundos, aux_dif
class PC:
"""
Clase utulizada para administrar el punto de cobro
"""
def __init__(self, variables):
self.tipo_controladora = ""
self.encriptacion = ""
self.nombre_sucursal = ""
self.localidad_sucursal = ""
self.server_ip_address = ""
self.ip_address = ""
self.id = ""
self.id_sucursal = ""
self.politicas = ""
#-------------------- Leer configuracion
self.vizualizar = ""
#-------------------- Modo operacion
self.listaDeVariables = variables
self.tarjeta_controladora = ""
#-------------------- Diccionatrios
self.informacion = ""
self.variables = ""
#-------------------- Secuencia cobro
self.secuencia_cobro = 0
self.monto_ingresar = 0
self.monto_ingresado = 0
self.monto_a_dispensar = 0
self.descuento = 0
#-------------------- Secuencia lectura boleto
self.boleto = ""
self.folio = ""
self.expedidora = ""
self.hora_entrada = ""
self.fecha_entrada = ""
self.tiempo_estacionado = ""
#-------------------- Modelos
self.equipo = ""
self.controladora = ""
self.dispositivo = ""
self.tarifa = ""
self.sensor = ""
self.servidor = ""
#-------------------- Interfaces
self.vista = ""
self.api = ""
self.inicializar()
self.TON_01 = Temporizador("TON_01", 2.5)
print("Iniciando Cajero.")
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def run(self):
self.funcionando = True
listaDeVariables_tmp = 0
while (self.funcionando):
time.sleep(1)
self.TON_01.entrada = not self.TON_01.salida
self.TON_01.actualizar()
print(" #-------------------- Secuencia de cobro: ",
self.secuencia_cobro)
#print(" #-------------------- conexion a internet: ",self.servidor.estado_internet)
#print(" #-------------------- conexion a servidor: ",self.servidor.estado_servidor)
if self.secuencia_cobro == 0:
#-------------------- Validar lectura de boleto
boleto_valido = self.validar_lectura_boleto()
if boleto_valido == 1:
self.secuencia_cobro = 1
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 1:
#-------------------- Validar estado de dispositivos
validacion = self.validar_dispositivos()
if validacion == 1:
self.secuencia_cobro = 2
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 2:
#-------------------- Habilitar dispositivos de cobro
self.habilitar_dispositivos_cobro()
resultado = 1
if resultado == 1:
listaDeVariables_tmp = self.listaDeVariables
self.secuencia_cobro = 3
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 3:
#-------------------- Actualizar variables
monto_completado = self.actualiza_cobro(listaDeVariables_tmp)
self.variables.update(interfaz=2)
if monto_completado == 1:
self.secuencia_cobro = 4
else:
self.secuencia_cobro = 3
if self.secuencia_cobro == 4:
#-------------------- Entregar cambio y validar operacion
operacion_validada = self.validar_operacion()
if operacion_validada == 1:
self.secuencia_cobro = 7
else:
self.secuencia_cobro = 5
if self.secuencia_cobro == 5:
#-------------------- Operacion no valida: Entregar comprobante de error y pedir asistencia
combrobante_error = self.secuencia_error()
if combrobante_error == 1:
self.secuencia_cobro = 7
else:
print("No se pudo expedir el comprobante de error")
if self.secuencia_cobro == 7:
#-------------------- Equipo suspendido
self.cajero_suspendido()
if self.secuencia_cobro == 8:
#-------------------- Ofrecer ticket , registrar operacion y reiniciar valores
operacion_finalizada = self.finalizar_operacion()
self.secuencia_cobro = 0
fecha = time.strftime("%Y-%m-%d %H:%M:%S")
self.variables.update(monto_ingresar=self.monto_ingresar)
self.variables.update(monto_ingresado=self.monto_ingresado)
self.variables.update(monto_a_dispensar=self.monto_a_dispensar)
self.variables.update(folio=self.folio)
self.variables.update(hora_entrada=self.hora_entrada)
self.variables.update(tiempo_estacionado=self.tiempo_estacionado)
self.variables.update(descuento=self.descuento)
self.variables.update(fecha=fecha)
#sensores.update(monto=i)
#response = cajero.enviar(informacion)
response = self.enviar(self.variables)
print(response)
def inicializar(self):
#shutil.copy(ruta+"configParser/configuracion.ini", ruta+"configParser/configuracion_respaldo.ini")
#shutil.copy(ruta+"configParser/sensores.ini", ruta+"configParser/sensores_respaldo.ini")
#-------------------- Establecer vista
self.vista = Interfaz('http://127.0.0.1:8000/hook/')
self.vista.establecer_lista_de_variables(self.listaDeVariables)
body = ""
metodo = "POST"
self.vista.establecer_metodo(metodo)
self.vista.establecer_encabezado({'Content-Type': 'application/json'})
#-------------------- Establecer API
self.api = Interfaz('http://127.0.0.1:8000/api/')
self.api.establecer_lista_de_variables(self.listaDeVariables)
body = ""
metodo = "GET"
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
self.tipo_controladora = 0
#-------------------- Leer configuracion
#self.vizualizar = viewData('configuracion.ini')
self.leer_configuracion()
#-------------------- Modo operacion
self.tarjeta_controladora = self.establecer_tarjeta_controladora(
self.listaDeVariables)
#-------------------- configurar dispositivos
self.configurar_dispositivos()
#-------------------- configurar servidores
self.configurar_servidores()
time.sleep(5)
self.informacion = dict(
interfaz=0,
X_02=self.listaDeVariables.dispositivos[0].variables[2].
obtenerValor(),
X_01=self.listaDeVariables.dispositivos[0].variables[1].
obtenerValor(),
X_03=self.listaDeVariables.dispositivos[0].variables[3].
obtenerValor(),
X_04=self.listaDeVariables.dispositivos[0].variables[4].
obtenerValor(),
X_05=self.listaDeVariables.dispositivos[0].variables[5].
obtenerValor(),
X_06=self.listaDeVariables.dispositivos[0].variables[6].
obtenerValor(),
X_07=self.listaDeVariables.dispositivos[0].variables[7].
obtenerValor(),
)
self.variables = dict(
monto_ingresar=1,
monto_ingresado=1,
monto_a_dispensar=0,
folio=0,
hora_entrada=0,
tiempo_estacionado="",
interfaz=1,
descuento=0,
X_08=self.listaDeVariables.dispositivos[0].variables[8].
obtenerValor(),
X_09=self.listaDeVariables.dispositivos[0].variables[9].
obtenerValor(),
X_10=self.listaDeVariables.dispositivos[0].variables[10].
obtenerValor(),
X_11=self.listaDeVariables.dispositivos[0].variables[11].
obtenerValor(),
X_12=self.listaDeVariables.dispositivos[0].variables[12].
obtenerValor(),
X_13=self.listaDeVariables.dispositivos[0].variables[13].
obtenerValor(),
X_14=self.listaDeVariables.dispositivos[0].variables[14].
obtenerValor(),
X_15=self.listaDeVariables.dispositivos[0].variables[15].
obtenerValor(),
X_16=self.listaDeVariables.dispositivos[0].variables[16].
obtenerValor(),
X_17=self.listaDeVariables.dispositivos[0].variables[17].
obtenerValor(),
X_18=self.listaDeVariables.dispositivos[0].variables[18].
obtenerValor(),
X_19=self.listaDeVariables.dispositivos[0].variables[19].
obtenerValor(),
X_20=self.listaDeVariables.dispositivos[0].variables[20].
obtenerValor(),
X_21=self.listaDeVariables.dispositivos[0].variables[21].
obtenerValor(),
X_22=self.listaDeVariables.dispositivos[0].variables[22].
obtenerValor(),
)
self.deshabilitar_dispositivos_cobro()
time.sleep(2)
pass
def obtenerEquipo(self, equipo):
return self.equipo
def obtenerControladora(self, controladora):
return self.controladora
def obtenerTarifas(self, tarifa):
return self.tarifa
def obtenerSensores(self, sensor):
return self.sensor
def obtenerDispositivos(self, dispositivo):
return self.dispositivo
def obtenerVista(self, vista):
return self.vista
def establecerEquipo(self, equipo):
self.equipo = equipo
def establecerControladora(self, controladora):
self.controladora = controladora
def establecerTarifas(self, tarifa):
self.tarifa = tarifa
def establecerSensores(self, sensor):
self.sensor = sensor
def establecerDispositivos(self, dispositivo):
self.dispositivo = dispositivo
def establecerVista(self, vista):
self.vista = vista
def establecer_tarjeta_controladora(self, tipo):
if self.controladora[0]['tipo'] == "Controladora Arduino":
if self.controladora[0]['modo_operacion'] == "Cajero":
#controladora = Controladora(listaDeVariable s, tarjeta = Controladora.TARJETA_DE_INTERFAZ_ARDUINO)
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_ARDUINO,
tipoDeControladora=Controladora.CONTROLADORA_PARA_CAJERO)
if self.controladora[0]['tipo'] == "Controladora Pulso":
controladora = Controladora(self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_PULSO)
if self.controladora[0]['tipo'] == "Controladora Blanca":
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_BLANCA)
if self.controladora[0]['tipo'] == "Controladora Raspberry":
controladora = Controladora(
self.listaDeVariables,
tarjeta=Controladora.TARJETA_DE_INTERFAZ_ARDUINO)
return 0
def leer_configuracion(self):
#interfaz_api = Interfaz('http://127.0.0.1:8000/api/')
### ------------------------------- Leer configuracion de equipo
body = ""
metodo = "GET"
self.api.establecer_url('http://127.0.0.1:8000/api/')
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
modelos = self.api.enviar(Interfaz.PROCESO, body)
#datos = self.api.response[0]
#print(response)
if isinstance(modelos, (dict)):
print(
"### -------------------------------Configuracion de equipo ")
for i, modelo in enumerate(modelos):
if modelo != 'transaccion' and modelo != 'servicio':
self.api.establecer_url(
'http://127.0.0.1:8000/api/{}/'.format(modelo))
campos = self.api.enviar(Interfaz.PROCESO, body)
if modelo == "equipo":
self.equipo = campos
if modelo == "controladora":
self.controladora = campos
if modelo == "dispositivo":
self.dispositivo = campos
if modelo == "tarifa":
self.tarifa = campos
if isinstance(campos, (list)):
for i, campo in enumerate(campos):
print(
"### -------------------------------Configuracion de {} {}"
.format(modelo, i + 1))
for valor in campo:
print(valor + " : " + str(campo[valor]))
return 0
'''
#-------------------- Leer configuracion archivo configuracion .ini
def leer_configuracion(self):
#self.vizualizar.getInfo()
self.tipo_controladora = int(self.vizualizar.getValue('CONTROLADORA','tipo_tc'))
self.encriptacion = int(self.vizualizar.getValue('GENERAL','encriptacion'))
self.nombre_sucursal = self.vizualizar.getValue('GENERAL','nombre_sucursal')
self.localidad_sucursal = self.vizualizar.getValue('GENERAL','localidad_sucursal')
self.server_ip_address = self.vizualizar.getValue('RED','server_ip_address')
self.ip_address = self.vizualizar.getValue('RED','ip_addeess')
self.id = int(self.vizualizar.getValue('GENERAL','id'))
self.id_sucursal = int(self.vizualizar.getValue('GENERAL','id_sucursal'))
self.politicas = self.vizualizar.getValue('GENERAL','politicas')
'''
def enviar(self, datos):
self.vista.enviar(Interfaz.PROCESO, datos)
print(self.vista.response)
return self.vista.response
def operacion_cobro(self):
pass
def actualiza_cobro(self, listaDeVariables_tmp):
variables_tmp = dict(
X_10_tmp=listaDeVariables_tmp.dispositivos[0].variables[10].
obtenerValor(),
X_13_tmp=listaDeVariables_tmp.dispositivos[0].variables[13].
obtenerValor(),
X_16_tmp=listaDeVariables_tmp.dispositivos[0].variables[16].
obtenerValor(),
X_19_tmp=listaDeVariables_tmp.dispositivos[0].variables[19].
obtenerValor(),
X_22_tmp=listaDeVariables_tmp.dispositivos[0].variables[22].
obtenerValor(),
)
#ingreso_1 = (int(self.variables.get('X_10')) - int(variables_tmp.get('X_10_tmp')))*int(self.variables.get('X_08'))
#ingreso_2 = (int(self.variables.get('X_13')) - int(variables_tmp.get('X_13_tmp')))*int(self.variables.get('X_11'))
#ingreso_3 = (int(self.variables.get('X_16')) - int(variables_tmp.get('X_16_tmp')))*int(self.variables.get('X_14'))
#ingreso_4 = (int(self.variables.get('X_19')) - int(variables_tmp.get('X_19_tmp')))*int(self.variables.get('X_17'))
#ingreso_5 = (int(self.variables.get('X_22')) - int(variables_tmp.get('X_22_tmp')))*int(self.variables.get('X_20'))
ingreso_1 = (int(variables_tmp.get('X_10_tmp')) - int(
self.variables.get('X_10'))) * int(self.variables.get('X_08'))
ingreso_2 = (int(variables_tmp.get('X_13_tmp')) - int(
self.variables.get('X_13'))) * int(self.variables.get('X_11'))
ingreso_3 = (int(variables_tmp.get('X_16_tmp')) - int(
self.variables.get('X_16'))) * int(self.variables.get('X_14'))
ingreso_4 = (int(variables_tmp.get('X_19_tmp')) - int(
self.variables.get('X_19'))) * int(self.variables.get('X_17'))
ingreso_5 = (int(variables_tmp.get('X_22_tmp')) - int(
self.variables.get('X_22'))) * int(self.variables.get('X_20'))
print("Denominacion 1:", ingreso_1)
print("Denominacion 2:", ingreso_2)
print("Denominacion 3:", ingreso_3)
print("Denominacion 4:", ingreso_4)
print("Denominacion 5:", ingreso_5)
self.monto_ingresado = ingreso_1 + ingreso_2 + ingreso_3 + ingreso_4 + ingreso_5
#self.monto_ingresado = self.monto_ingresado * (-1)
self.monto_a_dispensar = self.monto_ingresar - self.monto_ingresado
print("Monto a ingresar:", self.monto_ingresar)
print("Monto ingresado:", self.monto_ingresado)
print("Diferencia monto:", self.monto_a_dispensar)
return self.monto_a_dispensar
def probar(self):
return 0
def configurar_servidores(self):
self.servidor = Servidor()
return 1
def configurar_dispositivos(self):
return 1
def validar_dispositivos(self):
return 1
def validar_operacion(self):
if self.monto_a_dispensar:
self.dispensar_dinero(self.monto_a_dispensar)
return 1
def calcular_tarifa2(self):
horaBoleto = self.hora_entrada.split(':', 2)
fechaAMD = self.fecha_entrada.split('-')
print(fechaAMD)
fechaAMD = fechaAMD[2] + "-" + fechaAMD[1] + "-" + fechaAMD[0]
dh = self.restar_hora(horaBoleto, fechaAMD.split('-'))
dias = dh[0]
horas = dh[1]
tiempo_estacionado = dh[2]
print("tiempo_estacionado: ", dias, horas)
self.tiempo_estacionado = tiempo_estacionado
#self.tiempo_estacionado = str(dias)+" "+str(horas)
self.monto_ingresar = 15
def calcular_tarifa(self, hora_ingreso, fecha_ingreso, descuento):
#-------------------- Seleccionar tarifa y extraer datos --------------------#
indice = 0
for i, tarifa_seleccionada in enumerate(self.tarifa):
if tarifa_seleccionada['descuento'] == descuento:
indice = i
descuento = self.tarifa[indice]['descuento']
tiempo_base = self.tarifa[indice]['tiempo_base']
monto_base = self.tarifa[indice]['monto_base']
fraccion_tiempo = self.tarifa[indice]['fraccion_tiempo']
incremental = self.tarifa[indice]['incremental']
tarifa_seleccionada = self.tarifa[indice]['id']
# ( monto_base representa el descuento tipo 1 por el tiempo : tiempo_base )
self.descuento = monto_base
#-------------------- Calcular tiempo estacionado en minutos --------------------#
resta = self.restar_hora(self.hora_entrada, self.fecha_entrada)
dias = resta[0]
segundos = resta[1]
tiempo_estacionado = int(segundos / 60)
print(
"#-------------------- Informacion Boleto --------------------# ")
print("tarifa_seleccionada: {} ".format(tarifa_seleccionada))
print("tiempo_estacionado: {} dias con {} minutos".format(
dias, tiempo_estacionado))
if dias:
tiempo_estacionado += dias * 1440
self.tiempo_estacionado = tiempo_estacionado
print("minutos totales: {}".format(tiempo_estacionado))
#-------------------- Calcular monto total en base a tiempo estacionado --------------------#
monto_total = 0
if tiempo_base > tiempo_estacionado:
monto_total = monto_base
self.monto_ingresar = monto_total
return monto_total
else:
monto_total += monto_base
tiempo_restante = tiempo_estacionado - tiempo_base
fracciones_de_tiempo = int(tiempo_restante / fraccion_tiempo)
monto_total += fracciones_de_tiempo * incremental
self.monto_ingresar = monto_total
print("Fracciones: ", fracciones_de_tiempo)
print("Monto a ingresar: ", self.monto_ingresar)
return monto_total
def recargar(self):
return 0
def dispensar_dinero(self, monto):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
Monedero.MONEDERO_DAR_CAMBIO, monto)
def recibir_dinero(self):
return 1
#self.listaDeVariables.dispositivos[5].ejecutarInstruccion(Monedero.MONEDERO_DAR_CAMBIO, monto)
def buscar_boleto(self):
mensaje = "{},{},{} {}".format(self.folio, self.expedidora,
self.hora_entrada, self.fecha_entrada)
resultado = self.servidor.configSocket("informacion boleto", mensaje)
print("resultado", resultado)
if (not self.servidor.estado_servidor or resultado == -1):
self.estado_boleto = 0
estado = 1
else:
self.estado_boleto = resultado[1]
self.informacion_boleto = str(resultado[2])
estado = self.estado_boleto
'''
leerArch = open(ruta+"../../sys/descuento.txt", "r")
sello=leerArch.readline().rstrip("\n")
print("sellado =",sello)
if(int(sello) == 1):
descuento=2
else:
descuento=1
leerArch.close()
leerArch = open(ruta+"../../sys/descuento.txt", "w")
leerArch.write('0')
leerArch.close()
#Verificando sello de boleto Fin
'''
# [1] No pagado
# [2] Pagado, tiempo restante
# [3] Excedido, fecha ultimo pago
# [4] Obsoleto
if int(estado) == 1:
tarifa = self.calcular_tarifa(self.hora_entrada,
self.fecha_entrada, self.descuento)
if int(estado) == 2:
tiempo_restante = self.informacion_boleto
if int(estado) == 3:
ultimo_pago = self.informacion_boleto.split(" ", 1)
self.hora_entrada = ultimo_pago[0]
self.fecha_entrada = ultimo_pago[1]
self.calcular_tarifa(self.hora_entrada, self.fecha_entrada,
self.descuento)
if int(estado) == 4:
return estado
return estado
def validar_datos(self, tipo, datos):
# [1] Boleto
# [2] Descuento
# [3] Fecha [AAAA/MM/DD]
# [4]
if tipo == 1:
try:
caracter_inicio = datos[:2]
if ('M,' == caracter_inicio or 'L,' == caracter_inicio):
if 'M,' == caracter_inicio:
datos = datos[
0:-1:] #Retira caracteres de inicio y de fin
datos = datos.replace("'", "-")
datos = datos.replace("Ñ", ":")
datos = datos.split(',')
datos[1] = int(datos[1])
datos[2] = int(datos[2])
fecha = datetime.strptime(
str(datos[3]) + " " + str(datos[4]),
'%d-%m-%Y %H:%M:%S')
self.boleto = datos
self.folio = datos[1]
self.expedidora = datos[2]
self.hora_entrada = datos[4]
self.fecha_entrada = self.validar_datos(3, datos[3])
return 1
except:
return 0
if tipo == 3:
datos = datos.split(" ", 1)
datos = datos[0].split('-', 2)
fecha_amd = datos[2] + "-" + datos[1] + "-" + datos[0]
return fecha_amd
def validar_lectura_boleto(self):
#self.boleto = "M,60,1,26'03'2020,10Ñ30Ñ12"
leerArch = open(ruta + "lectura.txt", "r")
folio = leerArch.readline().rstrip("\n")
if (folio != ''):
self.boleto = "M,60,1,05'05'2020,10Ñ30Ñ12"
datos_validos = self.validar_datos(1, self.boleto)
if datos_validos:
print("Boleto detectado: ", self.boleto)
print("Folio: ", self.folio, self.expedidora,
self.hora_entrada, self.fecha_entrada)
self.buscar_boleto()
else:
return 0
leerArch.close()
leerArch = open(ruta + "lectura.txt", "w")
leerArch.write('')
leerArch.close()
return 1
else:
leerArch.close()
return 0
def registrar_pago(self):
self.boleto = ""
self.folio = ""
self.expedidora = ""
self.hora_entrada = ""
self.fecha_entrada = ""
self.tiempo_estacionado = ""
#------------------------------- Proceso para registrar un pago
body = {
"folio_boleto": self.folio,
"expedidor_boleto": self.expedidora,
"fecha_expedicion_boleto": "2020-04-07T12:12:00Z",
"codigo": 1,
"registrado": True,
"monto": self.monto_ingresar,
"cambio": self.monto_a_dispensar,
"monedas": "0:0",
"billetes": "0:0",
"cambio_entregado": "0:0",
"equipo_id": 1
}
metodo = "POST"
self.api.establecer_url('http://127.0.0.1:8000/api/corte/')
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
print("Metodo....: ",
self.api.obtener_metodo({'Content-Type': 'application/json'}))
response = self.api.enviar(Interfaz.PROCESO, body)
print("Respuesta: ", response)
def ejecutar_programa(self):
pass
def secuencia_error(self):
return 1
def finalizar_operacion(self):
self.registrar_pago()
return 1
def cajero_suspendido(self):
return 1
def deshabilitar_dispositivos_cobro(self):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
self.listaDeVariables.dispositivos[0].MONEDERO_DESHABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(
self.listaDeVariables.dispositivos[1].BILLETERO_DESHABILITAR)
def habilitar_dispositivos_cobro(self):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(
self.listaDeVariables.dispositivos[0].MONEDERO_HABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(
self.listaDeVariables.dispositivos[1].BILLETERO_HABILITAR)
def restar_hora(self, horab, fechab):
horab = horab.split(':', 2)
fechab = fechab.split('-')
fechaBoleto = datetime.strptime(
str(fechab[0]) + str(fechab[1]) + str(fechab[2]), '%Y%m%d').date()
horaBoleto = datetime.strptime(
str(horab[0]) + ':' + str(horab[1]) + ':' + str(horab[2]),
'%H:%M:%S').time()
fechaActual = datetime.now().date()
horaActual = datetime.now().time()
horayFechaBoleto = datetime.now().combine(fechaBoleto, horaBoleto)
horayFechaActual = datetime.now().combine(fechaActual, horaActual)
restaFechas = horayFechaActual - horayFechaBoleto
aux_dif = (str(restaFechas).split('.', 1))[0]
dias = int(restaFechas.days)
segundos = restaFechas.seconds
return dias, segundos, aux_dif
class Expedidora:
"""
Clase utulizada para administrar la expedidora
"""
#-------------------- Identificadores de dispositivos
MONEDERO_MDB = 1
BILLETERO_MDB = 2
HOPPER_01_CCTALK = 3
HOPPER_02_CCTALK = 4
HOPPER_03_CCTALK = 5
VALIDADOR_CCTALK = 6
BILLETERO_ACEPTADOR_ID003 = 7
BILLETERO_RECICLADOR_ID003 = 8
def __init__(self,variables):
self.tipo_controladora = ""
self.encriptacion = ""
self.nombre_sucursal = ""
self.localidad_sucursal = ""
self.server_ip_address = ""
self.ip_address = ""
self.id = ""
self.id_sucursal = ""
self.politicas = ""
#-------------------- Leer configuracion
self.vizualizar = ""
#-------------------- Modo operacion
self.listaDeVariables = variables
self.tarjeta_controladora = ""
#-------------------- Diccionatrios
self.informacion = ""
self.variables = ""
#-------------------- Secuencia cobro
self.secuencia_cobro = 0
self.monto_ingresar = 0
self.monto_ingresado = 0
self.monto_a_dispensar = 0
self.descuento = 0
self.tarifa_seleccionada = 0
self.cancelar_pago = 0
#-------------------- Secuencia lectura boleto
self.boleto = ""
self.folio= ""
self.expedidora = ""
self.hora_entrada = ""
self.fecha_entrada = ""
self.tiempo_estacionado = ""
#-------------------- Modelos
self.equipo = ""
self.controladora = ""
self.dispositivo = ""
self.tarifa = ""
self.sensor = ""
self.servidor = ""
#-------------------- Interfaces
self.vista = ""
self.api = ""
self.inicializar()
self.TON_01 = Temporizador("TON_01",2.5)
print("Iniciando Cajero.")
tarea1 = threading.Thread(target=self.run)
tarea1.start()
def run (self):
self.funcionando = True
listaDeVariables_tmp = 0
while (self.funcionando):
time.sleep(1)
self.TON_01.entrada = not self.TON_01.salida
self.TON_01.actualizar()
print(" #-------------------- Secuencia de expedicion: ",self.secuencia_cobro)
#print(" #-------------------- conexion a internet: ",self.servidor.estado_internet)
#print(" #-------------------- conexion a servidor: ",self.servidor.estado_servidor)
if self.secuencia_cobro == 0:
#-------------------- Validar lectura de boleto
self.variables.update(cancelar_pago=0)
self.variables.update(operacion_recarga=0)
boleto_valido = self.validar_lectura_boleto()
#self.dispensar_cambio2(583)
if boleto_valido == 1:
self.secuencia_cobro = 1
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 1:
#-------------------- Validar estado de dispositivos
validacion = self.validar_dispositivos()
if validacion == 1:
self.secuencia_cobro = 2
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 2:
#-------------------- Habilitar dispositivos de cobro
self.habilitar_dispositivos_cobro()
resultado = 1
if resultado == 1:
listaDeVariables_tmp = self.listaDeVariables
self.secuencia_cobro = 3
else:
self.secuencia_cobro = 0
if self.secuencia_cobro == 3:
#-------------------- Actualizar variables
monto_completado = self.actualiza_cobro(listaDeVariables_tmp)
self.variables.update(interfaz=2)
if monto_completado == 1:
self.secuencia_cobro = 4
else:
self.secuencia_cobro = 3
if self.secuencia_cobro == 4:
#-------------------- Entregar cambio y validar operacion
operacion_validada = self.validar_operacion()
if operacion_validada == 1:
self.secuencia_cobro = 8
else:
self.secuencia_cobro = 5
if self.secuencia_cobro == 5:
#-------------------- Operacion no valida: Entregar comprobante de error y pedir asistencia
combrobante_error = self.secuencia_error()
if combrobante_error == 1:
self.secuencia_cobro = 7
else:
print("No se pudo expedir el comprobante de error")
if self.secuencia_cobro == 6:
#-------------------- Operacion cancelada:
self.variables.update(interfaz=1)
self.variables.update(cancelar_pago=2)
self.cancelar_pago = 1
cancelacion_exitosa = self.secuencia_cancelacion()
if cancelacion_exitosa == 1:
self.secuencia_cobro = 8
else:
self.secuencia_cobro = 5
print("No se pudo expedir el comprobante de error")
if self.secuencia_cobro == 7:
#-------------------- Cajero suspendido
self.cajero_suspendido()
if self.secuencia_cobro == 8:
#-------------------- Ofrecer ticket , registrar operacion y reiniciar valores
operacion_finalizada = self.finalizar_operacion()
self.secuencia_cobro = 0
if self.secuencia_cobro == 9:
#-------------------- Operacion recarga
self.variables.update(operacion_recarga=2)
self.variables.update(interfaz=2)
operacion_finalizada = self.recargar()
fecha = time.strftime("%Y-%m-%d %H:%M:%S")
self.variables.update(monto_ingresar=self.monto_ingresar)
self.variables.update(monto_ingresado=self.monto_ingresado)
self.variables.update(monto_a_dispensar=self.monto_a_dispensar)
self.variables.update(folio=self.folio)
self.variables.update(hora_entrada=self.hora_entrada)
print("te",self.tiempo_estacionado)
self.variables.update(tiempo_estacionado=self.tiempo_estacionado)
self.variables.update(descuento=self.descuento)
self.variables.update(fecha=fecha)
#sensores.update(monto=i)
#response = cajero.enviar(informacion)
respuesta = self.enviar(self.variables)
self.validar_respuesta(respuesta)
print(respuesta)
def inicializar(self):
#shutil.copy(ruta+"configParser/configuracion.ini", ruta+"configParser/configuracion_respaldo.ini")
#shutil.copy(ruta+"configParser/sensores.ini", ruta+"configParser/sensores_respaldo.ini")
#-------------------- Establecer vista
self.vista = Interfaz('http://127.0.0.1:8000/hook/')
self.vista.establecer_lista_de_variables(self.listaDeVariables)
body = ""
metodo = "POST"
self.vista.establecer_metodo(metodo)
self.vista.establecer_encabezado({'Content-Type': 'application/json'})
#-------------------- Establecer API
self.api = Interfaz('http://127.0.0.1:8000/api/')
self.api.establecer_lista_de_variables(self.listaDeVariables)
body = ""
metodo = "GET"
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
self.tipo_controladora = 0
#-------------------- Leer configuracion
#self.vizualizar = viewData('configuracion.ini')
self.leer_configuracion()
#-------------------- Modo operacion
#####self.tarjeta_controladora = self.establecer_tarjeta_controladora(self.listaDeVariables)
#-------------------- configurar dispositivos
self.configurar_dispositivos()
#-------------------- configurar servidores
self.configurar_servidores()
time.sleep(5)
self.variables = dict (
folio = 0,
hora_entrada = 0,
tiempo_estacionado = "",
interfaz = 6,
descuento = 0,
operacion_recarga = 0,
presencia = 1,
boton_ticket = 1,
retorno = 1,
secuencia_expedicion = 5,
# X_08 = self.listaDeVariables.dispositivos[0].variables[8].obtenerValor(),
# X_09 = self.listaDeVariables.dispositivos[0].variables[9].obtenerValor(),
# X_10 = self.listaDeVariables.dispositivos[0].variables[10].obtenerValor(),
# X_11 = self.listaDeVariables.dispositivos[0].variables[11].obtenerValor(),
# X_12 = self.listaDeVariables.dispositivos[0].variables[12].obtenerValor(),
# X_13 = self.listaDeVariables.dispositivos[0].variables[13].obtenerValor(),
# X_14 = self.listaDeVariables.dispositivos[0].variables[14].obtenerValor(),
# X_15 = self.listaDeVariables.dispositivos[0].variables[15].obtenerValor(),
# X_16 = self.listaDeVariables.dispositivos[0].variables[16].obtenerValor(),
# X_17 = self.listaDeVariables.dispositivos[0].variables[17].obtenerValor(),
# X_18 = self.listaDeVariables.dispositivos[0].variables[18].obtenerValor(),
# X_19 = self.listaDeVariables.dispositivos[0].variables[19].obtenerValor(),
# X_20 = self.listaDeVariables.dispositivos[0].variables[20].obtenerValor(),
# X_21 = self.listaDeVariables.dispositivos[0].variables[21].obtenerValor(),
# X_22 = self.listaDeVariables.dispositivos[0].variables[22].obtenerValor(),
)
# self.deshabilitar_dispositivos_cobro()
time.sleep(2)
pass
def obtenerEquipo(self,equipo):
return self.equipo
def obtenerControladora(self,controladora):
return self.controladora
def obtenerTarifas(self,tarifa):
return self.tarifa
def obtenerSensores(self,sensor):
return self.sensor
def obtenerDispositivos(self,dispositivo):
return self.dispositivo
def obtenerVista(self,vista):
return self.vista
def establecerEquipo(self,equipo):
self.equipo = equipo
def establecerControladora(self,controladora):
self.controladora = controladora
def establecerTarifas(self,tarifa):
self.tarifa = tarifa
def establecerSensores(self,sensor):
self.sensor = sensor
def establecerDispositivos(self,dispositivo):
self.dispositivo = dispositivo
def establecerVista(self,vista):
self.vista = vista
def establecer_tarjeta_controladora(self,tipo):
if self.controladora[0]['modo_operacion'] == "Expedidor":
if self.controladora[0]['tipo'] == "Controladora Arduino":
controladora = Controladora(self.listaDeVariables,
tarjeta = Controladora.TARJETA_DE_INTERFAZ_ARDUINO,
tipoDeControladora = Controladora.CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
elif self.controladora[0]['tipo'] == "Controladora Raspberry":
controladora = Controladora(self.listaDeVariables,
tarjeta = Controladora.TARJETA_DE_INTERFAZ_BLANCA,
tipoDeControladora = Controladora.CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
elif self.controladora[0]['tipo'] == "Controladora Raspberry Negra":
controladora = Controladora(self.listaDeVariables,
tarjeta = Controladora.TARJETA_DE_INTERFAZ_NEGRA,
tipoDeControladora = Controladora.CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
elif self.controladora[0]['tipo'] == "Controladora Pulso":
controladora = Controladora(self.listaDeVariables,
tarjeta = Controladora.TARJETA_DE_PULSO,
tipoDeControladora = Controladora.CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA)
return 0
def leer_configuracion(self):
#interfaz_api = Interfaz('http://127.0.0.1:8000/api/')
### ------------------------------- Leer configuracion de equipo
body = ""
metodo = "GET"
self.api.establecer_url('http://127.0.0.1:8000/api/')
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
modelos = self.api.enviar(Interfaz.PROCESO,body)
#datos = self.api.response[0]
#print(response)
if isinstance(modelos, (dict)):
print("### -------------------------------Configuracion de equipo ")
for i,modelo in enumerate(modelos):
if modelo != 'transaccion' and modelo != 'servicio':
self.api.establecer_url('http://127.0.0.1:8000/api/{}/'.format(modelo))
campos = self.api.enviar(Interfaz.PROCESO,body)
if modelo == "equipo":
self.equipo = campos
if modelo == "controladora":
self.controladora = campos
if modelo == "dispositivo":
self.dispositivo = campos
if modelo == "tarifa":
self.tarifa = campos
if isinstance(campos, (list)):
for i,campo in enumerate(campos):
print("### -------------------------------Configuracion de {} {}".format(modelo,i+1))
for valor in campo:
print(valor + " : " + str(campo[valor]))
return 0
'''
#-------------------- Leer configuracion archivo configuracion .ini
def leer_configuracion(self):
#self.vizualizar.getInfo()
self.tipo_controladora = int(self.vizualizar.getValue('CONTROLADORA','tipo_tc'))
self.encriptacion = int(self.vizualizar.getValue('GENERAL','encriptacion'))
self.nombre_sucursal = self.vizualizar.getValue('GENERAL','nombre_sucursal')
self.localidad_sucursal = self.vizualizar.getValue('GENERAL','localidad_sucursal')
self.server_ip_address = self.vizualizar.getValue('RED','server_ip_address')
self.ip_address = self.vizualizar.getValue('RED','ip_addeess')
self.id = int(self.vizualizar.getValue('GENERAL','id'))
self.id_sucursal = int(self.vizualizar.getValue('GENERAL','id_sucursal'))
self.politicas = self.vizualizar.getValue('GENERAL','politicas')
'''
def enviar(self,datos):
self.vista.enviar(Interfaz.PROCESO,datos)
print(self.vista.response)
return self.vista.response
def operacion_cobro(self):
pass
def actualiza_cobro(self,listaDeVariables_tmp):
variables_tmp = dict (
X_10_tmp = listaDeVariables_tmp.dispositivos[0].variables[10].obtenerValor(),
X_13_tmp = listaDeVariables_tmp.dispositivos[0].variables[13].obtenerValor(),
X_16_tmp = listaDeVariables_tmp.dispositivos[0].variables[16].obtenerValor(),
X_19_tmp = listaDeVariables_tmp.dispositivos[0].variables[19].obtenerValor(),
X_22_tmp = listaDeVariables_tmp.dispositivos[0].variables[22].obtenerValor(),
)
#ingreso_1 = (int(self.variables.get('X_10')) - int(variables_tmp.get('X_10_tmp')))*int(self.variables.get('X_08'))
#ingreso_2 = (int(self.variables.get('X_13')) - int(variables_tmp.get('X_13_tmp')))*int(self.variables.get('X_11'))
#ingreso_3 = (int(self.variables.get('X_16')) - int(variables_tmp.get('X_16_tmp')))*int(self.variables.get('X_14'))
#ingreso_4 = (int(self.variables.get('X_19')) - int(variables_tmp.get('X_19_tmp')))*int(self.variables.get('X_17'))
#ingreso_5 = (int(self.variables.get('X_22')) - int(variables_tmp.get('X_22_tmp')))*int(self.variables.get('X_20'))
ingreso_1 = (int(variables_tmp.get('X_10_tmp')) - int(self.variables.get('X_10')))*int(self.variables.get('X_08'))
ingreso_2 = (int(variables_tmp.get('X_13_tmp')) - int(self.variables.get('X_13')))*int(self.variables.get('X_11'))
ingreso_3 = (int(variables_tmp.get('X_16_tmp')) - int(self.variables.get('X_16')))*int(self.variables.get('X_14'))
ingreso_4 = (int(variables_tmp.get('X_19_tmp')) - int(self.variables.get('X_19')))*int(self.variables.get('X_17'))
ingreso_5 = (int(variables_tmp.get('X_22_tmp')) - int(self.variables.get('X_22')))*int(self.variables.get('X_20'))
print("Denominacion 1:",ingreso_1)
print("Denominacion 2:",ingreso_2)
print("Denominacion 3:",ingreso_3)
print("Denominacion 4:",ingreso_4)
print("Denominacion 5:",ingreso_5)
self.monto_ingresado = ingreso_1 + ingreso_2 + ingreso_3 + ingreso_4 + ingreso_5
#self.monto_ingresado = self.monto_ingresado * (-1)
print("Monto a ingresar:",self.monto_ingresar)
print("Monto ingresado:",self.monto_ingresado)
print("Diferencia monto:",self.monto_a_dispensar)
if self.monto_ingresado >= self.monto_ingresar:
self.monto_a_dispensar = self.monto_ingresar - self.monto_ingresado
return 1
else:
return 0
return self.monto_a_dispensar
def probar(self):
return 0
def configurar_servidores(self):
self.servidor = Servidor()
return 1
def configurar_dispositivos(self):
return 1
def validar_dispositivos(self):
return 1
def validar_respuesta(self,respuesta):
#print("Respuesta: ",respuesta['status'])
print("Respuesta: ",type(respuesta),respuesta)
if respuesta['cancelar_pago'] == 1:
self.secuencia_cobro = 6
if respuesta['operacion_recarga'] == 1:
self.secuencia_cobro = 9
#if respuesta['descuento'] > 0:
# self.descuento = respuesta['descuento']
return 1
def validar_operacion(self):
if self.monto_a_dispensar:
self.dispensar_cambio2(self.monto_a_dispensar)
return 1
def calcular_tarifa2(self):
horaBoleto=self.hora_entrada.split(':',2)
fechaAMD=self.fecha_entrada.split('-')
print(fechaAMD)
fechaAMD=fechaAMD[2]+"-"+fechaAMD[1]+"-"+fechaAMD[0]
dh=self.restar_hora(horaBoleto,fechaAMD.split('-'))
dias=dh[0]
horas=dh[1]
tiempo_estacionado=dh[2]
print("tiempo_estacionado: ",dias,horas)
self.tiempo_estacionado = tiempo_estacionado
#self.tiempo_estacionado = str(dias)+" "+str(horas)
self.monto_ingresar = 15
def calcular_tarifa(self,hora_ingreso, fecha_ingreso, descuento):
#-------------------- Seleccionar tarifa y extraer datos --------------------#
indice = 0
for i,tarifa_seleccionada in enumerate(self.tarifa):
if tarifa_seleccionada['descuento'] == descuento:
indice = i
descuento = self.tarifa[indice]['descuento']
tiempo_base = self.tarifa[indice]['tiempo_base']
monto_base = self.tarifa[indice]['monto_base']
fraccion_tiempo = self.tarifa[indice]['fraccion_tiempo']
incremental = self.tarifa[indice]['incremental']
self.tarifa_seleccionada = self.tarifa[indice]['id']
# ( monto_base representa el descuento tipo 1 por el tiempo : tiempo_base )
self.descuento = monto_base
#-------------------- Calcular tiempo estacionado en minutos --------------------#
resta = self.restar_hora(self.hora_entrada,self.fecha_entrada)
dias = resta[0]
segundos = resta[1]
tiempo_estacionado = int(segundos/60)
print("#-------------------- Informacion Boleto --------------------# ")
print("tarifa_seleccionada: {} ".format(self.tarifa_seleccionada))
print("tiempo_estacionado: {} dias con {} minutos".format(dias,tiempo_estacionado))
if dias:
tiempo_estacionado += dias*1440
self.tiempo_estacionado = tiempo_estacionado
print("minutos totales: {}".format(tiempo_estacionado))
#-------------------- Calcular monto total en base a tiempo estacionado --------------------#
monto_total = 0
if tiempo_base > tiempo_estacionado:
monto_total = monto_base
self.monto_ingresar = monto_total
return monto_total
else:
monto_total += monto_base
tiempo_restante = tiempo_estacionado - tiempo_base
fracciones_de_tiempo = int(tiempo_restante/fraccion_tiempo)
monto_total += fracciones_de_tiempo * incremental
self.monto_ingresar = monto_total
print("Fracciones: ",fracciones_de_tiempo)
print("Monto a ingresar: ",self.monto_ingresar)
return monto_total
def recargar(self):
i = 0
direccion_dispositivo = 0
for i,dispositivo_seleccionado in enumerate(self.dispositivo):
if dispositivo_seleccionado['activo'] == True:
direccion_dispositivo =int( dispositivo_seleccionado['direccion'])
#self.listaDeVariables.dispositivos[direccion_dispositivo].ejecutarInstruccion(self.listaDeVariables.dispositivos[direccion_dispositivo].HABILITAR)
print("Dispositivo Habilitado: {} {} ".format(dispositivo_seleccionado['nombre'],dispositivo_seleccionado['direccion']))
return 1
def dispensar_dinero(self,monto):
indice = 0
for i,dispositivo_seleccionado in enumerate(self.dispositivo):
if dispositivo_seleccionado['tipo'] == "DISPENSADOR":
if dispositivo_seleccionado['activo'] == True:
if dispositivo_seleccionado['direccion'] == 0:
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(self.listaDeVariables.dispositivos[0].MONEDERO_DAR_CAMBIO, monto)
elif dispositivo_seleccionado['direccion'] == 2:
self.listaDeVariables.dispositivos[2].ejecutarInstruccion(self.listaDeVariables.dispositivos[2].MONEDERO_DAR_CAMBIO, monto)
elif dispositivo_seleccionado['direccion'] == 3:
self.listaDeVariables.dispositivos[3].ejecutarInstruccion(self.listaDeVariables.dispositivos[3].MONEDERO_DAR_CAMBIO, monto)
elif dispositivo_seleccionado['direccion'] == 4:
self.listaDeVariables.dispositivos[4].ejecutarInstruccion(self.listaDeVariables.dispositivos[4].MONEDERO_DAR_CAMBIO, monto)
indice = i
#self.listaDeVariables.dispositivos[0].ejecutarInstruccion(Monedero.MONEDERO_DAR_CAMBIO, monto)
def recibir_dinero(self):
return 1
#self.listaDeVariables.dispositivos[5].ejecutarInstruccion(Monedero.MONEDERO_DAR_CAMBIO, monto)
def buscar_boleto(self):
mensaje = "{},{},{} {}".format(self.folio,self.expedidora,self.hora_entrada,self.fecha_entrada)
resultado = self.servidor.configSocket("informacion boleto", mensaje)
if not self.servidor.estado_servidor:
self.estado_boleto = 0
estado = 1
err = "[{}] [Error2] Sin conexion a servidor".format(time.strftime("%Y-%m-%d %H:%M:%S"))
print(colored(err, 'red'))
elif resultado == -1:
self.estado_boleto = 0
err = "[{}] [Error5] Datos no encontrados o invalidos".format(time.strftime("%Y-%m-%d %H:%M:%S"))
print(colored(err, 'red'))
estado = 1
else:
self.estado_boleto = resultado[1]
self.informacion_boleto = str(resultado[2])
estado = self.estado_boleto
text = "[{}] Boleto encontrado".format(time.strftime("%Y-%m-%d %H:%M:%S"))
print(colored(text, 'blue'))
'''
leerArch = open(ruta+"../../sys/descuento.txt", "r")
sello=leerArch.readline().rstrip("\n")
print("sellado =",sello)
if(int(sello) == 1):
descuento=2
else:
descuento=1
leerArch.close()
leerArch = open(ruta+"../../sys/descuento.txt", "w")
leerArch.write('0')
leerArch.close()
#Verificando sello de boleto Fin
'''
# [1] No pagado
# [2] Pagado, tiempo restante
# [3] Excedido, fecha ultimo pago
# [4] Obsoleto
if int(estado)==1:
tarifa = self.calcular_tarifa(self.hora_entrada,self.fecha_entrada, self.descuento)
if int(estado)==2:
tiempo_restante = self.informacion_boleto
if int(estado)==3:
ultimo_pago = self.informacion_boleto.split(" ",1)
self.hora_entrada = ultimo_pago[0]
self.fecha_entrada = ultimo_pago[1]
self.calcular_tarifa(self.hora_entrada,self.fecha_entrada, self.descuento)
if int(estado)==4:
return estado
return estado
def validar_datos(self,tipo,datos):
# [1] Boleto
# [2] Descuento
# [3] Fecha [AAAA/MM/DD]
# [4]
if tipo == 1:
try:
caracter_inicio = datos[:2]
if('M,' == caracter_inicio or 'L,' == caracter_inicio):
if 'M,' == caracter_inicio:
datos = datos[0:-1:] #Retira caracteres de inicio y de fin
datos = datos.replace("'","-")
datos = datos.replace("Ñ",":")
datos = datos.split(',')
datos[1] = int(datos[1])
datos[2] = int(datos[2])
fecha = datetime.strptime(str(datos[3])+" "+str(datos[4]), '%d-%m-%Y %H:%M:%S')
self.boleto = datos
self.folio = datos[1]
self.expedidora = datos[2]
self.hora_entrada = datos[4]
self.fecha_entrada = self.validar_datos(3,datos[3])
return 1
except:
return 0
if tipo == 3:
datos = datos.split(" ",1)
datos = datos[0].split('-',2)
fecha_amd = datos[2]+"-"+datos[1]+"-"+datos[0]
return fecha_amd
def validar_lectura_boleto(self):
#self.boleto = "M,60,1,26'03'2020,10Ñ30Ñ12"
leerArch = open(ruta+"lectura.txt", "r")
folio=leerArch.readline().rstrip("\n")
if(folio != ''):
self.boleto = "M,60,1,14'05'2020,10Ñ30Ñ12"
datos_validos = self.validar_datos(1,self.boleto)
if datos_validos:
print("Boleto detectado: ",self.folio,self.expedidora,self.hora_entrada,self.fecha_entrada)
self.buscar_boleto()
else:
return 0
leerArch.close()
leerArch = open(ruta+"lectura.txt", "w")
leerArch.write('')
leerArch.close()
return 1
else:
leerArch.close()
return 0
def registrar_pago(self):
#------------------------------- Registrar pago en servidor
print("Solocitando registro del pago ")
codigo_registro = False
codigo = 0
respuestaServidor = 0
if self.cancelar_pago:
print("Operacion cancelada")
codigo = 5
else:
if self.servidor.estado_servidor:
mensaje = "{},{},{} {}*{};1;{};{};{};{};{}".format(self.folio,self.expedidora,self.fecha_entrada,self.hora_entrada,self.equipo[0]['numero'],self.monto_ingresar,"0:0","0:0","0:0",self.tarifa_seleccionada)
respuestaServidor = self.servidor.configSocket("pago boleto", mensaje)
if respuestaServidor == -1:
text = "[{}] [Error4] No se pudo registrar en servidor".format(time.strftime("%Y-%m-%d %H:%M:%S"))
print(colored(text, 'red'))
else:
codigo_registro = 1
text = "[{}] Pago registrado".format(time.strftime("%Y-%m-%d %H:%M:%S"))
print(colored(text, 'blue'))
else:
text = "[{}] [Error2] Sin conexion a servidor, No se registro el boleto".format(time.strftime("%Y-%m-%d %H:%M:%S"))
print(colored(text, 'red'))
respuestaServidor = 0
#------------------------------- Registrar pago interno
body = {
"folio_boleto": self.folio,
"expedidor_boleto": self.expedidora,
"fecha_expedicion_boleto": " {}T{}Z".format(self.fecha_entrada,self.hora_entrada),
"codigo": codigo,
"registrado": codigo_registro,
"monto": self.monto_ingresar,
"cambio": self.monto_a_dispensar,
"monedas": "0:0",
"billetes": "0:0",
"cambio_entregado": "0:0",
"equipo_id": 1
}
metodo = "POST"
self.api.establecer_url('http://127.0.0.1:8000/api/transaccion/')
self.api.establecer_metodo(metodo)
self.api.establecer_encabezado({'Content-Type': 'application/json'})
print("Metodo....: ",self.api.obtener_metodo({'Content-Type': 'application/json'}))
response = self.api.enviar(Interfaz.PROCESO,body)
print("Respuesta: ",response)
def reiniciar_variables(self):
#-------------------- Secuencia cobro
self.secuencia_cobro = 0
self.monto_ingresar = 0
self.monto_ingresado = 0
self.monto_a_dispensar = 0
self.descuento = 0
self.cancelar_pago = 0
self.tarifa_seleccionada = 0
#-------------------- Secuencia lectura boleto
self.boleto = ""
self.folio= ""
self.expedidora = ""
self.hora_entrada = ""
self.fecha_entrada = ""
self.tiempo_estacionado = ""
def ejecutar_programa(self):
pass
def secuencia_error(self):
return 1
def secuencia_cancelacion(self):
return 1
def finalizar_operacion(self):
self.registrar_pago()
self.reiniciar_variables()
return 1
def cajero_suspendido(self):
return 1
def habilitar_dispositivos_cobro(self):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(self.listaDeVariables.dispositivos[0].MONEDERO_HABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(self.listaDeVariables.dispositivos[1].BILLETERO_HABILITAR)
def deshabilitar_dispositivos_cobro(self):
self.listaDeVariables.dispositivos[0].ejecutarInstruccion(self.listaDeVariables.dispositivos[0].MONEDERO_DESHABILITAR)
self.listaDeVariables.dispositivos[1].ejecutarInstruccion(self.listaDeVariables.dispositivos[1].BILLETERO_DESHABILITAR)
def deshabilitar_dispositivos_cobro2(self):
i = 0
direccion_dispositivo = 0
for i,dispositivo_seleccionado in enumerate(self.dispositivo):
if dispositivo_seleccionado['tipo'] == "ACEPTADOR" or dispositivo_seleccionado['tipo'] == "RECICLADOR":
if dispositivo_seleccionado['activo'] == True:
direccion_dispositivo = dispositivo_seleccionado['direccion']
self.listaDeVariables.dispositivos[direccion_dispositivo].ejecutarInstruccion(self.listaDeVariables.dispositivos[direccion_dispositivo].DESHABILITAR)
print("Dispositivo Habilitado: {} {} ".format(dispositivo_seleccionado['nombre'],dispositivo_seleccionado['direccion']))
def habilitar_dispositivos_cobro2(self):
i = 0
direccion_dispositivo = 0
for i,dispositivo_seleccionado in enumerate(self.dispositivo):
if dispositivo_seleccionado['tipo'] == "ACEPTADOR" or dispositivo_seleccionado['tipo'] == "RECICLADOR":
if dispositivo_seleccionado['activo'] == True:
direccion_dispositivo = dispositivo_seleccionado['direccion']
self.listaDeVariables.dispositivos[direccion_dispositivo].ejecutarInstruccion(self.listaDeVariables.dispositivos[direccion_dispositivo].HABILITAR)
print("Dispositivo Habilitado: {} {} ".format(dispositivo_seleccionado['nombre'],dispositivo_seleccionado['direccion']))
def dispensar_cambio2(self,cambio_solicitado):
print("------------- Cambio Solicitado: ",cambio_solicitado,"-------------------")
cambio = 0
i = 0
direccion_dispositivo = 0
cambioRestante = cambio_solicitado
for i,dispositivo_seleccionado in enumerate(self.dispositivo):
if dispositivo_seleccionado['tipo'] == "DISPENSADOR" or dispositivo_seleccionado['tipo'] == "RECICLADOR":
if dispositivo_seleccionado['activo'] == True:
direccion_dispositivo = dispositivo_seleccionado['direccion']
denominaciones = dispositivo_seleccionado['numero_serie']
denominaciones = denominaciones.split(".")
for denominacion in denominaciones:
denominacion = int(denominacion)
cambio = int(cambio_solicitado/denominacion)
if(cambio):
cambio_solicitado = cambio_solicitado%denominacion
#self.listaDeVariables.dispositivos[6].ejecutarInstruccion(self.listaDeVariables.dispositivos[6].DISPENSAR,cambio,denominacion)
cambioRestante = cambioRestante - (cambio*denominacion)
print("Dispositivo seleccionado: {} Direccion: {} ".format(dispositivo_seleccionado['nombre'],dispositivo_seleccionado['direccion']))
print("Cambio entregado: {} unidad(es) de {} = ${} ".format(cambio,denominacion,cambio*denominacion))
#print("Cambio restante: ${} ".format(cambioRestante))
print("Secuencia cambio finalizada")
def solicitarCambio(cambioSolicitado):
global PAY_OUT_JCM,SECUENCIA_COBRO
#cambioSolicitado = 177
cambioEntregado10 = 0
cambioEntregado5 = 0
cambioEntregado1 = 0
monedasDispensadas = 0
estatus = 0
HOPPER_MONEDAS_SOLICITADAS = {10:0,5:0,1:0}
HOPPER_MONEDAS_DISPENSADAS = {10:0,5:0,1:0}
MONEDAS = [10,5,1]
BILLETES = [100,50]
cambioRestante = cambioSolicitado
i = 0
print("------------- Cambio Solicitado: ",cambioSolicitado,"-------------------")
for billete in BILLETES:
repeticiones = BILLETES.count(billete)
i = i +1
cambio = int(cambioSolicitado/billete)
if(cambio):
cambioSolicitado = cambioSolicitado%billete
###PAY_OUT_JCM = [252, 9, 240, 32, 74, cambio, i]
###SECUENCIA_COBRO = 2
self.listaDeVariables.dispositivos[6].ejecutarInstruccion(self.listaDeVariables.dispositivos[6].DISPENSAR,cambio,bilelte)
print('cambio en billetes de ',billete,' : ', cambio,'cambioSolicitado',cambioSolicitado)
cambioRestante = cambioRestante - (cambio*billete)
i = 0
for moneda in MONEDAS:
repeticiones = MONEDAS.count(moneda)
i = i +1
#print("reps: ",repeticiones, "iteracion: ", i)
if(repeticiones > 2):
#count(ser)
break
#exit(0)
pass
#print("Cambio Solicitado: ",cambioSolicitado)
#print(moneda,cambio)
cambio = int(cambioSolicitado/moneda)
if(cambio):
cambioSolicitado = cambioSolicitado%moneda
print("\nMonedas solicitadas de ",moneda,": ",cambio)
codigoCambio = cambioHopper(cambio,HOPPER_MONEDAS_HABILITADAS[moneda])
dispensandoCambio = 1
if codigoCambio == [0]:
while(dispensandoCambio):
time.sleep(.3)
estatus = statusHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
if estatus:
if estatus[1]:
#cambioRestante = (estatus[1]*moneda)+cambioSolicitado
print("*Entrgando Cambio*",(estatus[1]*moneda)+cambioSolicitado,"Restante")
else:
dispensandoCambio = 0
if estatus:
if estatus[0]:
monedasPorPagar = estatus[1]
monedasDispensadas = estatus[2]
monedasFaltantes = estatus[3]
if monedasFaltantes:
MONEDAS.append(moneda)
cambioSolicitado = cambioSolicitado + (monedasFaltantes*moneda)
#print("monedas por pagar de ",moneda,": ",monedasPorPagar)
print("monedas enrtegadas de ",moneda,": ",monedasDispensadas)
cambioRestante = cambioRestante - (monedasDispensadas*moneda)
print("Cambio incompleto , faltan ",monedasFaltantes," de $",moneda, "Restante: ",cambioRestante)
resetHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
habilitarHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
else:
#print("monedas pendientes en el pago de ",moneda,": ",monedasDispensadas)
cambioRestante = cambioRestante - (monedasDispensadas*moneda)
print("monedas enrtegadas de ",moneda,": ",monedasDispensadas)
print("monedas faltantes: ",monedasFaltantes," monedas",MONEDAS,"Cambio Restante:",cambioRestante)
#HOPPER_MONEDAS_DISPENSADAS.update({})
else:
print("Hopper ",HOPPER_MONEDAS_HABILITADAS[moneda],"No puede dar cambio: Deshabilitado")
else:
print("No se pudo obtener el status")
else:
resetHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
habilitarHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
print("No se entrego el cambio, Hopper",HOPPER_MONEDAS_HABILITADAS[moneda],"Deshabilitado,","Faltaron",cambio,"monedas de $",moneda)
#cambioRestante = cambioRestante+(cambio*moneda)
#-------------VERIFICACION FINAL DEL STATUSHOPPER ---------------
'''
estatus = statusHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
print("ultima moneda: ",moneda,cambioSolicitado,estatus,estatus[1],cambioSolicitado)
if estatus:
if estatus[3]:
cambioRestante = (estatus[3]*moneda)+cambioSolicitado
resetHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
habilitarHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
print("Cambio restante...: ",cambioRestante,"Reiniciando hopper")
else:
if estatus[0]:
cambioRestante = (estatus[3]*moneda)+cambioSolicitado
print("Cambio restante...: ",cambioRestante,"est0")
pass
else:
print("Cambio restante...: ",cambioRestante,"Reiniciando")
resetHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
habilitarHopper(HOPPER_MONEDAS_HABILITADAS[moneda])
'''
print("Cambio restante...: ",cambioRestante)
print("Cambio restante: ",cambioRestante)
return cambioRestante
def restar_hora(self,horab,fechab):
horab = horab.split(':',2)
fechab = fechab.split('-')
fechaBoleto = datetime.strptime(str(fechab[0]) + str(fechab[1]) + str(fechab[2]), '%Y%m%d').date()
horaBoleto = datetime.strptime(str(horab[0]) +':'+str(horab[1]) +':'+ str(horab[2]), '%H:%M:%S').time()
fechaActual=datetime.now().date()
horaActual=datetime.now().time()
horayFechaBoleto = datetime.now().combine(fechaBoleto, horaBoleto)
horayFechaActual = datetime.now().combine(fechaActual, horaActual)
restaFechas = horayFechaActual - horayFechaBoleto
aux_dif=(str(restaFechas).split('.',1))[0]
dias = int(restaFechas.days)
segundos = restaFechas.seconds
return dias,segundos,aux_dif
def generar_corte(self,fecha_1,hora_1,fecha_2,hora_2):
fecha_1 = "28-04-2020"
hora_1 = "19:14:18"
fecha_2 = "29-04-2021"
hora_2 = "19:17:18"
body = ""
url = "http://127.0.0.1:8000/api/corte?f1={0}&h1={1}&f2={2}&h2={3}".format(fecha_1,hora_1,fecha_2,hora_2)
self.api.establecer_url(url)
self.api.establecer_metodo('GET')
self.api.establecer_encabezado({'Content-Type': 'application/json'})
response = self.api.enviar(Interfaz.PROCESO,body)
print("#-------------------Prueba Corte: ",response)
print("Exitosos: ",response['exitosos'])
print("Incidencias: ",response['incidencias'])
print("Cancelados: ",response['cancelados'])
print("Ingreso total: ",response['ingreso'])
ruta = os.path.join(os.path.dirname(__file__))
sys.path.append(ruta)
from Variables.Variable import Variable
from Variables.Temporizador import Temporizador
from Monitor.Hopper import Hopper
contador = 0
ct_max = 5
INSTRUCCIONES = ["A_MON", "A_BIL", "CAMBIO", "CHECK_SENSOR"]
TON_01 = Temporizador("TON_01", 2 / ct_max)
while (True):
TON_01.entrada = not TON_01.salida
TON_01.actualizar()
if TON_01.salida:
contador += 1
print("req ----- ", contador)
if (contador >= ct_max):
contador = 0
if contador == 0:
print("acamero ----- ", contador)
time.sleep(1)
if contador == 1:
print("acamero ----- ", contador)
if contador == 2:
print("acamero ----- ", contador)
if contador == 3:
def estatusTubos(self):
#ESTATUS TUBOS
global MONEDAS_POR_SW, suspenderCajero, cajeroSuspendido
TUBOS = [0, 0, 0, 0]
TON = Temporizador("estatusTubos", 6)
while (1):
TON.actualizar()
self.ser.limpiar()
tuboVacio = 0
time.sleep(.1) #Para completar los 500 ms
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.MDB_DATOS,
[10, 1, 10, 0])
self.ser.write(a)
time.sleep(.01)
r = self.ser.read(18) #Verificar en el simulador se ven 19
#print("estatusTubos",r)
if (len(r) > 8):
#print("h", r[4],r[5],r[6],r[7],r)
TUBOS[0] = r[4]
TUBOS[1] = r[5]
TUBOS[2] = r[6]
TUBOS[3] = r[7]
if (r[0] == 0): # Verificar la respuesta <----------
if (r.__sizeof__() >= 30):
for i, tubo in enumerate(TUBOS):
if tubo == 0 and self.MONEDAS_HABILITADAS_MDB[
i] == 1:
#print("tubo: ",i,"cantidad:",tubo,"Habilitado:",MONEDAS_HABILITADAS_MDB[i])
tuboVacio = 1
if (tubo < 20):
nivelDeCambio = 1
if (tubo < 10):
nivelDeCambio = 1
#suspenderCajero=1
#if((r[4] == 0 and MONEDAS_HABILITADAS_MDB[0]) or (r[5] == 0 and MONEDAS_HABILITADAS_MDB[1]) or (r[6] == 0 and MONEDAS_HABILITADAS_MDB[2]) or (r[7] == 0 and MONEDAS_HABILITADAS_MDB[3])):
#if tuboVacio:
if 0:
print("errinfo...")
if self.iniciarTemporizador(TON):
cajeroSuspendido = 1
cs2 = 0
return TUBOS
'''
suspenderCajero=1
if(cajeroSuspendido==1):
suspenderCajero=0
cs2=0
return TUBOS
'''
else:
TON.entrada = 0
TON.actualizar()
suspenderCajero = 0
cs2 = 0
cajeroSuspendido = 0
#print("Estatus de Llenado de Tubo: ", r[0], r[1]) #Verificar si se debe imprimir en Decimal o Ascii
#print("TUBOS: ", TUBOS) #Verificar si se debe imprimir en Decimal o Ascii
mm1 = r[4]
mm2 = r[5]
mm3 = r[6]
mm4 = r[7]
a = self.comunicacion.crearInstruccion(
Comunicacion.PROCESO, Comunicacion.MDB_DATOS,
[0, 0])
self.ser.write(a)
return TUBOS
else:
if self.iniciarTemporizador(TON):
cajeroSuspendido = 1
return TUBOS
class ActualizarVariables(threading.Thread): #arduino
def __init__(self,
listaDeVariables=None,
listaDePuertos=None,
dispositivos=None,
controladora=None):
threading.Thread.__init__(self, name=None)
self.contador = 0
self.listaDeVariables = listaDeVariables
self.listaDePuertos = listaDePuertos
self.dispositivos = dispositivos
self.TipoDeControladora = controladora
self.comunicacion = Comunicacion()
self.TON_00 = Temporizador("TON_00", 1)
self.TON_01 = Temporizador("TON_01", 10)
self.TON_02 = Temporizador("TON_01", 0.04)
self.sistemaFuncionandoCorrectamente = True
# unicamente para la tarjeta de pulso
self.TON_10 = Temporizador("TON_10", 1.5)
self.banderaF3Detectada = False
# unicamente para la tarjeta de interfaz-blanca
self.raspberry_X = []
self.raspberry_Y = []
self.levantarPuertos()
def levantarPuertos(self):
# Se cierran las conexiones anteriores
# Se abren nuevas conexiones
if self.TipoDeControladora == Controladora.CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA:
if self.dispositivos == Controladora.TARJETA_DE_PULSO:
# puede funcionar con tarjeta madre y raspberry
# se abre un puerto de comunicación para manejar la comunicación RS-232
# se utiliza la otra entrada por medio del teclado modificado
self.listaDePuertos.append(PuertoSerie("Puerto Serie"))
self.listaDePuertos[0].modificarConfiguracion(
dispositivo=PuertoSerie.CABLE_USB)
self.listaDePuertos[0].abrirPuerto()
tarea1 = threading.Thread(target=self.keyloggerIniciar)
tarea1.start()
self.aux = 0
tarea2 = threading.Thread(target=self.keyloggerleerArchivo)
tarea2.start()
#TODO:Agregar funcion para modificar la salida de la tarjeta de pulso, admite una sola salida
self.listaDeVariables.Y[3].establecerFuncion(self.funcion_1)
if self.dispositivos == Controladora.TARJETA_DE_INTERFAZ_BLANCA:
# unicamente para raspberry
# se establecen los pines de comunicación GPIO
# de forma aficional se utilizan los pines de comunicacion RX, TX
if version != "raspberrypi":
self.sistemaFuncionandoCorrectamente = False
raise Exception(
'Solamente puede funcionar la tarjeta de interfaz blanca en Raspberry'
)
if self.sistemaFuncionandoCorrectamente:
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
self.DI_00 = 27
self.DI_01 = 22
self.DI_02 = 10
self.DO_03 = 9
GPIO.setup(self.DI_00, GPIO.IN)
GPIO.setup(self.DI_01, GPIO.IN)
GPIO.setup(self.DI_02, GPIO.IN)
GPIO.setup(self.DO_03, GPIO.OUT)
for i in range(4):
self.raspberry_X.append(0)
self.raspberry_Y.append(0)
self.listaDeVariables.Y[3].establecerFuncion(
self.funcion_2)
if self.dispositivos == Controladora.TARJETA_DE_INTERFAZ_NEGRA:
# unicamente para raspberry
# se establecen los pines de comunicación GPIO
# de forma aficional se utilizan los pines de comunicacion RX, TX
if version != "raspberrypi":
self.sistemaFuncionandoCorrectamente = False
raise Exception(
'Solamente puede funcionar la tarjeta de interfaz blanca en Raspberry'
)
if self.sistemaFuncionandoCorrectamente:
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
self.DI_03 = 27
self.DI_01 = 22
self.DI_02 = 10
self.DO_03 = 9
GPIO.setup(self.DI_03, GPIO.IN)
GPIO.setup(self.DI_01, GPIO.IN)
GPIO.setup(self.DI_02, GPIO.IN)
GPIO.setup(self.DO_03, GPIO.OUT)
for i in range(4):
self.raspberry_X.append(0)
self.raspberry_Y.append(0)
self.listaDeVariables.Y[3].establecerFuncion(
self.funcion_4)
if self.dispositivos == Controladora.TARJETA_DE_INTERFAZ_ARDUINO:
# Se abre un solo puerto de comunicación
self.listaDePuertos.append(PuertoSerie("Puerto Serie"))
self.listaDePuertos[0].modificarConfiguracion(
dispositivo=PuertoSerie.ARDUINO_MICRO)
self.contadorDeInstruccion_Arduino = 0
self.lock = threading.Lock()
#puerto.start()
#print("", end="\t")
self.listaDePuertos[0].abrirPuerto()
self.listaDeVariables.Y[3].establecerFuncion(self.funcion_3)
def run(self):
print("Actualizando las variables")
if self.sistemaFuncionandoCorrectamente:
self.funcionando = True
while (self.funcionando):
#TODO:Verificar si se pudieron levantar los puertos
self.TON_00.entrada = not self.TON_00.salida
self.TON_00.actualizar()
self.TON_02.entrada = not self.TON_02.salida
self.TON_02.actualizar()
if self.TON_00.salida:
self.contador += 1
#print (end= "")
print("%d." % self.contador, flush=True)
if self.TON_02.salida:
if self.contador > 1:
if self.TipoDeControladora == Controladora.CONTROLADORA_PARA_EXPEDIDORA_VALIDADORA:
if self.dispositivos == Controladora.TARJETA_DE_PULSO:
self.leerEntradas_TarjetaDePulso()
if self.dispositivos == Controladora.TARJETA_DE_INTERFAZ_BLANCA:
self.leerEntradas_TarjetaInterfazBlanca()
if self.dispositivos == Controladora.TARJETA_DE_INTERFAZ_NEGRA:
self.leerEntradas_TarjetaInterfazNegra()
if self.dispositivos == Controladora.TARJETA_DE_INTERFAZ_ARDUINO:
self.leerEntradas_TarjetaArduino()
print("Hilo terminado de actualizarVariables")
def detener(self):
self.funcionando = False
print("Deteniendo actualizarVariables")
############################################### Metodos para leer entradas de la tarjeta de pulso ################################
def leerEntradas_TarjetaDePulso(self):
#TODO: Verificar si se reunen las condiciones para que funcione la lectura (El puerto esta abierto y se obtiene lecturas y los hilos del keylogger estan vivos)
r = self.listaDePuertos[0].read(10)
#print (r)
if r == b'\xFE':
self.listaDeVariables.establecerX(0, 0)
if r == b'\xF9':
self.listaDeVariables.establecerX(0, 1)
def keyloggerIniciar(self):
print("Iniciando keylogger")
os.system(keylogger_commandoLinux)
def keyloggerleerArchivo(self):
self.funcionando = True
while (self.funcionando):
""" """
time.sleep(0.5)
self.leerArchivo()
self.TON_10.entrada = self.banderaF3Detectada
self.TON_10.actualizar()
if self.banderaF3Detectada:
self.listaDeVariables.establecerX(1, 1)
if self.TON_10.salida:
self.banderaF3Detectada = False
self.listaDeVariables.establecerX(1, 0)
print("Hilo terminado KeyloggerleerArchivo")
self.cerrarArchivo()
def abrirArchivo(self):
try:
self.archivo = open(keylogger_ARCHIVO, "r+")
self.aux = True
except IOError:
pass
#print ("El archivo no existe", file = sys.stderr)
def cerrarArchivo(self):
if self.aux:
self.archivo.close()
self.aux = False
def leerArchivo(self):
if self.aux: #El archivo esta abierto
lineas = self.archivo.readlines()
for linea in lineas:
#print (linea)
palabras = linea.split('\n')
#print (palabras)
if palabras[0] == 'F3':
#print ("Se oprimio la tecla F3")
self.banderaF3Detectada = True
else:
self.abrirArchivo()
def funcion_1(self, indice, valor):
#print ("Recibido {} = {}".format(indice, valor))
if valor:
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
self.listaDePuertos[0].write(
"0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&0&".
encode())
############################################### Metodos para leer entradas de la tarjeta con arduino ################################
def ejecutarInstrucciones_TarjetaArduino(self):
# Viene de un hilo que lo esta ejecuntado antes por lo tantose asume que hay un bucle atras
self.contadorDeInstruccion_Arduino += 1
def leerEntradas_TarjetaArduino(self):
#TODO: Verificar se se reunen las condiciones (el puerto esta abierto)
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.BOTON_CANCELAR)
#print ("Mensaje ", a)
#print("Funcionando")
self.lock.acquire()
try:
self.listaDePuertos[0].write(a)
time.sleep(.01)
r = self.listaDePuertos[0].read(6)
finally:
self.lock.release()
instruccionCorrecta = False
if (r):
if len(r) == 6:
if r[0] == ord(Comunicacion.caracterDeInicio):
if r[5] == ord(Comunicacion.caracterDeFin):
instruccionCorrecta = True
#print ("Botones", r)
if instruccionCorrecta:
for j in range(2):
for i in range(8):
self.listaDeVariables.establecerX(i + j * 8,
(r[1 + j] >> i) & 1)
for j in range(2):
for i in range(8):
self.listaDeVariables.Y[i + j * 8].establecerValor(
(r[3 + j] >> i) & 1, MODO="SOLO VARIABLE")
#print ("Y[{}]={}".format(i+j*8, (r[3+j] >> i) & 1))
else:
print("Instrucion recibida de forma incorrecta")
def funcion_3(self, indice, valor):
#print ("Recibido en 3 {} = {}".format(indice, valor))
#TODO: Mejorar la implementación de este sistema para cuando se anexan más tareas simultaneas
self.lock.acquire()
try:
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.LED,
[indice, 1 if valor else 0])
self.listaDePuertos[0].enviarBytes(a)
except:
print("No se pudo enviar la instruccion")
finally:
self.lock.release()
############################################### Metodos para leer entradas de la tarjeta de interfaz blanca unicamente con raspberry###########
def leerEntradas_TarjetaInterfazBlanca(self):
#TODO:Verificar si se reunen las condiciones (solo funciona en rasperry)
# Se leen los valores de los pines
self.raspberry_X[0] = GPIO.input(self.DI_00)
self.raspberry_X[1] = GPIO.input(self.DI_01)
self.raspberry_X[2] = GPIO.input(self.DI_02)
# se mapean los valores a la lista de variables
self.listaDeVariables.establecerX(0, self.raspberry_X[0])
self.listaDeVariables.establecerX(1, self.raspberry_X[1])
self.listaDeVariables.establecerX(2, self.raspberry_X[2])
GPIO.output(self.DO_03, self.raspberry_Y[3])
self.listaDeVariables.Y[3].establecerValor(self.raspberry_Y[3],
MODO="SOLO VARIABLE")
def funcion_2(self, indice, valor):
#print ("Recibido en funcion 2 {} = {}".format(indice, valor))
self.raspberry_Y[indice] = valor
############################################### Metodos para leer entradas de la tarjeta de interfaz negra unicamente con raspberry###########
def leerEntradas_TarjetaInterfazNegra(self):
#TODO:Verificar si se reunen las condiciones (solo funciona en rasperry)
# Se leen los valores de los pines
self.raspberry_X[3] = GPIO.input(self.DI_03)
self.raspberry_X[1] = GPIO.input(self.DI_01)
self.raspberry_X[2] = GPIO.input(self.DI_02)
# se mapean los valores a la lista de variables
self.listaDeVariables.establecerX(3, self.raspberry_X[3])
self.listaDeVariables.establecerX(1, self.raspberry_X[1])
self.listaDeVariables.establecerX(2, self.raspberry_X[2])
GPIO.output(self.DO_03, self.raspberry_Y[3])
self.listaDeVariables.Y[3].establecerValor(self.raspberry_Y[3],
MODO="SOLO VARIABLE")
def funcion_4(self, indice, valor):
#print ("Recibido en funcion 2 {} = {}".format(indice, valor))
self.raspberry_Y[indice] = valor
class ProtocoloMDB ():
def __init__ (self, nombre):
#threading.Thread.__init__ (self, name = nombre)
#print ("iniciado Protocolo MDB")
self.establecerNombre (nombre)
self.listaDeInterfaces = []
self.__estado = 1
self.comunicacion = Comunicacion ()
self.cont = 0
self.bandera = False;
self.hiloFuncionando = False;
self.TON_00 = Temporizador("TON_00",2)
self.TON_01 = Temporizador("TON_01",5)
self.idMDB = []
for i in range (2):
self.idMDB.append ("")
self.hilo = None
self.listaDeElementos = []
self.idEnviarDatosHex = StringVar(value="")
def establecerPuerto (self, puerto):
self.puerto = puerto
def establecerInterfaz (self, interfaz):
self.listaDeInterfaces.append(interfaz)
def obtenerInterfaz(self, indice):
if indice < len(self.listaDeInterfaces):
return self.listaDeInterfaces[indice]
def activar (self):
pass
print ("Desde activar")
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [30, 1, 26, 0])
print (a)
def mensajeRecibido (self, mensaje):
#print ("Recibido %s" % mensaje)
if len(mensaje) > 0:
#self.comunicacion.decodificarInstruccion (mensaje)
self.comunicacion.colocarBytesEnBuffer(mensaje[0])
self.comunicacion.leerInstruccionesDeBufferSerial()
"""
if mensaje:
if self.__estado == 1 and mensaje == b'\x00':
print ("Se cambia estado a 2")
self.__estado = 2
return
if self.__estado == 2 and mensaje == b'\x4D': # Verificar la respuesta (4D = M, 45 = E, 49 = I) <----------
self.puerto.escribirInstruccion(0x00, 0)
self.__estado = 3
print ("Se cambia estado a 3")
if self.__estado == 3 and mensaje == b'\x00':
self.__estado = 4
print ("Deshabilitacion de Monedas Exitosa")
if self.__estado == 4:
cont=cont+1
print("DESHINIBIENDO!---",cont)
self.__estado = 5
if self.__estado == 5 and mensaje == b'\x00':
print("Habilitacion de Monedas Exitosa")
print("LISTO!---")
self.__estado = 6
"""
def establecerNombre (self, nombre):
self.nombre = nombre
def obtenerNombre (self):
return self.nombre
def __str__(self):
return self.obtenerNombre()
def enviarInstruccion_1 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.BOTON_CANCELAR)
self.puerto.enviarBytes(a)
def enviarInstruccion_2 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.ADMINISTRACION, Comunicacion.VERSION)
self.puerto.enviarBytes(a)
def enviarInstruccion_3 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.TEMPERATURA)
self.puerto.enviarBytes(a)
def enviarInstruccion_4 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.RESET)
self.puerto.enviarBytes(a)
def enviarInstruccion_5 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.ADMINISTRACION, Comunicacion.PROGRAMA_0)
self.puerto.enviarBytes(a)
def enviarInstruccion_6 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.ADMINISTRACION, Comunicacion.PROGRAMA_1)
self.puerto.enviarBytes(a);
def enviarInstruccion_7 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.LED, [3, 1])
self.puerto.enviarBytes(a)
def enviarInstruccion_8 (self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.LED, [3, 0])
self.puerto.enviarBytes(a)
def enviarInstruccion_9 (self):
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 0, 0, 15, 0])
#self.puerto.enviarBytes(a)
monto = 2
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 2, 0, (monto * 10), 0, self.comunicacion.checkSum([15,2, (monto * 10)]), 0])
self.puerto.enviarBytes(a)
def enviarInstruccion_10 (self):
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.BANDERAS)
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [11, 1, 11, 0])
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS_INCLUIR_CHECKSUM, [0x08, 1, ])
#self.puerto.write(a)
#time.sleep(.025)
#r = self.puerto.read(50) #Verificar en el simulador se ven 19
print ("Dentro de intruccion 10")
self.puerto.enviarBytes(a)
def agregarElementoDeLista (self, valor, paridad):
elemento = [valor, paridad]
self.listadeElementos.append (elemento)
def stopEnEspera (self):
self.hiloActivado = False;
def detenerHilo (self):
self.hiloFuncionando = False;
def iniciar (self):
if not self.hiloFuncionando:
self.hilo = threading.Thread(target=self.run)
#threads.append(t)
self.hilo.start()
self.hiloActivado = True
def enviarDatos (self, datos):
print ("Dentro de enviarDatos")
aux1= datos
aux2 = 0
i = 0
while True:
aux1 = int (aux1 / 256)
i += 1
#print ("%s %s %d" %(aux1, datos, i))
if aux1 < 1:
break
mensaje = datos.to_bytes(i, byteorder='big')
print ("El mensa es", mensaje)
b = []
for i in mensaje:
print (i)
b.append (i)
print (b)
a = self.puerto.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, mensaje)
self.puerto.enviarBytes(a)
print ("Datos enviados MDB")
#TODO: Agregar moficaci�n para la comunicaci�n con arduino
def run (self):
self.hiloFuncionando = True;
self.hiloActivado = True;
self.cont=0
contador = 0
contador_aux = 0
print ("Desde run protocolo")
self.TON_00.entrada = not self.TON_00.salida
self.TON_00.actualizar()
while self.hiloFuncionando :
if self.hiloActivado:
if self.puerto.is_Open():
self.TON_00.entrada = not self.TON_00.salida
self.TON_00.actualizar()
if self.TON_00.salida:# and contador < 500:
contador = contador + 1;
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [8, 1, 8, 0])
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.BOTON_CANCELAR)
#self.puerto.enviarBytes(a);
if self.__estado == 1:
self.bandera = True
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [8, 1, 8, 0])
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.BOTON_CANCELAR)
self.puerto.enviarBytes(a);
time.sleep(.1)
if self.__estado == 2:
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 0, 0, 15, 0])
self.puerto.enviarBytes(a);
self.bandera = True
time.sleep(.1)
if self.__estado == 3:
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [0, 0])
self.puerto.enviarBytes(a);
self.disable_coin()
time.sleep(200)
#self.bandera = True
self.__estado = 4
print ("Se cambia estado a 4")
if self.__estado == 4:
self.bandera = True
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 5, 0, 20, 0])
self.puerto.enviarBytes(a);
time.sleep(0.5)
if self.__estado == 5:
self.bandera = True
print("DESHINIBIENDO!---",self.cont)
self.enable_coin()
time.sleep(1)
print ("RUN Estado ", self.__estado, self.bandera);
time.sleep(2)
else:
time.sleep(1)
print ("Protocolo MDB terminado")
def disable_coin(self):
self.puerto.limpiar()
"""
self.puerto.escribirInstruccion(0x0C, 1)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
"""
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [12, 1, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0])
self.puerto.enviarBytes(a);
def enable_coin(self):
global mona,mond
mona=60
mond=60
ba = [0x0C, mona, mond]
ckInt = self.checkSum(ba)
print("vals...>>>",mona,mond,ckInt)
#time.sleep(1)
"""
self.puerto.escribirInstruccion(0x0C, 1)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(self.int_to_bytes(mona, 8), 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(self.int_to_bytes(mond, 8), 0)
self.puerto.escribirInstruccion(self.int_to_bytes(ckInt, 8),0)
"""
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 0, 0, mona, 0, 0, 0, mond, 0, ckInt, 0])
self.puerto.enviarBytes(a);
def checkSum(self, arr):
j=0
sum=0
tam=arr.__len__()
while(j<tam):
#print(j, tam)
sum=sum+arr[j]
j=j+1
return 255&sum
class ProtocoloMDB():
def __init__(self, nombre):
#threading.Thread.__init__ (self, name = nombre)
#print ("iniciado Protocolo MDB")
self.establecerNombre(nombre)
self.listaDeInterfaces = []
self.__estado = 1
self.comunicacion = Comunicacion()
self.cont = 0
self.bandera = False
self.hiloFuncionando = False
self.TON_00 = Temporizador("TON_00", 2)
self.TON_01 = Temporizador("TON_01", 5)
self.idMDB = []
for i in range(2):
self.idMDB.append("")
self.hilo = None
self.listaDeElementos = []
def establecerPuerto(self, puerto):
self.puerto = puerto
def establecerInterfaz(self, interfaz):
self.listaDeInterfaces.append(interfaz)
def obtenerInterfaz(self, indice):
if indice < len(self.listaDeInterfaces):
return self.listaDeInterfaces[indice]
def activar(self):
pass
print("Desde activar")
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.MDB_DATOS,
[30, 1, 26, 0])
print(a)
def mensajeRecibido(self, mensaje):
#print ("Recibido %s" % mensaje)
if len(mensaje) > 0:
#self.comunicacion.decodificarInstruccion (mensaje)
self.comunicacion.colocarBytesEnBuffer(mensaje[0])
self.comunicacion.leerInstruccionesDeBufferSerial()
def establecerNombre(self, nombre):
self.nombre = nombre
def obtenerNombre(self):
return self.nombre
def __str__(self):
return self.obtenerNombre()
def enviarInstruccion_1(self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.BOTON_CANCELAR)
self.puerto.enviarBytes(a)
def enviarInstruccion_2(self):
parametros = []
for i, elementos in enumerate(self.listaDeElementos):
parametros.append(elemento[0])
parametros.append(elemento[1])
print("Imprimiendo listaDeElementos>>", parametros)
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.MDB_DATOS,
[8, 1, 8, 0])
self.puerto.enviarBytes(a)
def enviarInstruccion_3(self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.TEMPERATURA)
self.puerto.enviarBytes(a)
def enviarInstruccion_4(self):
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO,
Comunicacion.CCTALK_DATOS)
self.puerto.enviarBytes(a)
def agregarElementoDeLista(self, valor, paridad):
elemento = [valor, paridad]
self.listadeElementos.append(elemento)
def stopEnEspera(self):
self.hiloActivado = False
def detenerHilo(self):
self.hiloFuncionando = False
def iniciar(self):
if not self.hiloFuncionando:
self.hilo = threading.Thread(target=self.run)
#threads.append(t)
self.hilo.start()
self.hiloActivado = True
def run(self):
self.hiloFuncionando = True
self.hiloActivado = True
self.cont = 0
contador = 0
contador_aux = 0
print("Desde run protocoloMDB")
self.TON_00.entrada = not self.TON_00.salida
self.TON_00.actualizar()
while self.hiloFuncionando:
if self.hiloActivado:
if self.puerto.is_Open():
self.TON_00.entrada = not self.TON_00.salida
self.TON_00.actualizar()
if self.TON_00.salida: # and contador < 500:
contador = contador + 1
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [8, 1, 8, 0])
a = self.comunicacion.crearInstruccion(
Comunicacion.PROCESO, Comunicacion.BOTON_CANCELAR)
self.puerto.enviarBytes(a)
"""
if self.__estado == 1:
self.bandera = True
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [8, 1, 8, 0])
#a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.BOTON_CANCELAR)
self.puerto.enviarBytes(a);
time.sleep(.1)
if self.__estado == 2:
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 0, 0, 15, 0])
self.puerto.enviarBytes(a);
self.bandera = True
time.sleep(.1)
if self.__estado == 3:
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [0, 0])
self.puerto.enviarBytes(a);
self.disable_coin()
time.sleep(200)
#self.bandera = True
self.__estado = 4
print ("Se cambia estado a 4")
if self.__estado == 4:
self.bandera = True
a = self.comunicacion.crearInstruccion(Comunicacion.PROCESO, Comunicacion.MDB_DATOS, [15, 1, 5, 0, 20, 0])
self.puerto.enviarBytes(a);
time.sleep(0.5)
if self.__estado == 5:
self.bandera = True
print("DESHINIBIENDO!---",self.cont)
self.enable_coin()
time.sleep(1)
print ("RUN Estado ", self.__estado, self.bandera);
time.sleep(2)
"""
else:
time.sleep(1)
print("Protocolo MDB terminado")
def disable_coin(self):
self.puerto.limpiar()
"""
self.puerto.escribirInstruccion(0x0C, 1)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(0x00, 0)
"""
a = self.comunicacion.crearInstruccion(
Comunicacion.PROCESO, Comunicacion.MDB_DATOS,
[12, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
self.puerto.enviarBytes(a)
def enable_coin(self):
global mona, mond
mona = 60
mond = 60
ba = [0x0C, mona, mond]
ckInt = self.checkSum(ba)
print("vals...>>>", mona, mond, ckInt)
#time.sleep(1)
"""
self.puerto.escribirInstruccion(0x0C, 1)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(self.int_to_bytes(mona, 8), 0)
self.puerto.escribirInstruccion(0x00, 0)
self.puerto.escribirInstruccion(self.int_to_bytes(mond, 8), 0)
self.puerto.escribirInstruccion(self.int_to_bytes(ckInt, 8),0)
"""
a = self.comunicacion.crearInstruccion(
Comunicacion.PROCESO, Comunicacion.MDB_DATOS,
[15, 1, 0, 0, mona, 0, 0, 0, mond, 0, ckInt, 0])
self.puerto.enviarBytes(a)
def checkSum(self, arr):
j = 0
sum = 0
tam = arr.__len__()
while (j < tam):
#print(j, tam)
sum = sum + arr[j]
j = j + 1
return 255 & sum