Programmieren Sie ESP32 mit der Stimme und hören Sie die gesprochene Antwort von ESP32.

from envioOrden import run_micropython_code
from GTTS import comunicaVoz

def comprobar(palabra):
    #Comprobar si reconoce una instruccion
    if palabra == 'apaga la luz':
        print('entiendo que apague la luz')
        comunicaVoz("entiendo que apague la luz", "salidaAudio.mp3")
        run_micropython_code(apagaLed)
    elif palabra == 'enciende la luz':
        print('entiendo que encienda la luz')
        comunicaVoz("entiendo que encienda la luz", "salidaAudio.mp3")
        run_micropython_code(enciendeLed)
    elif palabra == 'enciende y apaga':
        print('entiendo que encienda y apague la luz')
        comunicaVoz("entiendo que encienda y apague la luz", "salidaAudio.mp3")
        run_micropython_code(enciendeapaga)
    elif palabra == 'reiniciar':
        print('entiendo que haga un reset')
        comunicaVoz("entiendo que haga un reset", "salidaAudio.mp3")
        run_micropython_code(reset)
    elif palabra == 'dime la temperatura':
        print('la temperatura que hace son')
        comunicaVoz("ok, te digo la temperatura", "salidaAudio.mp3")
        run_micropython_code(temperatura)      
    else:
        print(palabra)
        print('lo siento, no he entendido la instruccion')
        comunicaVoz("lo siento, no he entendido la instruccion", "salidaAudio.mp3")

def apagaLed():
    return '''
import machine
print("apaga")
led=machine.Pin(14, machine.Pin.OUT)
led.off()
t=1000
'''

def enciendeLed():
    return '''
import machine
led=machine.Pin(14, machine.Pin.OUT)
led.on()
t=1000
'''

def enciendeapaga():
    return '''
import machine
led=machine.Pin(14, machine.Pin.OUT)
led.off()
t=1000
'''
def temperatura():
    return '''
import machine
import dht
temperatura=machine.Pin(26)
sensor=dht.DHT11(temperatura)
sensor.measure()
temp=sensor.temperature()
t=temp
'''

def reset():
    return'''
import machine
machine.reset()
'''

import socket
from GTTS import comunicaVoz

def run_micropython_code(main3):
    leerparaESP32=main3()
    HOST = "192.168.4.1"
    PORT = 8080
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        try:
            s.connect((HOST, PORT))
            s.sendall(leerparaESP32.encode('utf-8'))
            data = s.recv(1024)
            text=data.decode('utf-8')
            print(text)
            comunicaVoz(text, "salidaAudio.mp3")
        except socket.gaierror as e:
            print(f"Error en la resolución del nombre de host")
            comunicaVoz("Error en la resolución del nombre de host", "salidaAudio.mp3")
        except socket.timeout as e:
            print(f"Tiempo de espera de conexión agotado")
            comunicaVoz("Tiempo de espera de conexión agotado", "salidaAudio.mp3")
        except ConnectionRefusedError as e:
            print(f"Conexión rechazada por el servidor")
            comunicaVoz("Conexión rechazada por el servidor", "salidaAudio.mp3")
        except socket.error as e:
            print(f"No se pudo conectar a {HOST}:{PORT}")
            comunicaVoz("No se pudo conectar a {HOST}:{PORT}", "salidaAudio.mp3")
        
        return

from vosk import Model, KaldiRecognizer
import pyaudio
from comparaOrdenes import comprobar
from GTTS import comunicaVoz

#https://alphacephei.com/vosk/models
model=Model(r"/Users/cesarhernandez/Desktop/Mypython/vosk-model-small-es-0.42")
recognizer=KaldiRecognizer(model, 16000)
llamada="Hola tarjeta"
finllamada="ya puedes terminar"
mic=pyaudio.PyAudio()
#antiguo buffer 8192
stream= mic.open(format=pyaudio.paInt16, channels=1, rate=16000, input=True, frames_per_buffer=2048)
stream.start_stream()
while True:
    data=stream.read(2048, exception_on_overflow=False)
    if recognizer.AcceptWaveform(data):
        text=recognizer.Result()
        if llamada.lower() in text.lower():
            print("Hola dime que quieres hacer.")
            comunicaVoz("Hola dime que quieres hacer.", "salidaAudio.mp3")
            while True:
                data=stream.read(2048, exception_on_overflow=False)
                if recognizer.AcceptWaveform(data):
                    text=recognizer.Result()
                    if finllamada.lower() in text.lower():
                        print("ok, apago todo el servicio")
                        text="ok, apago todo el servicio"
                        salidaAudio= "salidaAudio.mp3"
                        comunicaVoz(text, salidaAudio) 
                        stream.stop_stream()
                        stream.close()
                        mic.terminate()
                        break
                    else:
                        orden=text.lower()
                        #{
                        #"text" : "enciende la luz"
                        #}
                        orden2=orden[14:-3]
                        comprobar(orden2)
                        break

import gtts
from playsound import playsound

def comunicaVoz(text, output_file):
    # in spanish
    tts = gtts.gTTS(text, lang="es")
    tts.save(output_file)
    playsound(output_file)

import os
import tempfile
from pydub import AudioSegment
from playsound import playsound

def comunicaVoz(text, output_file):
    with tempfile.NamedTemporaryFile(delete=False) as tmp_wav:
        # Convertir texto a voz usando eSpeak y guardar el resultado en un archivo WAV temporal
        os.system(f'espeak -v es "{text}" -w {tmp_wav.name}')

        # Leer el archivo WAV temporal y convertirlo al formato deseado
        audio = AudioSegment.from_wav(tmp_wav.name)

        # Guardar el archivo de audio en el formato deseado
        audio.export(output_file, format="mp3")
        
        playsound("salidaAudio.mp3")

import network
import socket
import time

SSID = "ESP32"
PASSWORD = "po12345678"

def setup_access_point(ssid, password):
    ap = network.WLAN(network.AP_IF)
    ap.active(True)
    ap.config(essid=ssid, password=password, authmode=network.AUTH_WPA2_PSK)
    while not ap.active():
        print("Esperando que el Access Point se active...")
        time.sleep(1)
    print("Access Point activado. SSID:", ssid, "Password:", password)
    return ap

def setup_socket(ap):
    ip, _, _, _ = ap.ifconfig()
    print("IP del Access Point:", ip)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((ip, 8080))
    s.listen(5)
    return s

def main():
    ap = setup_access_point(SSID, PASSWORD)
    s = setup_socket(ap)

    while True:
        print("Esperando conexiones...")
        conn, addr = s.accept()
        print("Conexión desde:", addr)
        data = conn.recv(1024)
        text=data.decode('utf-8')
        if text:
            print(text)
        try:
            exec(text)
            temp=locals()["t"]
            if temp >= 1000:
                response='Instrucciones ejecutadas correctamente'
            elif temp < 1000:
                response='la temperatura son '+ str(temp) +' grados centigrados'
        except Exception as e:
            response = 'Error al ejecutar instrucciones: {}'.format(e)

        #conn.sendall(str(temp).encode('utf-8'))
        conn.sendall(response.encode('utf-8'))
        conn.close()

if __name__ == "__main__":
    main()