def error():
ERROR = [
"No te he entendido", "No he podido escuchar nada",
"John, no siento las palabras",
"Error 404, texto no detectado. Espera, no era ese error",
"Ya sé por qué no hablas. La primera regla del club de la lucha es que no se habla del club de la lucha, pero yo estoy dentro"
]
texto_leer = random.choice(ERROR)
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
def run(self):
if not TTS.support(self._provider) :
self.log(F('Неизвестный провайдер: {}', self._provider), logger.CRIT)
self._file_path = self.cfg.path['tts_error']
return self._unlock()
msg = F('{} за {}{}: {}', *self._generating(), self._file_path)
self.log(msg, logger.DEBUG if self._realtime else logger.INFO)
def leer_pagina(rutaPagina, ruta, imagen=None):
# Lee el texto dentro de la imagen
texto_pagina = OCR.ocr(rutaPagina, ruta, imagen)
# Reproduce el texto obtenido por el OCR
pararLeer = TTS.reproducir_texto_tts(texto_pagina, True)
return pararLeer
def _tts_gen(self, file, format_, msg: str):
prov = self.cfg.gts('providertts', 'unset')
key = None
if TTS.support(prov):
sets = utils.rhvoice_rest_sets(self.cfg[prov]) if prov == 'rhvoice-rest' else {}
try:
key = self.cfg.key(prov, 'apikeytts')
tts = TTS.GetTTS(
prov,
text=msg,
buff_size=self._buff_size,
speaker=self.cfg.gt(prov, 'speaker'),
audio_format=format_,
key=key,
lang=LNG['tts_lng_dict'].get(prov, LNG['tts_lng_def']),
emotion=self.cfg.gt(prov, 'emotion'),
url=self.cfg.gt(prov, 'server'),
sets=sets,
yandex_api=self.cfg.yandex_api(prov)
)
except(RuntimeError, TTS.gTTSError) as e:
self._synthesis_error(prov, key, e)
self.file_path = self.cfg.path['tts_error']
return
else:
self.log(LNG['unknown_prov'].format(prov), logger.CRIT)
self.file_path = self.cfg.path['tts_error']
return
self._stream = utils.FakeFP()
write_to = [self._stream]
if file:
write_to.append(open(file, 'wb'))
self._ext = '.{}'.format(format_) if not file else None
self._unlock()
try:
tts.stream_to_fps(write_to)
except (RuntimeError, TTS.gTTSError) as e:
self._synthesis_error(prov, key, e)
for fp in write_to:
fp.close()
return
def __init__(self):
"""初始化"""
# 个人配置初始化
utils.mkdir(self.USER_PATH)
utils.mkdir(self.TEMP_PATH)
utils.mkdir(self.FACE_ID_PATH)
print(self.CONF_FILE)
if os.path.exists(self.CONF_FILE) is False:
for name in ['config.yml', '八戒.pmdl', '小白.pmdl']:
utils.cp(CUR_PATH + '/conf/' + name,
self.USER_PATH + '/' + name)
self.CONFIG_DATA = utils.load_conf(self.CONF_FILE)
# print(self.CONFIG_DATA)
# 主人初始化状态(status: 1face已确认；2名字已确认)
self.master = {
'status': 0,
'time': 0,
'face': '',
'morning': 0,
'noon': 0,
'evening': 0,
'lastask': 0
}
self.guest = {
'status': 0,
'time': 0,
'face': '',
'morning': 0,
'noon': 0,
'evening': 0,
'lastask': 0
}
# self.master.update(self.CONFIG_DATA['master'])
# print(self.master)
# 初始化语音合成
self.saying = '' # 是否正在播放
self.tts = TTS.get_engine_by_slug(config.get('tts_engine',
'baidu-tts'))
# 初始化语音识别
self.listening = '' # 是否正在收音
self.asr = ASR.get_engine_by_slug(
config.get('asr_engine', 'tencent-asr'))
# 启动摄像头人脸识别
self.camera = camera.Face(faceid_path=self.FACE_ID_PATH,
temp_path=self.TEMP_PATH)
#self.camera.get_camera_face(camera_data=self.CAMERA_DATA, callback=camera.show_camera_face_window)
self.camera.get_camera_face(camera_data=self.CAMERA_DATA,
callback=self.patrol)
def _tts_gen(self, file, format_, msg: str):
prov = self.cfg.get('providertts', 'unset')
key = self.cfg.key(prov, 'apikeytts')
if TTS.support(prov):
try:
tts = TTS.GetTTS(
prov,
text=msg,
speaker=self.cfg.get(prov, {}).get('speaker'),
audio_format=format_,
key=key,
lang=self.PROVIDERS[prov],
emotion=self.cfg.get(prov, {}).get('emotion'),
url=self.cfg.get(prov, {}).get('server')
)
except RuntimeError as e:
self._synthesis_error(prov, key, e)
self.file_path = self.cfg.path['tts_error']
return
else:
self.log('Неизвестный провайдер: {}'.format(prov), logger.CRIT)
self.file_path = self.cfg.path['tts_error']
return
self._stream = utils.FakeFP()
write_to = [self._stream]
if file:
write_to.append(open(file, 'wb'))
self._ext = '.{}'.format(format_) if not file else None
self._unlock()
try:
tts.stream_to_fps(write_to)
except RuntimeError as e:
self._synthesis_error(prov, key, e)
for fp in write_to:
fp.close()
return
def _found_in_cache(self, rname: str, ext: str):
prov_priority = self.cfg.gt('cache', 'tts_priority', '')
self._file_path = None
if TTS.support(prov_priority): # Приоритет
self._file_path = self._file_check(prov_priority, rname, ext)
if not self._file_path and prov_priority != self._provider: # Обычная, второй раз не чекаем
self._file_path = self._file_check(self._provider, rname, ext)
if not self._file_path and prov_priority == '*': # Ищем всех
for key in TTS.PROVIDERS:
if key != self._provider:
self._file_path = self._file_check(key, rname, ext)
if self._file_path:
break
return self._file_path
def _tts_gen(self, file, format_, msg: str):
key = None
sets = utils.rhvoice_rest_sets(self.cfg[self._provider]) if self._provider == 'rhvoice-rest' else {}
try:
key = self.cfg.key(self._provider, 'apikeytts')
tts = TTS.GetTTS(
self._provider,
text=msg,
buff_size=self._buff_size,
speaker=self.cfg.gt(self._provider, 'speaker'),
audio_format=format_,
key=key,
lang=self.cfg.tts_lang(self._provider),
emotion=self.cfg.gt(self._provider, 'emotion'),
url=self.cfg.gt(self._provider, 'server'),
sets=sets,
speed=self.cfg.gt(self._provider, 'speed'),
slow=self.cfg.gt(self._provider, 'slow'),
yandex_api=self.cfg.yandex_api(self._provider)
)
except Exception as e:
self._synthesis_error(key, e)
self._file_path = self.cfg.path['tts_error']
return
self._stream = utils.FakeFP()
write_to = [self._stream]
if file:
write_to.append(open(file, 'wb'))
self._ext = '.{}'.format(format_) if not file else None
self._unlock()
try:
tts.stream_to_fps(write_to)
except Exception as e:
self._synthesis_error(key, e)
for fp in write_to:
fp.close()
def leer_libro(lista_paginas, pagina_actual, clientID, sensor, pag_joint,
joint1, joint2, joint3, pagina, brazo1, pagina1, pagina2,
pagina3):
print("Pagina actual: ", pagina_actual)
# Se declara el path donde estaran las hipoteticas fotos hechas por la camara de la maquina
path = 'fotos/el_perfume/'
# Esto seria el codigo si usasemos el sensor del Coppelia. De cara a la simulacion, hemos usado directamente
# imagenes de un libro
'''
imagenIzq, imagenDer = robot_orders.hacerCaptura(clientID, sensor)
listaImagenes = [imagenIzq, imagenDer]
# Se le aplican preprocesamiento en VC
for fotoPagina in listaImagenes:
rutaPagina = path +'imagenLeer.jpg'
misc.imsave(rutaPagina, fotoPagina)
leer_pagina(rutaPagina, path)
'''
# Se inicializa el contador para saber si tenemos que pasar pagina (solo pasamos cada 2 lecturas)
# pararLeer es una variable que sirve para indicar si se ha interrumpido al robot.
pararLeer = False
contador = 0
for i in range(pagina_actual, len(lista_paginas)):
contador += 1
# Los diferentes paths absolutos de la foto a analizar
rutaPagina = path + "img" + str(i) + ".jpeg"
#print("pagina: ", rutaPagina)
#print("path: ", path)
# Comienza a leer la pagina. Si el comando es interrumpido, sale automáticamente del for y pide otra accion
pararLeer = leer_pagina(rutaPagina, path)
if pararLeer:
break
# Mueve la pagina en la simulacion cada 2 imagenes leídas
if contador % 2 == 0:
pagina_actual = robot_orders.pasar_pagina(pagina_actual, clientID,
sensor, pag_joint,
joint1, joint2, joint3,
pagina, brazo1, pagina1,
pagina2, pagina3)
# Una vez la pagina es leida, se destruye el archivo.
# En la simulacion no lo hacemos porque no queremos borrar las imagenes que usamos de prueba
#os.remove(rutaPagina)
# Si no se ha parado de leer, el libro ha finalizado el libro/la lectura entera
if not pararLeer:
texto_leer = "Y aqui acaba el libro"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# Si el robot se ha interrumpido, cambia la frase dictada y pide nuevas ordenes
else:
texto_leer = "Okay, paro de leer. ¿Qué hago ahora?"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
return pagina_actual
def main():
# Inicializa la simulacion del robot
brazo1, suction, sensor, joint1, joint2, joint3, pagina, pag_joint, clientID, pagina1, pagina2, pagina3 = robot_orders.initRobot(
)
# Inicializa el reconocedor, el translator y el microfono
reconocedor = sr.Recognizer()
microfono = sr.Microphone()
traductor = recognize_order.Translator()
# Inicia el contador de pagina actual y guarda en lista_paginas todas las fotos obtenidas
pagina_actual = 0
lista_paginas = os.listdir(
'fotos/el_perfume'
) #['img0.jpeg', 'img1.jpeg', 'img2.jpeg','img3.jpeg','img4.jpeg']
# Frases que detectara READER para empezar o finalizar el programa
SALUDO = ("hola", "ey", "hey", "dias", "okey", "ok", "okay", "tardes",
"reader", "rider")
TERMINAR = ("apagate", "apagar", "adios", "cierra", "luego", "noches")
OTRAS = ("google", "guguel", "siri", "alexa")
# Si tras 3 intentos no entiende ninguna orden (iniciar/terminar programa) se cierra automaticamente
intentos = 0
# READER se presenta
texto_leer = "Hola, soy READER."
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# Bucle principal del código. Aquí el programa puede acceder a sus funciones basicas
while True:
# Si READER detecta mas de 3 intentos fallidos, se apaga
if intentos >= 3:
break
intentos += 1
# Se escucha lo que dice el usuario y se usa una funcion para tokenizar, lemmatizar y taggear la frase
resultado = recognize_voice.recognize_speech_from_mic(
reconocedor, microfono)
if resultado['transcription'] is not None:
resultado, _ = recognize_order.escucharOrdenes(
resultado['transcription'], traductor, 0)
print(resultado)
# Flag para saber si iniciar o finalizar el programa
iniciarPrograma = gv.NOT_RECOGNIZED
# Si se dice una palabra en la lista de SALUDO/TERMINAR/OTRAS se inicia una orden
for palabra in reversed(resultado):
aux = palabra[gv.FIRST].lower()
if aux in SALUDO:
iniciarPrograma = gv.START_PROGRAM
break
elif aux in TERMINAR:
iniciarPrograma = gv.GO_SLEEP
break
elif aux in OTRAS:
iniciarPrograma = gv.HORNS
break
if iniciarPrograma == 1:
# READER ofrece sus servicios
texto_leer = "¿En qué te puedo ayudar?"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
intentos = 0
# El programa se inicia porque se ha detectado un saludo
while iniciarPrograma == 1:
if intentos >= 3:
break
# El usuario envia su orden y es reconocido por el voice reconocedor (se traduce a ingles)
resultado = recognize_voice.recognize_speech_from_mic(
reconocedor, microfono)
print(resultado)
print("Result[succes] = ", resultado['success'])
# Si da error por no poder alcanzar la API o por error de captacion, no se hace nada
if resultado['success'] == False:
intentos += 1
error()
elif resultado['success'] == True and resultado[
'transcription'] is None:
intentos += 1
error()
else:
# Si el reconocimiento es positivo, se envia al algoritmo de decision y este devuelve una orden y
# un numero de paginas que desplazarse
orden, num_paginas, texto_leer = recognize_order.recuperarOrden(
resultado['transcription'], traductor)
# Si el robot ha entendido la orden, reinicia los intentos y responde
if orden != gv.UNKNOWN:
intentos = 0
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# Si no ha entendido la orden, responde, pero no reinicia los intentos
elif intentos < 2:
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# El robot no ha entendido la orden
if orden == gv.UNKNOWN:
intentos += 1
# La función para interrumpir al READER mientras habla se ha implementado dentro de la funcion leer_libro
# por lo que no hace falta hacer un caso especial en el main
'''
elif orden == gv.STOP:
intentos = 0
'''
# La funcion ir una pagina atras ha sido absorbida por la función BACK_N_PAGES, la cual ahora puede
# retroceder desde 1 a las que tenga el libro
'''
# Ir una pagina atras
elif orden == gv.BACK_PAGE:
if pagina_actual > 0:
pagina_actual = robot_orders.retroceder_pagina(pagina_actual, clientID, sensor, joint1, joint2,
joint3, pagina, pag_joint)
else:
texto_leer = "...Hay un problema, estamos en la primera pagina. No puedo retroceder"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
pass
'''
# Leer el libro
elif orden == gv.READ_BOOK:
pagina_actual = leer_libro(lista_paginas,
pagina_actual, clientID,
sensor, pag_joint, joint1,
joint2, joint3, pagina,
brazo1, pagina1, pagina2,
pagina3)
# Ir n paginas hacia adelante
elif orden == gv.ADVANCE_N_PAGES:
if pagina_actual + num_paginas < len(lista_paginas):
texto_leer = "Pasando " + str(
num_paginas) + " páginas"
print("Pasando ", str(num_paginas), " paginas")
TTS.reproducir_texto_tts(texto_leer)
pagina_actual = robot_orders.pasar_n_paginas(
num_paginas, pagina_actual, clientID, sensor,
pag_joint, joint1, joint2, joint3, pagina,
brazo1, pagina1, pagina2, pagina3)
texto_leer = "Ya he terminado. ¿Qué hago ahora?"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# Ir n paginas hacia atras
elif orden == gv.BACK_N_PAGES:
if pagina_actual >= num_paginas:
texto_leer = "Retrocediendo " + str(
num_paginas) + " páginas"
print("Retrocediendo ", str(num_paginas),
" paginas")
TTS.reproducir_texto_tts(texto_leer)
robot_orders.retroceder_n_paginas(
num_paginas, pagina_actual, clientID, sensor,
joint1, joint2, joint3, pagina, pag_joint,
pagina1, pagina2, pagina3)
texto_leer = "Ya he terminado. ¿Qué hago ahora?"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
else:
texto_leer = "...Hay un problema. No puedo retroceder tantas páginas atrás."
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# Apagar READER
else:
iniciarPrograma = gv.GO_SLEEP
break
# Apagar el programa
if iniciarPrograma == gv.GO_SLEEP:
break
# No ha entendido/escuchado nada
elif iniciarPrograma == gv.NOT_RECOGNIZED:
error()
# Alternativa joke si se habla de un Asistente de Voz
elif iniciarPrograma == gv.HORNS:
texto_leer = "¿Quién es esa otra IA que has llamado? Creía que teníamos algo especial."
intentos = 3
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# Si se ha intentado mas de 3 veces, el robot se apaga automaticamente
if intentos >= 3:
texto_leer = "Bueno, creo que no nos estamos entendiendo. Mejor me voy a dormir."
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)
# READER se despide
texto_leer = "Buenas noches"
print(texto_leer)
TTS.reproducir_texto_tts(texto_leer)