ChatGPT als Heimassistent

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()

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()

#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[50];
} 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, 50);
    esp_err_t result = esp_now_send(broadcastAddress1, (uint8_t *)&myDataSen, sizeof(myDataSen));
  }
}

#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[50];
} 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));
}

; 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

#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[50];
} 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() {

}