class Image_Send(object):
def __init__(self):
self.camara = Webcam()
self.tcp = Comunicacion()
self.host = "127.0.0.1"
self.reintentos = 10 # cantidad de reintentos de conexion de la camara
self.th_cam = ThreadAdmin() # Thread para la camara
self.tiempo = Timer() # Control de fps
self.log = self.__log_default # Para configurar log
def config(self, host, port):
self.host = host
self.camara.config(Ancho=200, Alto=150)
self.tcp.config(host, puerto=port, cliente=False, binario=True, callback=self.__call_conexion)
def config_log(self, Log):
'''posibilidad de configurar clase Log(Texto, Modulo)'''
self.log = Log.log
self.camara.config_log(Log) # enviamos el log configurado a la camara tambien
def iniciar(self):
self.camara.start()
if self.camara.activo: # CONEXION EXITOSA
self.log("CAMARA CONECTADA","IMAGE-SEND")
self.tcp.iniciar()
else:
self.log("CAMARA SIN CONEXION", "IMAGE-SEND")
# Recepcion de datos de la conexion
def __call_conexion(self, codigo, mensaje):
if codigo == 2: # Conexion
self.th_cam.start(self.__th_camara, '', 'CAMARA ENVIO', callback=self.__log_th, enviar_ejecucion=True)
elif codigo == 4: # Recepcion de datos
self.log("RECEPCION INCORRECTA - COD: " + str(codigo) + " Men: " + str(mensaje), "IMAGE-SEND")
elif codigo != 3: # 3 es envio de datos
self.log("COD: " + str(codigo) + " Men: " + str(mensaje), "IMAGE-SEND")
def __th_camara(self, run):
self.tiempo.iniciar()
while self.tcp.conexion and run.value:
frame = self.camara.read() # Lectura de cuadro de camara
self.tcp.enviar(frame) # Enviar cuadro
# print(self.tiempo.fps()) # ver los fps que enviamos (solo envia 5 cuadros la raspberry)
self.tiempo.delay(6)
# Log por defecto
def __log_default(self, Texto, Modulo):
print(Texto)
# Log que devuelve el thread
def __log_th(self, Codigo, Mensaje):
self.log(Mensaje, "IMAGE-SEND")
class Eventos(object):
def __init__(self, c_objetos, c_log):
# type: (Form_Principal, Logg)->None # utilizado para visualizar ayuda
self.objetos = c_objetos
self.log = c_log
# Configuracion de objetos sin graficos
self.tcp_cli = Comunicacion()
self.face_comp = Face_Comp()
self.tcp_cli.config(config.SERVIDOR,
config.PUERTO,
callback=self.evento_conexion)
self.face_comp.config(config.SERVIDOR, config.PUERTO_IMG,
self.objetos.box_imagen, self.objetos.label_fps,
self.fun_envio)
# Metodos de los objetos graficos
self.objetos.bot_conectar.accion(self.click_conectar)
self.objetos.bot_conec_img.accion(self.click_conectar_img)
self.objetos.bot_guardar.accion(self.click_guardar)
self.objetos.chbox_sens_cent.accion(self.click_chbox_sensor_cent)
self.objetos.chbox_sens_izq.accion(self.click_chbox_sensor_izq)
self.objetos.chbox_sens_der.accion(self.click_chbox_sensor_der)
self.objetos.chbox_sens_bru.accion(self.click_chbox_brujula)
self.objetos.bot_update_cent.accion(self.up_sonic_cent_time)
self.objetos.bot_update_bru.accion(self.up_brujula_time)
# Callback a eventos
self.face_comp.config_eventos(self.evento_im_conexion)
###########################################################
### METODOS (ACCIONES DE LOS BOTONES) ###
###########################################################
def click_conectar(self):
"""evento cuando se presiona boton de conexion """
if self.tcp_cli.conexion:
self.objetos.bot_conectar.set_text("Desconectando...")
self.tcp_cli.desconectar()
else:
self.objetos.bot_conectar.set_text("Conectando...")
self.tcp_cli.iniciar()
def click_conectar_img(self):
"""evento cuando se presiona boton de conexion de imagen"""
if self.face_comp.conexion:
self.objetos.bot_conec_img.set_text("Desconectando...")
self.face_comp.desconectar()
else:
self.objetos.bot_conec_img.set_text("Conectando...")
self.face_comp.iniciar()
def click_guardar(self):
"""evento cuando se presiona boton de guardar"""
config.CONFIGURACION.set('CONEXION', 'SERVIDOR',
self.objetos.text_ip.text)
config.CONFIGURACION.set('CONEXION', 'PUERTO',
self.objetos.text_port.text)
config.CONFIGURACION.set('CONEXION', 'PUERTO_IMG',
self.objetos.text_port2.text)
config.CONFIGURACION.set('SONICO', 'UPDATE',
self.objetos.text_speed_cent.text)
with open(config.ARCHIVO, 'w') as archivo:
config.CONFIGURACION.write(archivo) # salvamos el archivo
def click_chbox_sensor_cent(self, estado):
"""evento cuando se presiona checkbox de sensor central"""
if estado:
self.tcp_cli.enviar("SONICO|ENCENDIDO|1")
else:
self.tcp_cli.enviar("SONICO|ENCENDIDO|0")
def click_chbox_brujula(self, estado):
"""evento cuando se presiona checkbox de la brujula"""
if estado:
self.tcp_cli.enviar("COMPAS|ENCENDIDO|1")
else:
self.tcp_cli.enviar("COMPAS|ENCENDIDO|0")
def click_chbox_sensor_izq(self, estado):
"""evento cuando se presiona checkbox de sensor izquierdo"""
if estado:
self.tcp_cli.enviar("[SONICO_IZQ-ON]")
else:
self.tcp_cli.enviar("[SONICO_IZQ-OFF]")
def click_chbox_sensor_der(self, estado):
"""evento cuando se presiona checkbox de sensor derecho"""
if estado:
self.tcp_cli.enviar("[SONICO_DER-ON]")
else:
self.tcp_cli.enviar("[SONICO_DER-OFF]")
def up_sonic_cent_time(self):
"""evento cuando se presiona el boton de actualizacion de tiempo"""
tiempo = self.objetos.text_speed_cent.text
self.tcp_cli.enviar("SONICO|SPEED|" + tiempo)
def up_brujula_time(self):
"""evento cuando se presiona el boton de actualizacion de tiempo"""
tiempo = self.objetos.text_speed_bru.text
self.tcp_cli.enviar("COMPAS|SPEED|" + tiempo)
###########################################################
### EVENTOS (CALLBACK DE CONEXION) ###
###########################################################
def evento_conexion(self, codigo, mensaje):
if codigo == 2: # Conectado
self.objetos.bot_conectar.set_text("Desconectar")
elif codigo == 0: # Desconectado
self.objetos.bot_conectar.set_text("Conectar")
elif codigo == -1: # Error
self.objetos.bot_conectar.set_text("Conectar")
elif codigo == 4: # Recepcion de datos
self.recepcion_datos(mensaje)
else:
self.log.log(str(codigo) + " " + mensaje, "EVENTOS")
###########################################################
### PROCESAMIENTO DE DATOS RECIBIDOS ###
###########################################################
def recepcion_datos(self, datos):
datos = datos.replace("[", "", 1)
datos = datos.replace("]", "", 1)
try:
self.log.log("RECP: " + datos)
mensaje_split = str(datos).split(":", 1)
# recepcion de 2 valores (parametros)
if len(mensaje_split) > 1:
parametro = mensaje_split[0] # Parametro
valor = mensaje_split[1] # valor como string
valor_f = float(valor) # valor como float
valor_int = int(valor_f) # valor como integer
print(valor_int)
if parametro == "COMPAS":
self.objetos.compbox.rotar(int(valor_int))
if parametro == "SONICO-CENT":
self.objetos.prog_cent.set_text(str(valor_int))
if parametro == "SONICO-IZQ":
self.objetos.prog_izq.set_text(str(valor_int))
if parametro == "SONICO-DER":
self.objetos.prog_der.set_text(str(valor_int))
except Exception as e:
self.log.log("ERR: " + str(e))
# EVENTOS
def evento_im_conexion(self, Estado):
if Estado:
self.objetos.bot_conec_img.set_text("Desconectar")
else:
self.objetos.bot_conec_img.set_text("Conectar")
# ENVIOS
def fun_envio(self, modulo, comando, valor):
mensaje = modulo + "|" + comando + "|" + valor
self.tcp_cli.enviar(mensaje)
class Face_Comp(object):
def __init__(self):
self.tcp = Comunicacion()
self.fdetect = Face_Detect2()
self.th_detect = ThreadAdmin()
self.host = ''
self.port = ''
self.ob_imagen = '' # type: Imagen
self.ob_label_fps = '' # type: Label
self.cola_imagen = queue.LifoQueue()
self.conexion = False # Estado de la conexion
self.tiempo = Timer()
self.evento_conexion = '' # Evento que devuelve el estado de la conexion
self.fun_envio = '' # Evento para movimiento de la vista
def config(self, host, puerto, ob_imagen, ob_label_fps, fun_envio):
# type: (str, int, Imagen, Label, object)->None
""" Se requiere IP del Servidor y Objeto Imagen
Devuelve la imagen y los fps en un objeto label
fun envio = fun(modulo, comando, valor)
"""
self.host = host
self.port = puerto
self.ob_imagen = ob_imagen
self.ob_label_fps = ob_label_fps
self.tcp.config(host,
puerto,
binario=True,
callback=self.__call_conexion)
self.fdetect.config(Callback_Imagen=self.__call_imagen)
self.fdetect.config_callback(Func_Unica=self.__call_posdetect)
self.fun_envio = fun_envio
def config_eventos(self, evento_conexion=''):
"""evento_conexion: Funcion que devuelve True o False cuando conecta o desconecta
Ej: def evento(Estado)
"""
self.evento_conexion = evento_conexion
def iniciar(self):
self.tiempo.iniciar()
self.tcp.iniciar()
def desconectar(self):
self.tcp.desconectar()
self.th_detect.close()
def __call_conexion(self, codigo, mensaje):
""" recepcion de datos binarios del servidor tcp"""
# Conectado
if codigo == 2:
self.conexion = True
self.th_detect.start(self.__th_detector,
'',
'DETECTOR',
enviar_ejecucion=True)
self.evento_conexion(True) # Devolvemos conectado
# Desconecado
elif codigo == 0:
self.conexion = False
self.evento_conexion(False) # Devolvemos desconectado
# Recepcion de datos
elif codigo == 4:
self.cola_imagen.put(mensaje) # encolamos la imgen recibida
# Errores
elif codigo == -1:
self.conexion = False
self.evento_conexion(False) # Devolvemos desconectado
# Otros mensajes
else:
if codigo != 3: # 3 es envio de mensajes
print("MEN: " + str(codigo) + " " + str(mensaje))
def __call_imagen(self, cv_imagen):
""" recepcion de imagen procesada por el detector para insertar en el objeto imagen"""
self.ob_imagen.imagen_cv(cv_imagen)
def __th_detector(self, run):
""" envia a analizar las imagenes que entran en cola """
while run.value:
if self.cola_imagen.qsize() > 0:
# print(tiempo.fps())
self.ob_label_fps.set_text("FPS: " +
str(round(self.tiempo.fps(), 2)))
imag = self.cola_imagen.get()
self.fdetect.imagen(imag)
time.sleep(0.01)
def __call_posdetect(self, x, y):
modulo = "FACE"
comando = "CENTRAR"
valor = str(x) + "/" + str(y) # separador de valores /
self.fun_envio(modulo, comando, valor)
class Gestor(object):
def __init__(self):
self.tcp_gestor = Comunicacion()
self.host = "127.0.0.1"
self.log = self.__log_default # Para configurar log
# Elementos de gestion
self.im_send = Image_Send()
self.cara = Robot_Cara()
self.cuerpo = Robot_Cuerpo()
self.voz = '' # type: TTS
self.sonico_cent = UltraSonido()
def config(self, host, voz):
# type: (str, TTS)->None
self.host = host
# conexion del Gestor
self.tcp_gestor.config(host,
cliente=False,
callback=self.__call_conexion)
# Modulos de gestion
self.im_send.config(host=host, port=50002) # Imagen send
self.cara.config() # Cara
self.cara.config_cuerpo(self.cuerpo) # datos del cuerpo a la cara
self.cuerpo.config() # Cuerpo
self.voz = voz
# SENSORES
self.sonico_cent.config(26, 19) # pines trigger y echo
def config_log(self, Log):
"""posibilidad de configurar clase Log(Texto, Modulo)"""
self.log = Log.log
# Imagen send
self.im_send.config_log(Log)
def iniciar(self):
self.log("INICIANDO GESTOR", "GESTOR")
# Gestor
self.tcp_gestor.iniciar()
############################
### RECEPCION DE DATOS ###
############################
def __call_conexion(self, codigo, mensaje):
if codigo == 2: # Conectado
self.log("CONECTADO A GESTOR", "GESTOR")
self.voz.say("Conexion establecida")
# Imagen send
self.im_send.iniciar()
elif codigo == 4: # Recepcion de datos
self.recepcion_datos(mensaje)
elif codigo != 3: # 3 es envio de datos
self.log("COD: " + str(codigo) + " Men: " + str(mensaje), "GESTOR")
# Log por defecto
def __log_default(self, Texto, Modulo):
print(Texto)
###########################################################
### PROCESAMIENTO DE DATOS RECIBIDOS ###
###########################################################
def recepcion_datos(self, datos):
print(datos)
splitted = datos.split("|")
if len(splitted) == 1: # acciones de un solo valor
self.accion_unica(datos)
else:
modulo, comando, valor = datos.split("|")
self.acciones(modulo, comando, valor)
########################################
### ANALISIS DE DATOS DE 1 VALOR ###
########################################
def accion_unica(self, comando):
if comando == "[SONICO-ON]":
TH_SONICO.start(self.hilo_sonico, COLA_SONICO, 'ENVIO_SONICO')
if comando == "[SONICO-OFF]":
TH_SONICO.close()
########################################
### ANALISIS DE RECEPCION DE DATOS ###
########################################
def acciones(self, modulo, comando, valor):
# Selecccion segun modulo
if modulo == "FACE":
self.modulo_FACE(comando, valor)
def modulo_FACE(self, comando, valor):
# Seleccion segun comando
if comando == "CENTRAR":
val_x, val_y = valor.split("/") # seperador de valores /
val_x = int(int(val_x) * -0.2)
val_y = int(int(val_y) * -0.2)
# Mover la cara
self.cara.mover(int(val_x), int(val_y))
########################################
### HILOS ###
########################################
def hilo_sonico(self, cola_tiempo):
tiempo = 1
while self.tcp_gestor.conexion:
# distancia = config.SONICO.distancia()
distancia = self.sonico_cent.distancia_precisa(20)
if distancia > -1:
self.tcp_gestor.enviar("[SONICO:" + str(distancia) + "]")
time.sleep(tiempo)
# revisar cola
if cola_tiempo.qsize() > 0:
tiempo = float(cola_tiempo.get())
print("EXIT SEND DISTANCIA")
class Gestor_cli(object):
def __init__(self, c_objetos):
# type: (Form_Principal)->None # ejemplo ty_ (int, int)
self.conexion = False # Estado de la conexion
self.objeto = c_objetos
self.tcp_gestor = Comunicacion()
self.host = "127.0.0.1"
self.log = self.__log_default # Para configurar log
# Elementos de gestion
self.face_analis = Face_Comp()
self.fun_conexion = '' # devulve ele estado de la conexion
def config(self, host, evento_conexion):
""" host: IP del servidor
evento_conexion devuelve el estado de la conexion
"""
self.host = host
self.tcp_gestor.config(host, callback=self.__call_conexion)
# Modulos de gestion
self.face_analis.config(host, 50002, self.objeto.box_imagen, self.objeto.label_fps, self.enviar)
self.face_analis.config_eventos(self.__evento_face)
self.fun_conexion = evento_conexion
def config_log(self, Log):
"""posibilidad de configurar clase Log(Texto, Modulo)"""
self.log = Log.log
def conectar(self):
self.log("INICIANDO GESTOR CLIENTE", "GESTOR-CLI")
# Gestor
self.tcp_gestor.iniciar()
def desconectar(self):
self.log("DESCONECTAR GESTOR CLIENTE", "GESTOR-CLI")
# Gestor
self.tcp_gestor.desconectar()
def conectar_face(self):
#self.log("INICIANDO GESTOR CLIENTE", "GESTOR-CLI")
self.face_analis.iniciar()
def desconectar_face(self):
#self.log("DESCONECTAR GESTOR CLIENTE", "GESTOR-CLI")
self.face_analis.desconectar()
############################
### ENVIO DE DATOS ###
############################
def enviar(self, modulo, comando, valor):
mensaje = modulo + "|" + comando + "|" + valor
self.tcp_gestor.enviar(mensaje)
############################
### RECEPCION DE DATOS ###
############################
def __call_conexion(self, codigo, mensaje):
if codigo == 2: # Conectado
self.log("CONECTADO A GESTOR SERVIDOR", "GESTOR-CLI")
self.conexion = True
self.fun_conexion(True)
if codigo == 0: # Desconectado
self.conexion = False
self.fun_conexion(False)
def __evento_face(self, estado):
# Log por defecto
def __log_default(self, Texto, Modulo):
print(Texto)
# Esto es para poder hacer el from desde un nivel atras y funciona con launch.json
import os, sys
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)
from componentes.comunicacion import Comunicacion
import time
cli = Comunicacion()
def callback(codigo, mensaje):
print("CALL: ", codigo, mensaje)
cli.config("127.0.0.1", cliente=True, callback=callback)
cli.config_packet("<", ">", 100)
cli.iniciar()
time.sleep(1000)
# Esto es para poder hacer el from desde un nivel atras y funciona con launch.json
import os, sys
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)
from componentes.comunicacion import Comunicacion
import time
serv = Comunicacion()
def callback(codigo, mensaje):
print("CALL: ", codigo, mensaje)
if codigo == 2:
for i in range(25000):
serv.enviar("m" + str(i))
serv.config("127.0.0.1", cliente=False, callback=callback)
serv.config_packet("<", ">", 100)
serv.iniciar()
time.sleep(1000)
tiempo = Timer()
cam.config(0, ModoActivo=True)
cam.start()
time.sleep(1)
def fun_callback(codigo, mensaje):
if codigo != 3: # 3 es envio de datos
print("COD: ", codigo, "Men: ", mensaje)
if codigo == 2:
th_cam.start(th_camara, '', 'CAMARA ENVIO', enviar_ejecucion=True)
def th_camara(run):
time.sleep(2)
tiempo.iniciar()
while tcp.conexion and run.value:
frame = cam.read()
tcp.enviar(frame)
print(tiempo.fps())
tiempo.delay(10)
tcp.config("192.168.0.24", cliente=False, binario=True, callback=fun_callback)
tcp.iniciar()
time.sleep(1000)
# terminar siempre con esta sentencia
ThreadAdmin.close_all()