ChatGPT actuando como asistente de casa

Codigo que carga el ChatGPT:

from tkinter import *
from openai import OpenAI
import time
from voz import play_audio
from funciones import delete_file, save_cesar
import vosk
import pyaudio
import threading
import json 
import serial
import subprocess

api_key="sk-0rtzuhgjhghuztutzuzjhfghfghrtuftghfgh"
client = OpenAI(api_key=api_key)
assistant_id="asst_fjghfgjgkjhjklhjklhhjkhj"

# Ejecutar el segundo código en un subshell
subprocess.Popen(["python3", "datosexcel.py"])

my_assistant = client.beta.assistants.retrieve(assistant_id)
thread = client.beta.threads.create()

file1 = client.files.create(
  file=open("/Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/Comandos.txt", "rb"),
  purpose='assistants'
)

file2 = client.files.create(
  file=open("/Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/temperatura.txt", "rb"),
  purpose='assistants'
)

def record_audio():
    model=vosk.Model(r"/Users/cesarhernandez/Desktop/cesar/Infootec/Mypython/vosk-model-small-es-0.42")
    recognizer = vosk.KaldiRecognizer(model, 16000)
    creadoAsistente=0
    mic = pyaudio.PyAudio()
    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()
            try:
              text = json.loads(text)['text']
            except KeyError:
              continue
            if not text:
              print(text)
              continue
            if text.lower() == "salir":
              creadoAsistente=0 
              play_audio("adios")
              continue
            if text.lower() == "terminar micro":
              creadoAsistente=0
              play_audio("cierro micro") 
              stream.stop_stream()
              stream.close()
              mic.terminate()
              break 
            if text.lower() == "terminar todo":
              creadoAsistente=0
              play_audio("cierro todo")
              delete_file(file1.id) 
              delete_file(file2.id) 
              stream.stop_stream()
              stream.close()
              mic.terminate()
              ventana.destroy()
              break                       
            elif text.lower() == "hola lara" or creadoAsistente==1:
              creadoAsistente=1
              obtener_texto(text)                   

def mostrar_input():
    global entrada
    global ventana
    ventana = Tk()
    ventana.geometry("+%d+%d" % (ventana.winfo_screenwidth() - 300, 0))
    ventana.title("Lara")

    # Crear un widget de entrada de texto
    entrada = Entry(ventana)
    entrada.pack()
    entrada.bind('<Return>', obtener_texto)
    # Crear un botón para obtener el texto
    boton = Button(ventana, text="Obtener texto", command=obtener_texto)
    boton.pack()
    return ventana

def obtener_texto(texto_introducido):
  texto_introducido_ventana = entrada.get()
  if texto_introducido_ventana.strip():  
    texto_introducido = texto_introducido_ventana
  if texto_introducido_ventana.lower() == "terminar ventana":
    play_audio("adios")
    ventana.destroy()
    delete_file(file1.id)
    delete_file(file2.id)   
  if texto_introducido_ventana.lower().startswith("escribir datos "):
    phrase_to_remember = texto_introducido_ventana[len("escribir datos "):].strip()
    save_cesar(phrase_to_remember)
    play_audio("Información guardada, " + phrase_to_remember)
  else:
    message = client.beta.threads.messages.create(
      thread_id=thread.id,
      role="user",
      content=texto_introducido,
      file_ids=[file1.id]
    )
    run = client.beta.threads.runs.create(
      thread_id=thread.id,
      assistant_id=assistant_id
    )
    while run.status == "queued" or run.status == "in_progress":
      run=client.beta.threads.runs.retrieve(
        thread_id=thread.id,
        run_id=run.id
      )
    time.sleep(0.5)
    
    # Retrieve all the messages added after our last user message
    messages = client.beta.threads.messages.list(
      thread_id=thread.id, order="asc", after=message.id
    )

    print(messages.data[0].content[0].text.value)
    respuesta=messages.data[0].content[0].text.value
    if respuesta.lower() == "encender comedor":
      ser = serial.Serial('/dev/tty.usbserial-0001', 9600)
      dato="c1"
      ser.write(dato.encode('utf-8'))
      ser.close()
    if respuesta.lower() == "apagar comedor":
      ser = serial.Serial('/dev/tty.usbserial-0001', 9600)
      dato="c0"
      ser.write(dato.encode('utf-8'))
      ser.close()
    if respuesta.lower() == "encender cocina":
      ser = serial.Serial('/dev/tty.usbserial-0001', 9600)
      dato="ci1"
      ser.write(dato.encode())
      ser.close()
    if respuesta.lower() == "apagar cocina":
      ser = serial.Serial('/dev/tty.usbserial-0001', 9600)
      dato="ci0"
      ser.write(dato.encode())
      ser.close()
    if respuesta.lower() == "encender electrovalvula":
      ser = serial.Serial('/dev/tty.usbserial-0001', 9600)
      dato="v1"
      ser.write(dato.encode())
      ser.close()
    if respuesta.lower() == "apagar electrovalvula":
      ser = serial.Serial('/dev/tty.usbserial-0001', 9600)
      dato="v0"
      ser.write(dato.encode())
      ser.close()
    play_audio(respuesta)
    entrada.delete(0, END)
    return

def main():
    # Se inicia la grabación de audio en una función separada
    record_audio_thread = threading.Thread(target=record_audio)
    
    record_audio_thread.start()
    
    ventana=mostrar_input()
    ventana.mainloop()  
if __name__ == "__main__":

    main()

Codigo de la importancion de libreria en este codigo de: «from voz import play_audio»:

import os
from gtts import gTTS

def play_audio(text):
    try:
        tts = gTTS(text=text, lang="es")
        tts.save("/Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/temp.mp3")
        os.system("/opt/homebrew/bin/mpg123 /Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/temp.mp3")
        os.remove("/Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/temp.mp3")
    except Exception as e:
        print(f"Error reproduciendo el audio: {e}")

# Ejemplo de uso
#play_audio("¡Hola! Esto es una prueba de audio.")

Codigo de la importancion de libreria en este codigo de: «from funciones import delete_file, save_cesar»:

from openai import OpenAI

api_key="sk-oiuzoiuzoiuzoiuzoiuzoiuzoiuzoiu"
assistant_id="asst_poiupiiuhzoiuhzljihlkjhljkhlj"
client=OpenAI(api_key=api_key)

def delete_file(file_id):
  client.files.delete(file_id)
  #print(f"File with ID {file_id} has been deleted.")

def save_cesar(information):
  with open("/Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/datos_de_casa.txt", "a", newline="") as file:  # Open in append mode
    file.write(information + "\n")
  file.close()
#
#def actualizar_vista_archivo(thread_id, file_id):
#  with open("datos_de_casa.txt", "r") as f:
#    contenido_actual = f.read()
#  message = client.beta.threads.messages.create(
#    thread_id=thread_id,
#    role="user",
#    content=contenido_actual,
#    file_ids=[file_id]
#  )

Archivo Comandos.txt:

Con cada consulta que te hago responder solo con las palabras exactas que estan en "Respuesta" y que correspondan con el contexto del comando. 

‘’’
Comando1=“enciende la luz del comedor”; Respuesta1=“encender comedor”.

Comando2=“apagar la luz del comedor”; Respuesta2=“apagar comedor”.

Comando3=“enciende la luz de la cocina”; Respuesta3=“encender cocina”.

Comando4="apaga la luz de la cocina"; Respuesta4="apagar cocina".

Comando5="enciende la electrovalvula"; Respuesta5="encender valvula".

Comando6="apagar la electrovalvula"; Respuesta6="apagar valvula".

Comando7="la temperatura es"; Respuesta7="24 grados centigrados".
‘’’

Codigo interfaz entre ESP32 y archivo .txt:

import serial
import pandas as pd
from datetime import datetime

# Abrir la comunicación serial con el puerto USB
port = serial.Serial('/dev/tty.usbserial-0001', 9600)

try:
    # Crear un DataFrame vacío
    df = pd.DataFrame(columns=['Fecha', 'Datos'])
    i = 0  # Índice para añadir filas al DataFrame

    while True:  # Bucle infinito para leer datos continuamente
        # Leer datos del puerto serial
        data = port.readline().decode('utf-8')

        # Si hay datos, procesarlos y guardar el mensaje en el archivo TXT
        if data:
            # Obtener la fecha actual formateada
            fecha_actual = datetime.now().strftime('%Y-%m-%d')

            # Crear el mensaje deseado
            mensaje = f"La temperatura es {data}"

            # Añadir el mensaje como una nueva fila en el DataFrame
            df.loc[i] = [fecha_actual, mensaje]
            i += 1

            # Guardar el mensaje en el archivo TXT
            with open('temperatura.txt', 'a', encoding='utf-8') as f:
                f.write(mensaje + '\n')

except KeyboardInterrupt:
    # Cerrar el puerto cuando se detiene el programa con Ctrl+C
    print("Programa interrumpido por el usuario.")
    port.close()

except Exception as e:
    # Manejo de cualquier otro tipo de error
    print(f"Se ha producido un error: {e}")
    port.close()

Codigo ESP32 conectada al ordenador:

#include <Arduino.h>
#include <esp_now.h>
#include <WiFi.h>

uint8_t broadcastAddress1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t broadcastAddress2[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

typedef struct struct_message
{
  char a[200];
} struct_message;
struct_message myDataRec;
struct_message myDataSen;

esp_now_peer_info_t peerInfo;

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status)
{
}
void OnDataRecv(const uint8_t *mac, const uint8_t *incomingData, int len)
{
  memcpy(&myDataRec, incomingData, sizeof(myDataRec));
  Serial.println(myDataRec.a);
}
void setup() {
  Serial.begin(9600);
  WiFi.mode(WIFI_STA);
  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  esp_now_register_send_cb(OnDataSent);
  // Register peer
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;

  memcpy(peerInfo.peer_addr, broadcastAddress1, 6);
  //Add peer mac1
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  memcpy(peerInfo.peer_addr, broadcastAddress2, 6);
  //Add peer mac2
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  
  esp_now_register_recv_cb(OnDataRecv);
}

void loop() {
   if (Serial.available()>0) {
    String data = Serial.readString();
    data.toCharArray(myDataSen.a, 200);
    esp_err_t result = esp_now_send(broadcastAddress1, (uint8_t *)&myDataSen, sizeof(myDataSen));
  }
}

Codigo ESP32 del sensor temperatura:

#include <Arduino.h>
#include <esp_now.h>
#include <WiFi.h>
#include <Adafruit_Sensor.h>
#include <DHT.h>

#define DHTPIN 27     
#define DHTTYPE DHT11 
DHT dht(DHTPIN, DHTTYPE);
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

typedef struct struct_message
{
  char a[200];
} struct_message;
struct_message myDataRec;
struct_message myDataSen;

esp_now_peer_info_t peerInfo;

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status)
{
}
void OnDataRecv(const uint8_t *mac, const uint8_t *incomingData, int len)
{
  memcpy(&myDataRec, incomingData, sizeof(myDataRec));
}
void setup() {
  Serial.begin(9600);
  WiFi.mode(WIFI_STA);
  dht.begin();
  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  esp_now_register_send_cb(OnDataSent);
  // Register peer
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
  // Add peer        
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  esp_now_register_recv_cb(OnDataRecv);
}

void loop() {
  delay(5000);

  float h = dht.readHumidity();
  float t = dht.readTemperature();
  //sprintf(myDataSen.a, "%f", t);
  dtostrf(t, 3, 2, myDataSen.a);
  //Serial.println(myDataSen.a);
  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *)&myDataSen, sizeof(myDataSen));
}

Archivo platformio para libreria adafruit:

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter
;   Upload options: custom upload port, speed and extra flags
;   Library options: dependencies, extra library storages
;   Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html

[env:az-delivery-devkit-v4]
platform = espressif32
board = az-delivery-devkit-v4
framework = arduino
lib_deps = https://github.com/adafruit/DHT-sensor-library.git

Codigo ESP32 que enciende la lampara a traves de un rele:

#include <Arduino.h>
#include <esp_now.h>
#include <WiFi.h>

const int ledPin = 27; 
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

typedef struct struct_message
{
  char a[200];
} struct_message;
struct_message myDataRec;
struct_message myDataSen;

esp_now_peer_info_t peerInfo;

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status)
{
}

void OnDataRecv(const uint8_t *mac, const uint8_t *incomingData, int len)
{
  memcpy(&myDataRec, incomingData, sizeof(myDataRec));
  String myString = String(myDataRec.a);
  if (myString == "c1") {
    digitalWrite(ledPin, HIGH);  
  }else if(myString == "c0"){
    digitalWrite(ledPin, LOW);  
  }
}

void setup() {
  Serial.begin(9600);
  WiFi.mode(WIFI_STA);
  pinMode(ledPin, OUTPUT); 
  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  esp_now_register_send_cb(OnDataSent);
  // Register peer
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
  // Add peer        
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
  esp_now_register_recv_cb(OnDataRecv);
}

void loop() {

}

Ejemplo de esquema electrico utilizando un rele para manejar la parte de potencia de 230 voltios en alterna y la parte de maniobra, manejada por los 3.3 voltios en continua en la salida de uno de los pines de la nodemcu. Hay que tener en cuenta que los 230 voltios en corriente alterna son tensiones peligrosas y altamente dañinas en caso de accidente. Se deben extremar medidas de seguridad para manipular estas tensiones, como diferencial, fusiobles, magnetotermicos, etc.

Video de ejemplo de los codigos:

Deja una respuesta Cancelar la respuesta

Deja una respuesta