Phi3-Sprachmodell vor Ort, das als Heimassistent fungiert.

from tkinter import *
from openai import OpenAI
import time
from voz import play_audio
from funciones import save_cesar
import vosk
import pyaudio
import threading
import json 
import serial
import subprocess
from langchain_community.document_loaders import TextLoader
from langchain_community.embeddings import OllamaEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.prompts import ChatPromptTemplate, PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_community.chat_models import ChatOllama
from langchain_core.runnables import RunnablePassthrough
from langchain.retrievers.multi_query import MultiQueryRetriever

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

local_path = "datoscasa2.txt"

# Local .txt file uploads
if local_path:
    loader = TextLoader(file_path=local_path)  # Use TextFileLoader for .txt
    data = loader.load()  # Load with explicit encoding
else:
    print("Upload a .txt file")
# Split and chunk 
text_splitter = RecursiveCharacterTextSplitter(chunk_size=7500, chunk_overlap=100)
chunks = text_splitter.split_documents(data)

# Define a persistent collection name (avoid deletion after each interaction)
collection_name = "local-rag"
custom_db_directory = "/Users/cesarhernandez/Documents/PlatformIO/Projects/RAG-1/prueba2"


vector_db = Chroma.from_documents(
    documents=chunks,
    embedding=OllamaEmbeddings(model="phi3", show_progress=False),
    collection_name=collection_name,
    persist_directory=custom_db_directory
)

# LLM from Ollama
local_model = "phi3"
llm = ChatOllama(model=local_model)

QUERY_PROMPT = PromptTemplate(
    input_variables=["question"],
    template="""Eres una asistente y te llamas Lara. 
    Pregunta original: {question}""",
)

retriever = MultiQueryRetriever.from_llm(
    vector_db.as_retriever(),
    llm,
    prompt=QUERY_PROMPT
)

# RAG prompt
template = """Debes de responder a cualquier pregunta:
{context}
Pregunta: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

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")
              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_ventana():
    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() 
  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:
    resultado = chain.invoke(texto_introducido)
    print(resultado)
    respuesta=resultado
    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_ventana()
    ventana.mainloop()  
if __name__ == "__main__":

    main()

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.")

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('datoscasa2.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 serial.serialutil.SerialException:
    # Manejo del error cuando no hay dispositivo conectado al puerto USB
    print("No hay ningún dispositivo conectado al puerto USB.")
    
except Exception as e:
    # Manejo de cualquier otro tipo de error
    print(f"Se ha producido un error: {e}")
    port.close()

def save_cesar(information):
  with open("/Users/cesarhernandez/Documents/PlatformIO/Projects/Agentes/datoscasa2.txt", "a", newline="") as file:  # Open in append mode
    file.write(information + "\n")
  file.close()

'''
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".
'''

#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>

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

}

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