278 lines
13 KiB
Python
278 lines
13 KiB
Python
"""
|
|
Generador de prompt para adaptación de IO - Este script genera un prompt para ayudar con la
|
|
adaptación de IO entre hardware de PLC Siemens TIA Portal y software master.
|
|
"""
|
|
|
|
# Standard library imports
|
|
import os
|
|
import sys
|
|
import tkinter as tk
|
|
from tkinter import filedialog, messagebox
|
|
import pyperclip # Para copiar al portapapeles
|
|
|
|
# Determine script_root and add to sys.path for custom module import
|
|
try:
|
|
current_script_path = os.path.abspath(__file__)
|
|
script_root = os.path.dirname(
|
|
os.path.dirname(os.path.dirname(os.path.dirname(current_script_path)))
|
|
)
|
|
if script_root not in sys.path:
|
|
sys.path.append(script_root)
|
|
|
|
from backend.script_utils import load_configuration
|
|
|
|
except ImportError:
|
|
print(
|
|
"Error: No se pudo importar 'load_configuration' desde 'backend.script_utils'."
|
|
)
|
|
sys.exit(1)
|
|
except NameError: # __file__ is not defined
|
|
print(
|
|
"Error: __file__ no está definido. Este script podría no estar ejecutándose en un entorno Python estándar."
|
|
)
|
|
sys.exit(1)
|
|
|
|
def verify_path(path, is_file=True):
|
|
"""Verifica si una ruta existe y es un archivo o directorio según corresponda."""
|
|
if is_file:
|
|
return os.path.isfile(path)
|
|
else:
|
|
return os.path.isdir(path)
|
|
|
|
def select_obsidian_folder():
|
|
"""Permite al usuario seleccionar la carpeta base de Obsidian."""
|
|
root = tk.Tk()
|
|
root.withdraw() # Ocultar ventana principal
|
|
|
|
folder_path = filedialog.askdirectory(
|
|
title="Seleccione la carpeta base de Obsidian",
|
|
mustexist=True
|
|
)
|
|
|
|
return folder_path if folder_path else None
|
|
|
|
def generate_prompt():
|
|
"""
|
|
Genera el prompt para la adaptación de IO y lo copia al portapapeles.
|
|
Verifica la existencia de archivos y directorios.
|
|
"""
|
|
# Cargar la configuración para obtener working_directory
|
|
try:
|
|
configs = load_configuration()
|
|
working_directory = configs.get("working_directory")
|
|
if not working_directory:
|
|
print("Error: 'working_directory' no se encontró en la configuración.")
|
|
return False
|
|
if not os.path.isdir(working_directory):
|
|
print(
|
|
f"Error: El directorio de trabajo '{working_directory}' no existe o no es un directorio."
|
|
)
|
|
return False
|
|
except Exception as e:
|
|
print(f"Error al cargar la configuración: {e}")
|
|
return False
|
|
|
|
working_directory_abs = os.path.abspath(working_directory)
|
|
print(f"Usando directorio de trabajo: {working_directory_abs}")
|
|
|
|
# Pedir al usuario que seleccione la carpeta base de Obsidian
|
|
print("Por favor, seleccione la carpeta base de Obsidian para los archivos de equivalencias...")
|
|
obsidian_base_folder = select_obsidian_folder()
|
|
|
|
if not obsidian_base_folder:
|
|
print("No se seleccionó ninguna carpeta. Saliendo...")
|
|
return False
|
|
|
|
print(f"Usando carpeta base de Obsidian: {obsidian_base_folder}")
|
|
|
|
# Definir las rutas a los archivos
|
|
master_table_path = os.path.join(working_directory_abs, "Master IO Tags.md")
|
|
hardware_table_path = os.path.join(working_directory_abs, "Hardware.md")
|
|
adaptation_table_path = os.path.join(working_directory_abs, "IO Adapted.md")
|
|
|
|
# Rutas a los archivos de datos semánticos
|
|
# Intentamos encontrar automáticamente la ruta correcta
|
|
mixer_io_path = os.path.join(obsidian_base_folder, "00 - MASTER", "MIXER", "IO")
|
|
|
|
# Si no existe esta ruta, permitimos seleccionar manualmente
|
|
if not verify_path(mixer_io_path, is_file=False):
|
|
print("Ruta a la carpeta IO no encontrada. Por favor, seleccione la carpeta IO:")
|
|
root = tk.Tk()
|
|
root.withdraw()
|
|
mixer_io_path = filedialog.askdirectory(
|
|
title="Seleccione la carpeta IO dentro de la estructura de Obsidian",
|
|
mustexist=True
|
|
)
|
|
|
|
if not mixer_io_path:
|
|
print("No se seleccionó ninguna carpeta IO. Saliendo...")
|
|
return False
|
|
|
|
equivalences_data_path = os.path.join(mixer_io_path, "SIDEL - Mixer - Equivalences.md")
|
|
default_io_data_path = os.path.join(mixer_io_path, "Default IO for Analog.md")
|
|
|
|
# Verificar que los archivos existan
|
|
files_to_check = [
|
|
{"path": master_table_path, "name": "Master IO Tags.md", "required": True},
|
|
{"path": hardware_table_path, "name": "Hardware.md", "required": True},
|
|
{"path": equivalences_data_path, "name": "SIDEL - Mixer - Equivalences.md", "required": False},
|
|
{"path": default_io_data_path, "name": "Default IO for Analog.md", "required": False}
|
|
]
|
|
|
|
missing_files = []
|
|
for file_info in files_to_check:
|
|
if not verify_path(file_info["path"]):
|
|
if file_info["required"]:
|
|
missing_files.append(f"[REQUERIDO] {file_info['name']}")
|
|
else:
|
|
missing_files.append(f"[OPCIONAL] {file_info['name']}")
|
|
|
|
if missing_files:
|
|
print("Los siguientes archivos no se encontraron:")
|
|
for missing_file in missing_files:
|
|
print(f" - {missing_file}")
|
|
|
|
# Si faltan archivos requeridos, preguntar si se quiere continuar
|
|
if any(f.startswith("[REQUERIDO]") for f in missing_files):
|
|
if not messagebox.askyesno("Archivos faltantes",
|
|
"Faltan archivos requeridos. ¿Desea continuar de todos modos?"):
|
|
print("Operación cancelada.")
|
|
return False
|
|
|
|
# Generar el texto del prompt
|
|
prompt_text = f"""
|
|
Estoy adaptando las entradas y salidas entre un hardware de PLC Siemens Tia Portal y un software master. Para lograr identificar que tags del software master se deben asignar a cada IO del hardware del PLC. Se debe asignar a cada IO del harware un Tag del software master.
|
|
Para que me ayudes con este proceso de busqueda he creado las tablas:
|
|
|
|
$Master_table: que contiene los tags del software master con las descripciones. Esta tabla se divide en 4 subtablas. La "Inputs PLCTags" son los inputs mas utilizados, luego estan los "InputsMaster PLCTags" que son inputs menos utilizados. Lo mismo sucede con "Outputs PLCTags" que son los mas utilizados y "OutputsMaster PLCTags" son los outputs menos utilizados.
|
|
|
|
$Hardware_table: que contiene todo el IO del hardware del PLC. Esta dibidido en diferentes dispositivos ya que algunos componentes se acceden mediante interfaces de comunicaciones como profibus. Pero desde el punto de vista del PLC son inputs o outputs definidos como PEW que significa: P:periferia, W:word , se sigue la nomenclatura alemana de siemens, A:output, E:input.
|
|
|
|
$Adaptation_table: es la tabla que deseo que crees con los IO adaptados. Seria la $Hardware_table con los tags de la $Master_table. Quisiera que se agrege una columna con el nivel de certeza y en caso que el nivel no sea el maximo quisiera que agregues 3 posibles opciones como tag1,tag2,tag3 en una columna nueva.
|
|
|
|
$Equivalences_data tiene información de ciertas equivalencias que pueden ser útiles para las búsquedas.
|
|
$DefaultIO_data tiene conexiones estandard en los casos mas comunes.
|
|
|
|
Para acceder a los archivos para leer o escribir puedes usar el MCP filesystem.
|
|
|
|
# Definiciones de rutas
|
|
$Working_Directory = "{working_directory_abs}"
|
|
$Obsidean_Base_Folder = "{obsidian_base_folder}"
|
|
|
|
# Archivos de entrada
|
|
$Master_table = $Working_Directory + "/Master IO Tags.md"
|
|
$Hardware_table = $Working_Directory + "/Hardware.md"
|
|
|
|
# Archivo de salida
|
|
$Adaptation_table = $Working_Directory + "/IO Adapted.md"
|
|
|
|
# Datos semánticos de apoyo
|
|
$Equivalences_data = "{equivalences_data_path}"
|
|
$DefaultIO_data = "{default_io_data_path}"
|
|
|
|
# CONTEXTO DEL PROYECTO
|
|
Estoy realizando un upgrade de software para equipos SIDEL que migran de un sistema antiguo a uno nuevo. Estos equipos de mezclado de bebidas (mixers) tienen hardware de PLC Siemens que debe ser adaptado al software master moderno. La correcta asignación de entradas/salidas es fundamental para que el sistema funcione adecuadamente.
|
|
|
|
# OBJETIVO
|
|
Crear una tabla de adaptación que asigne correctamente cada entrada/salida (I/O) del hardware de PLC Siemens TIA Portal a los tags correspondientes del software master moderno. Este mapeo permitirá la comunicación efectiva entre el hardware existente y el nuevo software de control.
|
|
|
|
# TECNOLOGÍA Y NOMENCLATURA
|
|
- Sistema de control: Siemens PLC con TIA Portal
|
|
- Nomenclatura Siemens (alemana):
|
|
* E: Entrada (Input) - Ejemplo: I0.1, EW100
|
|
* A: Salida (Output) - Ejemplo: Q0.1, AW100
|
|
* P: Periferia
|
|
* W: Word (16 bits)
|
|
* D: Double Word (32 bits)
|
|
- PEW: Entrada de Periferia Word (Peripheral Input Word)
|
|
- PAW: Salida de Periferia Word (Peripheral Output Word)
|
|
|
|
# DESCRIPCIÓN DE LOS ARCHIVOS
|
|
|
|
## Hardware_table ($Hardware_table)
|
|
- FUNCIÓN: Contiene la configuración completa del hardware del PLC y el detalle de todas las señales de I/O físicas.
|
|
- ESTRUCTURA:
|
|
* Primera sección: Tabla de configuración del PLC con red, direcciones y dispositivos
|
|
* Segunda sección: Tabla de I/O con dirección (ej. I0.1, PEW100), descripción en italiano/inglés y sensor asociado
|
|
- INFORMACIÓN CLAVE: Direcciones de hardware, descripciones físicas y conexiones de sensores/actuadores
|
|
|
|
## Master_table ($Master_table)
|
|
- FUNCIÓN: Define los tags estandarizados en el software master moderno que deben mapearse a las I/O físicas.
|
|
- ESTRUCTURA: Dividido en 4 secciones:
|
|
* "Inputs PLCTags": Entradas más utilizadas
|
|
* "InputsMaster PLCTags": Entradas secundarias
|
|
* "Outputs PLCTags": Salidas más utilizadas
|
|
* "OutputsMaster PLCTags": Salidas secundarias
|
|
- INFORMACIÓN CLAVE: Tags estandarizados, tipos de datos y descripciones en inglés
|
|
|
|
## Equivalences_data ($Equivalences_data)
|
|
- FUNCIÓN: Proporciona equivalencias semánticas entre terminologías antiguas/nuevas y abreviaturas.
|
|
- ESTRUCTURA: Listado de equivalencias como "301 : WATER PUMP = P1"
|
|
- INFORMACIÓN CLAVE: Traducciones entre nomenclaturas, equivalencias entre códigos y nombres descriptivos
|
|
|
|
## DefaultIO_data ($DefaultIO_data)
|
|
- FUNCIÓN: Contiene configuraciones predeterminadas para señales analógicas específicas.
|
|
- ESTRUCTURA: Tabla con tags, tipos de datos y direcciones de memoria para señales analógicas estándar
|
|
- INFORMACIÓN CLAVE: Mapeos predefinidos para señales analógicas comunes, especialmente para comunicación Profibus
|
|
|
|
## Adaptation_table (a crear en $Adaptation_table)
|
|
- FUNCIÓN: Tabla final que mapea cada I/O del hardware a su correspondiente tag del master.
|
|
- ESTRUCTURA: Formato requerido:
|
|
| IO | Master Tag | PLC Description | Master Description | Certeza | Alternative |
|
|
- INFORMACIÓN CLAVE: Resultado del proceso de adaptación con nivel de confianza y alternativas
|
|
|
|
# PROCESO DE ADAPTACIÓN
|
|
Lee ambos archivos ($Hardware_table y $Master_table) y crea una tabla de adaptación que asigne a cada IO del hardware un Tag del software master.
|
|
|
|
El proceso de asignación debe:
|
|
1. Comparar semánticamente descripciones entre ambas tablas, teniendo en cuenta el idioma (italiano/inglés)
|
|
2. Verificar compatibilidad de tipo (input/output) y tamaño de datos
|
|
3. Utilizar las equivalencias en $Equivalences_data para mejorar la coincidencia semántica
|
|
4. Verificar configuraciones estándar en $DefaultIO_data para señales analógicas
|
|
5. Priorizar los tags de las tablas principales ("Inputs PLCTags"/"Outputs PLCTags") sobre las secundarias
|
|
|
|
# FORMATO DE SALIDA
|
|
Crea la tabla con esta estructura exacta:
|
|
| IO | Master Tag | PLC Description | Master Description | Certeza | Alternative |
|
|
|
|
# NIVELES DE CERTEZA
|
|
Asigna niveles de certeza según estos criterios:
|
|
- Alto (90%+): Coincidencia evidente en nombre y descripción
|
|
- Medio (70-90%): Similitud semántica notable pero no exacta
|
|
- Bajo (<70%): Similitud limitada, requiere revisión manual
|
|
|
|
Para entradas con nivel de certeza medio o bajo, añade hasta 3 tags alternativos en la columna "Alternative" separados por comas.
|
|
|
|
# EXCEPCIONES
|
|
Al final del documento, crea una sección titulada "## Excepciones y Problemas" con una tabla que liste las IO sin asignación clara y el problema detectado.
|
|
"""
|
|
|
|
# Copiar el texto al portapapeles
|
|
try:
|
|
pyperclip.copy(prompt_text)
|
|
print("¡Prompt generado y copiado al portapapeles con éxito!")
|
|
|
|
# Guardar el prompt en un archivo para referencia
|
|
prompt_file_path = os.path.join(working_directory_abs, "IO_Adaptation_Prompt.txt")
|
|
with open(prompt_file_path, "w", encoding="utf-8") as f:
|
|
f.write(prompt_text)
|
|
print(f"Prompt guardado en: {prompt_file_path}")
|
|
|
|
# Mostrar mensaje de éxito
|
|
messagebox.showinfo("Éxito",
|
|
f"Prompt generado y copiado al portapapeles.\n\n"
|
|
f"También se ha guardado en:\n{prompt_file_path}")
|
|
|
|
return True
|
|
except Exception as e:
|
|
print(f"Error al copiar al portapapeles: {e}")
|
|
messagebox.showerror("Error",
|
|
f"Error al copiar al portapapeles: {e}\n\n"
|
|
f"Por favor, instale pyperclip con 'pip install pyperclip'")
|
|
return False
|
|
|
|
if __name__ == "__main__":
|
|
print("Generador de prompt para adaptación de IO")
|
|
print("=========================================")
|
|
generate_prompt()
|