eip2nats 1.0.0__tar.gz

eip2nats-1.0.0/.gitignore

@@ -0,0 +1,67 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.venv/
+
+# PyPI
+.pypirc
+
+# Hatch
+.hatch/
+.env
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.hypothesis/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Project specific
+# Mantener la estructura pero ignorar archivos compilados
+src/eip2nats/lib/*.so*
+src/eip2nats/lib/*.a
+
+# Build artifacts
+build/dependencies/
+*.cmake
+CMakeCache.txt
+CMakeFiles/
+Makefile
+
+# Logs
+*.log

eip2nats-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

eip2nats-1.0.0/PKG-INFO

@@ -0,0 +1,333 @@
+Metadata-Version: 2.4
+Name: eip2nats
+Version: 1.0.0
+Summary: EtherNet/IP to NATS Bridge with bundled dependencies
+Project-URL: Homepage, https://github.com/yourusername/eip2nats
+Project-URL: Documentation, https://github.com/yourusername/eip2nats/blob/main/README.md
+Project-URL: Repository, https://github.com/yourusername/eip2nats
+Author-email: Your Name <your.email@example.com>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.7
+Requires-Dist: pybind11>=2.6.0
+Provides-Extra: dev
+Requires-Dist: black>=22.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.0.243; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# eip2nats - EtherNet/IP to NATS Bridge
+
+Puente completo entre dispositivos EtherNet/IP (PLCs) y servidores NATS, **con todas las dependencias incluidas** en el wheel.
+
+## ✨ Características
+
+- ✅ **Self-contained**: Incluye libnats y libEIPScanner compiladas
+- ✅ **Zero dependencies**: No requiere instalación de librerías del sistema
+- ✅ **Entorno virtual**: Compatible con Raspberry Pi OS (sin pip install global)
+- ✅ **Simple instalación**: Setup automático con un comando
+- ✅ **Alto rendimiento**: Bindings nativos C++ con pybind11
+- ✅ **Thread-safe**: Manejo seguro de múltiples conexiones
+
+## 🚀 Instalación Rápida
+
+### Setup Completo Automático
+
+```bash
+./setup_project.sh
+```
+
+Esto hace TODO automáticamente:
+1. Crea un entorno virtual en `venv/`
+2. Instala Hatch y pybind11
+3. Compila nats.c, EIPScanner y el binding Python
+4. Crea el wheel
+5. Instala el wheel en el venv
+
+### Uso Posterior
+
+```bash
+# Activar entorno virtual
+source venv/bin/activate
+
+# Ejecutar ejemplo básico
+python examples/basic_example.py
+
+# O test completo
+python examples/test_bridge.py
+
+# O usar el script helper
+./run.sh  # Ejecuta basic_example.py por defecto
+./run.sh python examples/test_bridge.py
+
+# Desactivar cuando termines
+deactivate
+```
+
+## 💻 Uso
+
+```python
+import eip2nats
+import time
+
+# Crear el bridge
+bridge = eip2nats.EIPtoNATSBridge(
+    "192.168.17.200",              # IP del PLC
+    "nats://192.168.17.138:4222",  # Servidor NATS
+    "plc.data"                     # Subject/topic NATS
+)
+
+# Iniciar
+if bridge.start():
+    print("✅ Bridge corriendo!")
+    
+    # Monitorear
+    while bridge.is_running():
+        time.sleep(5)
+        print(f"📊 RX={bridge.get_received_count()}, "
+              f"TX={bridge.get_published_count()}")
+    
+    # Detener
+    bridge.stop()
+```
+
+**Ver más ejemplos en [`examples/`](examples/README.md)**
+
+## 📋 Requisitos
+
+**Sistema:**
+- Linux (ARM64/x86_64)
+- Python 3.7+
+- git, cmake, make, g++, python3-venv (solo para compilar)
+
+**Para desarrollo:** Ejecutar `./setup_project.sh` (crea venv automáticamente)
+
+## 🛠️ Desarrollo
+
+### Modificar Código C++
+
+Para desarrollo iterativo sin regenerar el wheel:
+
+```bash
+# 1. Editar código
+nano src/eip2nats/EIPtoNATSBridge.cpp
+
+# 2. Opción A: Test C++ standalone (recomendado para debugging)
+./scripts/build_standalone.sh
+./test_standalone
+
+# 3. Opción B: Compilar binding Python (test de integración)
+./scripts/build_python_binding.sh
+python examples/basic_example.py
+```
+
+**Ver guía completa:** [`DEVELOPMENT.md`](DEVELOPMENT.md)
+
+**Incluye:**
+- Workflow de desarrollo iterativo
+- Debugging con VSCode (recomendado) y GDB
+- Detección de memory leaks con Valgrind
+- Testing C++ standalone vs Python binding
+- Cuándo usar cada enfoque
+
+### Crear Release
+
+```bash
+# Cuando estés satisfecho con los cambios
+hatch build
+```
+
+### Clonar el repositorio
+
+```bash
+git clone https://github.com/yourusername/eip2nats.git
+cd eip2nats
+```
+
+### Instalar Hatch
+
+```bash
+pip install hatch
+```
+
+### Compilar dependencias
+
+```bash
+# Esto descarga y compila nats.c, EIPScanner y el binding Python
+python scripts/build_dependencies.py
+```
+
+O usando Hatch:
+
+```bash
+hatch run build-deps
+```
+
+### Crear el wheel
+
+```bash
+hatch build
+```
+
+Esto genera:
+- `dist/eip2nats-1.0.0-*.whl` - Wheel con todas las dependencias incluidas
+- `dist/eip2nats-1.0.0.tar.gz` - Source distribution
+
+### Ejecutar tests
+
+```bash
+hatch run test
+```
+
+## 📦 Estructura del Proyecto
+
+```
+eip2nats/
+├── pyproject.toml              # Configuración Hatch
+├── README.md
+├── src/
+│   └── eip2nats/
+│       ├── __init__.py         # Package Python
+│       ├── bindings.cpp        # Bindings pybind11
+│       ├── EIPtoNATSBridge.h   # Header C++
+│       ├── EIPtoNATSBridge.cpp # Implementación C++
+│       └── lib/                # Librerías compiladas (auto-generado)
+│           ├── libnats.so
+│           ├── libEIPScanner.so
+│           └── eip2nats.*.so
+├── scripts/
+│   └── build_dependencies.py  # Script de compilación
+├── tests/
+│   └── test_basic.py
+└── build/
+    └── dependencies/           # Clones de nats.c y EIPScanner
+        ├── nats.c/
+        └── EIPScanner/
+```
+
+## 🔧 Cómo Funciona
+
+1. **`scripts/build_dependencies.py`**:
+   - Clona nats.c desde GitHub
+   - Compila nats.c → `libnats.so`
+   - Clona EIPScanner desde GitHub
+   - Compila EIPScanner → `libEIPScanner.so`
+   - Compila el binding Python → `eip2nats.*.so`
+   - Copia todos los `.so` a `src/eip2nats/lib/`
+
+2. **`hatch build`**:
+   - Ejecuta el build script automáticamente
+   - Empaqueta `src/eip2nats/` completo (código + `.so`)
+   - Crea el wheel con RPATH relativo (`$ORIGIN`)
+   - El wheel contiene todo lo necesario
+
+3. **`pip install`**:
+   - Instala el wheel
+   - Los `.so` quedan en el site-packages
+   - Python carga las librerías automáticamente
+   - ¡Funciona sin dependencias del sistema!
+
+## 🎯 Ventajas de Este Enfoque
+
+### ✅ Comparado con librerías del sistema:
+- No requiere `sudo apt-get install`
+- No hay conflictos de versiones
+- Portabilidad entre sistemas
+
+### ✅ Comparado con wheels normales:
+- Incluye todas las dependencias C/C++
+- Un solo archivo para instalar
+- Funciona en sistemas sin compiladores
+
+### ✅ Comparado con Docker:
+- Más ligero (MBs vs GBs)
+- Integración directa con Python
+- No requiere privilegios de Docker
+
+## 📊 API Reference
+
+### Clase: `EIPtoNATSBridge`
+
+```python
+bridge = eip2nats.EIPtoNATSBridge(
+    plc_address: str,
+    nats_url: str,
+    nats_subject: str,
+    use_binary_format: bool = True
+)
+```
+
+**Métodos:**
+- `start() -> bool`: Inicia el bridge
+- `stop() -> None`: Detiene el bridge
+- `is_running() -> bool`: Estado del bridge
+- `get_received_count() -> int`: Mensajes del PLC
+- `get_published_count() -> int`: Mensajes a NATS
+
+## 🐛 Troubleshooting
+
+### Error: "cannot open shared object file"
+
+Aunque el wheel incluye las librerías, verifica RPATH:
+
+```bash
+ldd $(python -c "import eip2nats; print(eip2nats.__file__.replace('__init__.py', 'lib/eip2nats.*.so'))")
+```
+
+Todas las dependencias deberían resolverse localmente.
+
+### Recompilar en otro sistema
+
+```bash
+git clone <repo>
+cd eip2nats
+python scripts/build_dependencies.py
+hatch build
+```
+
+### Limpiar builds
+
+```bash
+rm -rf build/ dist/ src/eip2nats/lib/
+```
+
+## 📝 Changelog
+
+### v1.0.0 (2024-02-10)
+- Initial release
+- Self-contained wheel con nats.c y EIPScanner
+- Soporte para formato binario y JSON
+- Thread-safe operations
+
+## 🤝 Contribuir
+
+1. Fork el proyecto
+2. Crea una rama (`git checkout -b feature/amazing`)
+3. Commit cambios (`git commit -m 'Add amazing feature'`)
+4. Push (`git push origin feature/amazing`)
+5. Abre un Pull Request
+
+## 📄 Licencia
+
+MIT License - ver LICENSE file
+
+## 🙏 Créditos
+
+- [nats.c](https://github.com/nats-io/nats.c) - Cliente NATS para C
+- [EIPScanner](https://github.com/nimbuscontrols/EIPScanner) - Librería EtherNet/IP
+- [pybind11](https://github.com/pybind/pybind11) - Python bindings
+
+---
+
+**Hecho con ❤️ para facilitar la integración industrial**

eip2nats-1.0.0/README.md

@@ -0,0 +1,304 @@
+# eip2nats - EtherNet/IP to NATS Bridge
+
+Puente completo entre dispositivos EtherNet/IP (PLCs) y servidores NATS, **con todas las dependencias incluidas** en el wheel.
+
+## ✨ Características
+
+- ✅ **Self-contained**: Incluye libnats y libEIPScanner compiladas
+- ✅ **Zero dependencies**: No requiere instalación de librerías del sistema
+- ✅ **Entorno virtual**: Compatible con Raspberry Pi OS (sin pip install global)
+- ✅ **Simple instalación**: Setup automático con un comando
+- ✅ **Alto rendimiento**: Bindings nativos C++ con pybind11
+- ✅ **Thread-safe**: Manejo seguro de múltiples conexiones
+
+## 🚀 Instalación Rápida
+
+### Setup Completo Automático
+
+```bash
+./setup_project.sh
+```
+
+Esto hace TODO automáticamente:
+1. Crea un entorno virtual en `venv/`
+2. Instala Hatch y pybind11
+3. Compila nats.c, EIPScanner y el binding Python
+4. Crea el wheel
+5. Instala el wheel en el venv
+
+### Uso Posterior
+
+```bash
+# Activar entorno virtual
+source venv/bin/activate
+
+# Ejecutar ejemplo básico
+python examples/basic_example.py
+
+# O test completo
+python examples/test_bridge.py
+
+# O usar el script helper
+./run.sh  # Ejecuta basic_example.py por defecto
+./run.sh python examples/test_bridge.py
+
+# Desactivar cuando termines
+deactivate
+```
+
+## 💻 Uso
+
+```python
+import eip2nats
+import time
+
+# Crear el bridge
+bridge = eip2nats.EIPtoNATSBridge(
+    "192.168.17.200",              # IP del PLC
+    "nats://192.168.17.138:4222",  # Servidor NATS
+    "plc.data"                     # Subject/topic NATS
+)
+
+# Iniciar
+if bridge.start():
+    print("✅ Bridge corriendo!")
+    
+    # Monitorear
+    while bridge.is_running():
+        time.sleep(5)
+        print(f"📊 RX={bridge.get_received_count()}, "
+              f"TX={bridge.get_published_count()}")
+    
+    # Detener
+    bridge.stop()
+```
+
+**Ver más ejemplos en [`examples/`](examples/README.md)**
+
+## 📋 Requisitos
+
+**Sistema:**
+- Linux (ARM64/x86_64)
+- Python 3.7+
+- git, cmake, make, g++, python3-venv (solo para compilar)
+
+**Para desarrollo:** Ejecutar `./setup_project.sh` (crea venv automáticamente)
+
+## 🛠️ Desarrollo
+
+### Modificar Código C++
+
+Para desarrollo iterativo sin regenerar el wheel:
+
+```bash
+# 1. Editar código
+nano src/eip2nats/EIPtoNATSBridge.cpp
+
+# 2. Opción A: Test C++ standalone (recomendado para debugging)
+./scripts/build_standalone.sh
+./test_standalone
+
+# 3. Opción B: Compilar binding Python (test de integración)
+./scripts/build_python_binding.sh
+python examples/basic_example.py
+```
+
+**Ver guía completa:** [`DEVELOPMENT.md`](DEVELOPMENT.md)
+
+**Incluye:**
+- Workflow de desarrollo iterativo
+- Debugging con VSCode (recomendado) y GDB
+- Detección de memory leaks con Valgrind
+- Testing C++ standalone vs Python binding
+- Cuándo usar cada enfoque
+
+### Crear Release
+
+```bash
+# Cuando estés satisfecho con los cambios
+hatch build
+```
+
+### Clonar el repositorio
+
+```bash
+git clone https://github.com/yourusername/eip2nats.git
+cd eip2nats
+```
+
+### Instalar Hatch
+
+```bash
+pip install hatch
+```
+
+### Compilar dependencias
+
+```bash
+# Esto descarga y compila nats.c, EIPScanner y el binding Python
+python scripts/build_dependencies.py
+```
+
+O usando Hatch:
+
+```bash
+hatch run build-deps
+```
+
+### Crear el wheel
+
+```bash
+hatch build
+```
+
+Esto genera:
+- `dist/eip2nats-1.0.0-*.whl` - Wheel con todas las dependencias incluidas
+- `dist/eip2nats-1.0.0.tar.gz` - Source distribution
+
+### Ejecutar tests
+
+```bash
+hatch run test
+```
+
+## 📦 Estructura del Proyecto
+
+```
+eip2nats/
+├── pyproject.toml              # Configuración Hatch
+├── README.md
+├── src/
+│   └── eip2nats/
+│       ├── __init__.py         # Package Python
+│       ├── bindings.cpp        # Bindings pybind11
+│       ├── EIPtoNATSBridge.h   # Header C++
+│       ├── EIPtoNATSBridge.cpp # Implementación C++
+│       └── lib/                # Librerías compiladas (auto-generado)
+│           ├── libnats.so
+│           ├── libEIPScanner.so
+│           └── eip2nats.*.so
+├── scripts/
+│   └── build_dependencies.py  # Script de compilación
+├── tests/
+│   └── test_basic.py
+└── build/
+    └── dependencies/           # Clones de nats.c y EIPScanner
+        ├── nats.c/
+        └── EIPScanner/
+```
+
+## 🔧 Cómo Funciona
+
+1. **`scripts/build_dependencies.py`**:
+   - Clona nats.c desde GitHub
+   - Compila nats.c → `libnats.so`
+   - Clona EIPScanner desde GitHub
+   - Compila EIPScanner → `libEIPScanner.so`
+   - Compila el binding Python → `eip2nats.*.so`
+   - Copia todos los `.so` a `src/eip2nats/lib/`
+
+2. **`hatch build`**:
+   - Ejecuta el build script automáticamente
+   - Empaqueta `src/eip2nats/` completo (código + `.so`)
+   - Crea el wheel con RPATH relativo (`$ORIGIN`)
+   - El wheel contiene todo lo necesario
+
+3. **`pip install`**:
+   - Instala el wheel
+   - Los `.so` quedan en el site-packages
+   - Python carga las librerías automáticamente
+   - ¡Funciona sin dependencias del sistema!
+
+## 🎯 Ventajas de Este Enfoque
+
+### ✅ Comparado con librerías del sistema:
+- No requiere `sudo apt-get install`
+- No hay conflictos de versiones
+- Portabilidad entre sistemas
+
+### ✅ Comparado con wheels normales:
+- Incluye todas las dependencias C/C++
+- Un solo archivo para instalar
+- Funciona en sistemas sin compiladores
+
+### ✅ Comparado con Docker:
+- Más ligero (MBs vs GBs)
+- Integración directa con Python
+- No requiere privilegios de Docker
+
+## 📊 API Reference
+
+### Clase: `EIPtoNATSBridge`
+
+```python
+bridge = eip2nats.EIPtoNATSBridge(
+    plc_address: str,
+    nats_url: str,
+    nats_subject: str,
+    use_binary_format: bool = True
+)
+```
+
+**Métodos:**
+- `start() -> bool`: Inicia el bridge
+- `stop() -> None`: Detiene el bridge
+- `is_running() -> bool`: Estado del bridge
+- `get_received_count() -> int`: Mensajes del PLC
+- `get_published_count() -> int`: Mensajes a NATS
+
+## 🐛 Troubleshooting
+
+### Error: "cannot open shared object file"
+
+Aunque el wheel incluye las librerías, verifica RPATH:
+
+```bash
+ldd $(python -c "import eip2nats; print(eip2nats.__file__.replace('__init__.py', 'lib/eip2nats.*.so'))")
+```
+
+Todas las dependencias deberían resolverse localmente.
+
+### Recompilar en otro sistema
+
+```bash
+git clone <repo>
+cd eip2nats
+python scripts/build_dependencies.py
+hatch build
+```
+
+### Limpiar builds
+
+```bash
+rm -rf build/ dist/ src/eip2nats/lib/
+```
+
+## 📝 Changelog
+
+### v1.0.0 (2024-02-10)
+- Initial release
+- Self-contained wheel con nats.c y EIPScanner
+- Soporte para formato binario y JSON
+- Thread-safe operations
+
+## 🤝 Contribuir
+
+1. Fork el proyecto
+2. Crea una rama (`git checkout -b feature/amazing`)
+3. Commit cambios (`git commit -m 'Add amazing feature'`)
+4. Push (`git push origin feature/amazing`)
+5. Abre un Pull Request
+
+## 📄 Licencia
+
+MIT License - ver LICENSE file
+
+## 🙏 Créditos
+
+- [nats.c](https://github.com/nats-io/nats.c) - Cliente NATS para C
+- [EIPScanner](https://github.com/nimbuscontrols/EIPScanner) - Librería EtherNet/IP
+- [pybind11](https://github.com/pybind/pybind11) - Python bindings
+
+---
+
+**Hecho con ❤️ para facilitar la integración industrial**

eip2nats-1.0.0/eip2nats/EIPtoNATSBridge.cpp

@@ -0,0 +1,321 @@
+#include "EIPtoNATSBridge.h"
+#include "utils/Logger.h"
+#include "utils/Buffer.h"
+#include <sstream>
+#include <iomanip>
+#include <chrono>
+
+using namespace bridge;
+using namespace eipScanner;
+using namespace eipScanner::cip;
+using namespace eipScanner::cip::connectionManager;
+using namespace eipScanner::utils;
+
+EIPtoNATSBridge::EIPtoNATSBridge(const std::string& plcAddress, 
+                                 const std::string& natsUrl,
+                                 const std::string& natsSubject,
+                                 bool useBinaryFormat)
+    : plcAddress_(plcAddress)
+    , natsUrl_(natsUrl)
+    , natsSubject_(natsSubject)
+    , useBinaryFormat_(useBinaryFormat)
+    , natsConn_(nullptr)
+    , natsOpts_(nullptr)
+    , connectionManager_(nullptr)
+    , running_(false)
+    , shouldStop_(false)
+    , publishedCount_(0)
+    , receivedCount_(0)
+{
+    Logger(LogLevel::INFO) << "EIPtoNATSBridge creado - PLC: " << plcAddress 
+                           << " NATS: " << natsUrl 
+                           << " Subject: " << natsSubject
+                           << " Formato: " << (useBinaryFormat ? "Binario" : "JSON");
+}
+
+EIPtoNATSBridge::~EIPtoNATSBridge() {
+    if (running_) {
+        Logger(LogLevel::WARNING) << "Bridge destruido mientras estaba corriendo - deteniendo...";
+        stop();
+    }
+}
+
+bool EIPtoNATSBridge::start() {
+    if (running_) {
+        Logger(LogLevel::WARNING) << "Bridge ya está corriendo";
+        return false;
+    }
+    
+    Logger(LogLevel::INFO) << "Iniciando EIPtoNATS Bridge...";
+    
+    // Inicializar NATS primero
+    if (!initNATS()) {
+        Logger(LogLevel::ERROR) << "Fallo al inicializar NATS";
+        return false;
+    }
+    
+    // Inicializar EIP
+    if (!initEIP()) {
+        Logger(LogLevel::ERROR) << "Fallo al inicializar EIP";
+        closeNATS();
+        return false;
+    }
+    
+    // Arrancar el thread worker
+    shouldStop_ = false;
+    running_ = true;
+    workerThread_ = std::thread(&EIPtoNATSBridge::workerLoop, this);
+    
+    Logger(LogLevel::INFO) << "✅ Bridge iniciado exitosamente";
+    return true;
+}
+
+void EIPtoNATSBridge::stop() {
+    if (!running_) {
+        Logger(LogLevel::WARNING) << "Bridge ya está detenido";
+        return;
+    }
+    
+    Logger(LogLevel::INFO) << "Deteniendo EIPtoNATS Bridge...";
+    
+    // Señalizar al thread que debe detenerse
+    shouldStop_ = true;
+    
+    // Esperar a que el thread termine
+    if (workerThread_.joinable()) {
+        workerThread_.join();
+    }
+    
+    // Cerrar conexiones
+    closeEIP();
+    closeNATS();
+    
+    running_ = false;
+    
+    Logger(LogLevel::INFO) << "✅ Bridge detenido - Mensajes recibidos: " 
+                           << receivedCount_ << " - Mensajes publicados: " 
+                           << publishedCount_;
+}
+
+bool EIPtoNATSBridge::isRunning() const {
+    return running_;
+}
+
+uint64_t EIPtoNATSBridge::getPublishedCount() const {
+    return publishedCount_;
+}
+
+uint64_t EIPtoNATSBridge::getReceivedCount() const {
+    return receivedCount_;
+}
+
+bool EIPtoNATSBridge::initNATS() {
+    Logger(LogLevel::INFO) << "Conectando a NATS: " << natsUrl_;
+    
+    natsStatus s;
+    
+    // Crear opciones
+    s = natsOptions_Create(&natsOpts_);
+    if (s != NATS_OK) {
+        Logger(LogLevel::ERROR) << "Error creando opciones NATS: " << natsStatus_GetText(s);
+        return false;
+    }
+    
+    // Configurar URL
+    s = natsOptions_SetURL(natsOpts_, natsUrl_.c_str());
+    if (s != NATS_OK) {
+        Logger(LogLevel::ERROR) << "Error configurando URL NATS: " << natsStatus_GetText(s);
+        natsOptions_Destroy(natsOpts_);
+        natsOpts_ = nullptr;
+        return false;
+    }
+    
+    // Configurar timeout
+    s = natsOptions_SetTimeout(natsOpts_, 5000);
+    if (s != NATS_OK) {
+        Logger(LogLevel::ERROR) << "Error configurando timeout NATS: " << natsStatus_GetText(s);
+        natsOptions_Destroy(natsOpts_);
+        natsOpts_ = nullptr;
+        return false;
+    }
+    
+    // Conectar
+    s = natsConnection_Connect(&natsConn_, natsOpts_);
+    if (s != NATS_OK) {
+        Logger(LogLevel::ERROR) << "Error conectando a NATS: " << natsStatus_GetText(s);
+        natsOptions_Destroy(natsOpts_);
+        natsOpts_ = nullptr;
+        return false;
+    }
+    
+    Logger(LogLevel::INFO) << "✅ Conectado a NATS exitosamente";
+    return true;
+}
+
+bool EIPtoNATSBridge::initEIP() {
+    Logger(LogLevel::INFO) << "Conectando a PLC EIP: " << plcAddress_;
+    
+    try {
+        // Crear SessionInfo
+        sessionInfo_ = std::make_shared<SessionInfo>(plcAddress_, 0xAF12);
+        
+        // Crear ConnectionManager
+        connectionManager_ = std::make_unique<ConnectionManager>();
+        
+        // Configurar parámetros de conexión (basado en tu código original)
+        ConnectionParameters parameters;
+        parameters.connectionPath = {0x20, 0x04, 0x24, 4, 0x2C, 2, 0x2C, 1};
+        parameters.o2tRealTimeFormat = true;
+        parameters.originatorVendorId = 342;
+        parameters.originatorSerialNumber = 0x12345;
+        
+        parameters.t2oNetworkConnectionParams |= NetworkConnectionParams::P2P;
+        parameters.t2oNetworkConnectionParams |= NetworkConnectionParams::SCHEDULED_PRIORITY;
+        parameters.t2oNetworkConnectionParams |= 100;
+        
+        parameters.o2tNetworkConnectionParams |= NetworkConnectionParams::P2P;
+        parameters.o2tNetworkConnectionParams |= NetworkConnectionParams::SCHEDULED_PRIORITY;
+        parameters.o2tNetworkConnectionParams |= 0;
+        
+        parameters.o2tRPI = 2000;
+        parameters.t2oRPI = 2000;
+        parameters.transportTypeTrigger |= NetworkConnectionParams::CLASS1 | NetworkConnectionParams::TRIG_CYCLIC;
+        
+        // Abrir conexión
+        ioConnection_ = connectionManager_->forwardOpen(sessionInfo_, parameters);
+        
+        if (auto ptr = ioConnection_.lock()) {
+            // Configurar listener para datos recibidos
+            ptr->setReceiveDataListener([this](auto realTimeHeader, auto sequence, auto data) {
+                this->onEIPDataReceived(realTimeHeader, sequence, data);
+            });
+            
+            // Configurar listener para cierre de conexión
+            ptr->setCloseListener([this]() {
+                Logger(LogLevel::WARNING) << "Conexión EIP cerrada por el PLC";
+                shouldStop_ = true;
+            });
+            
+            Logger(LogLevel::INFO) << "✅ Conexión EIP abierta exitosamente";
+            return true;
+        } else {
+            Logger(LogLevel::ERROR) << "Error: No se pudo obtener el puntero de IOConnection";
+            return false;
+        }
+        
+    } catch (const std::exception& e) {
+        Logger(LogLevel::ERROR) << "Excepción al inicializar EIP: " << e.what();
+        return false;
+    }
+}
+
+void EIPtoNATSBridge::closeNATS() {
+    std::lock_guard<std::mutex> lock(natsMutex_);
+    
+    if (natsConn_ != nullptr) {
+        Logger(LogLevel::INFO) << "Cerrando conexión NATS...";
+        natsConnection_Destroy(natsConn_);
+        natsConn_ = nullptr;
+    }
+    
+    if (natsOpts_ != nullptr) {
+        natsOptions_Destroy(natsOpts_);
+        natsOpts_ = nullptr;
+    }
+}
+
+void EIPtoNATSBridge::closeEIP() {
+    Logger(LogLevel::INFO) << "Cerrando conexión EIP...";
+    
+    if (connectionManager_ && sessionInfo_) {
+        try {
+            connectionManager_->forwardClose(sessionInfo_, ioConnection_);
+            Logger(LogLevel::INFO) << "Forward Close enviado";
+        } catch (const std::exception& e) {
+            Logger(LogLevel::ERROR) << "Error en forward close: " << e.what();
+        }
+    }
+    
+    ioConnection_.reset();
+    connectionManager_.reset();
+    sessionInfo_.reset();
+}
+
+void EIPtoNATSBridge::workerLoop() {
+    Logger(LogLevel::INFO) << "Thread worker iniciado";
+    
+    while (!shouldStop_ && connectionManager_->hasOpenConnections()) {
+        // Manejar las conexiones EIP (procesar datos entrantes)
+        connectionManager_->handleConnections(std::chrono::milliseconds(1));
+    }
+    
+    Logger(LogLevel::INFO) << "Thread worker finalizando";
+}
+
+bool EIPtoNATSBridge::publishToNATS(const std::vector<uint8_t>& data) {
+    std::lock_guard<std::mutex> lock(natsMutex_);
+    
+    if (natsConn_ == nullptr) {
+        Logger(LogLevel::ERROR) << "No hay conexión NATS activa";
+        return false;
+    }
+    
+    natsStatus s;
+    
+    if (useBinaryFormat_) {
+        // Publicar datos binarios directamente (más eficiente)
+        s = natsConnection_Publish(natsConn_, 
+                                   natsSubject_.c_str(), 
+                                   data.data(), 
+                                   data.size());
+    } else {
+        // Publicar como JSON (para debugging o interoperabilidad)
+        std::ostringstream jsonStream;
+        jsonStream << "{\"timestamp\":" << time(nullptr) 
+                   << ",\"sequence\":" << receivedCount_
+                   << ",\"size\":" << data.size()
+                   << ",\"data\":\"";
+        
+        // Convertir bytes a hexadecimal
+        for (const auto& byte : data) {
+            jsonStream << std::hex << std::setfill('0') << std::setw(2) << (int)byte;
+        }
+        
+        jsonStream << "\"}";
+        std::string jsonStr = jsonStream.str();
+        
+        s = natsConnection_PublishString(natsConn_, natsSubject_.c_str(), jsonStr.c_str());
+    }
+    
+    if (s == NATS_OK) {
+        publishedCount_++;
+        Logger(LogLevel::DEBUG) << "Publicado a NATS [" << publishedCount_ << "]: " 
+                               << data.size() << " bytes (" 
+                               << (useBinaryFormat_ ? "binario" : "JSON") << ")";
+        return true;
+    } else {
+        Logger(LogLevel::ERROR) << "Error publicando a NATS: " << natsStatus_GetText(s);
+        return false;
+    }
+}
+
+void EIPtoNATSBridge::onEIPDataReceived(uint32_t realTimeHeader, 
+                                        uint16_t sequence, 
+                                        const std::vector<uint8_t>& data) {
+    receivedCount_++;
+    
+    // Log detallado de lo recibido
+    std::ostringstream ss;
+    ss << "EIP RX [" << receivedCount_ << "] seq=" << sequence 
+       << " size=" << data.size() << " data=";
+    for (const auto& byte : data) {
+        ss << std::hex << std::setfill('0') << std::setw(2) << (int)byte << " ";
+    }
+    
+    Logger(LogLevel::DEBUG) << ss.str();
+    
+    // Publicar a NATS
+    if (!publishToNATS(data)) {
+        Logger(LogLevel::WARNING) << "Fallo al publicar datos a NATS";
+    }
+}

eip2nats-1.0.0/eip2nats/EIPtoNATSBridge.h

@@ -0,0 +1,141 @@
+#ifndef EIP_TO_NATS_BRIDGE_H
+#define EIP_TO_NATS_BRIDGE_H
+
+#include <memory>
+#include <thread>
+#include <atomic>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <nats/nats.h>
+#include <cip/connectionManager/NetworkConnectionParams.h>
+#include "SessionInfo.h"
+#include "ConnectionManager.h"
+
+namespace bridge {
+
+/**
+ * @brief Puente entre EtherNet/IP (usando EIPScanner) y NATS
+ * 
+ * Esta clase gestiona una conexión EIP implícita y publica los datos
+ * recibidos a un servidor NATS en un thread separado.
+ */
+class EIPtoNATSBridge {
+public:
+    /**
+     * @brief Constructor
+     * @param plcAddress Dirección IP del PLC
+     * @param natsUrl URL del servidor NATS (ej: "nats://192.168.17.138:4222")
+     * @param natsSubject Subject/topic donde publicar los datos
+     * @param useBinaryFormat Si es true usa binario, si es false usa JSON (default: true)
+     */
+    EIPtoNATSBridge(const std::string& plcAddress, 
+                    const std::string& natsUrl,
+                    const std::string& natsSubject,
+                    bool useBinaryFormat = true);
+    
+    /**
+     * @brief Destructor - asegura que todo esté limpiamente cerrado
+     */
+    ~EIPtoNATSBridge();
+    
+    /**
+     * @brief Inicia el bridge: conecta a NATS, abre conexión EIP y arranca el thread
+     * @return true si todo se inició correctamente, false en caso de error
+     */
+    bool start();
+    
+    /**
+     * @brief Detiene el bridge: cierra conexión EIP, desconecta NATS y detiene el thread
+     */
+    void stop();
+    
+    /**
+     * @brief Verifica si el bridge está corriendo
+     * @return true si está activo, false si está detenido
+     */
+    bool isRunning() const;
+    
+    /**
+     * @brief Obtiene el número de mensajes publicados
+     * @return Contador de mensajes enviados a NATS
+     */
+    uint64_t getPublishedCount() const;
+    
+    /**
+     * @brief Obtiene el número de mensajes recibidos del PLC
+     * @return Contador de mensajes recibidos por EIP
+     */
+    uint64_t getReceivedCount() const;
+
+private:
+    // Configuración
+    std::string plcAddress_;
+    std::string natsUrl_;
+    std::string natsSubject_;
+    bool useBinaryFormat_;
+    
+    // NATS
+    natsConnection* natsConn_;
+    natsOptions* natsOpts_;
+    std::mutex natsMutex_;
+    
+    // EIP Scanner
+    std::shared_ptr<eipScanner::SessionInfo> sessionInfo_;
+    std::unique_ptr<eipScanner::ConnectionManager> connectionManager_;
+    std::weak_ptr<eipScanner::IOConnection> ioConnection_;
+    
+    // Thread control
+    std::thread workerThread_;
+    std::atomic<bool> running_;
+    std::atomic<bool> shouldStop_;
+    
+    // Estadísticas
+    std::atomic<uint64_t> publishedCount_;
+    std::atomic<uint64_t> receivedCount_;
+    
+    /**
+     * @brief Función principal del thread worker
+     */
+    void workerLoop();
+    
+    /**
+     * @brief Inicializa la conexión NATS
+     * @return true si se conectó correctamente
+     */
+    bool initNATS();
+    
+    /**
+     * @brief Inicializa la conexión EIP
+     * @return true si se conectó correctamente
+     */
+    bool initEIP();
+    
+    /**
+     * @brief Cierra la conexión NATS
+     */
+    void closeNATS();
+    
+    /**
+     * @brief Cierra la conexión EIP
+     */
+    void closeEIP();
+    
+    /**
+     * @brief Publica datos a NATS
+     * @param data Vector de bytes a publicar
+     * @return true si se publicó correctamente
+     */
+    bool publishToNATS(const std::vector<uint8_t>& data);
+    
+    /**
+     * @brief Callback para datos recibidos del PLC
+     */
+    void onEIPDataReceived(uint32_t realTimeHeader, 
+                          uint16_t sequence, 
+                          const std::vector<uint8_t>& data);
+};
+
+} // namespace bridge
+
+#endif // EIP_TO_NATS_BRIDGE_H

eip2nats-1.0.0/eip2nats/__init__.py

@@ -0,0 +1,42 @@
+"""
+eip2nats - EtherNet/IP to NATS Bridge
+
+Puente entre dispositivos EtherNet/IP (PLCs) y servidores NATS con
+todas las dependencias incluidas.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Agregar el directorio lib al path de búsqueda de librerías
+_lib_dir = Path(__file__).parent / "lib"
+if _lib_dir.exists():
+    # Agregar al LD_LIBRARY_PATH en tiempo de ejecución
+    if sys.platform.startswith('linux'):
+        os.environ['LD_LIBRARY_PATH'] = f"{_lib_dir}:{os.environ.get('LD_LIBRARY_PATH', '')}"
+
+# Importar el módulo C++ - está directamente en este directorio
+try:
+    # Buscar el archivo .so en el directorio actual
+    import importlib.util
+    _module_dir = Path(__file__).parent
+    
+    # Buscar el módulo compilado (eip_nats_bridge*.so)
+    for so_file in _module_dir.glob("eip_nats_bridge*.so"):
+        if so_file.is_file():
+            # El nombre debe coincidir con PYBIND11_MODULE(eip_nats_bridge, m)
+            spec = importlib.util.spec_from_file_location("eip_nats_bridge", so_file)
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                EIPtoNATSBridge = module.EIPtoNATSBridge
+                break
+    else:
+        raise ImportError("No se encontró el módulo eip_nats_bridge compilado (.so)")
+        
+except ImportError as e:
+    raise ImportError(f"Error cargando el módulo eip2nats: {e}")
+
+__version__ = "1.0.0"
+__all__ = ["EIPtoNATSBridge"]

eip2nats-1.0.0/eip2nats/bindings.cpp

@@ -0,0 +1,66 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "EIPtoNATSBridge.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(eip_nats_bridge, m) {
+    m.doc() = "EIP to NATS Bridge - Puente entre EtherNet/IP y NATS";
+
+    py::class_<bridge::EIPtoNATSBridge>(m, "EIPtoNATSBridge")
+        .def(py::init<const std::string&, const std::string&, const std::string&>(),
+             py::arg("plc_address"),
+             py::arg("nats_url"),
+             py::arg("nats_subject"),
+             "Constructor del bridge\n\n"
+             "Args:\n"
+             "    plc_address (str): Dirección IP del PLC (ej: '192.168.17.200')\n"
+             "    nats_url (str): URL del servidor NATS (ej: 'nats://192.168.17.138:4222')\n"
+             "    nats_subject (str): Subject/topic NATS (ej: 'plc.data')")
+        
+        .def(py::init<const std::string&, const std::string&, const std::string&, bool>(),
+             py::arg("plc_address"),
+             py::arg("nats_url"),
+             py::arg("nats_subject"),
+             py::arg("use_binary_format"),
+             "Constructor del bridge con formato personalizado\n\n"
+             "Args:\n"
+             "    plc_address (str): Dirección IP del PLC\n"
+             "    nats_url (str): URL del servidor NATS\n"
+             "    nats_subject (str): Subject/topic NATS\n"
+             "    use_binary_format (bool): True para binario, False para JSON")
+        
+        .def("start", &bridge::EIPtoNATSBridge::start,
+             "Inicia el bridge: conecta a NATS, abre conexión EIP y arranca el thread\n\n"
+             "Returns:\n"
+             "    bool: True si se inició correctamente, False en caso de error")
+        
+        .def("stop", &bridge::EIPtoNATSBridge::stop,
+             "Detiene el bridge: cierra conexión EIP, desconecta NATS y detiene el thread")
+        
+        .def("is_running", &bridge::EIPtoNATSBridge::isRunning,
+             "Verifica si el bridge está corriendo\n\n"
+             "Returns:\n"
+             "    bool: True si está activo, False si está detenido")
+        
+        .def("get_published_count", &bridge::EIPtoNATSBridge::getPublishedCount,
+             "Obtiene el número de mensajes publicados a NATS\n\n"
+             "Returns:\n"
+             "    int: Contador de mensajes enviados")
+        
+        .def("get_received_count", &bridge::EIPtoNATSBridge::getReceivedCount,
+             "Obtiene el número de mensajes recibidos del PLC\n\n"
+             "Returns:\n"
+             "    int: Contador de mensajes recibidos")
+        
+        .def("__repr__", [](const bridge::EIPtoNATSBridge &bridge) {
+            return "<EIPtoNATSBridge running=" + 
+                   std::string(bridge.isRunning() ? "True" : "False") + 
+                   " received=" + std::to_string(bridge.getReceivedCount()) +
+                   " published=" + std::to_string(bridge.getPublishedCount()) + ">";
+        });
+
+    // Información del módulo
+    m.attr("__version__") = "1.0.0";
+    m.attr("__author__") = "Your Name";
+}

eip2nats-1.0.0/pyproject.toml

@@ -0,0 +1,95 @@
+[build-system]
+requires = ["hatchling", "pybind11>=2.6.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "eip2nats"
+version = "1.0.0"
+description = "EtherNet/IP to NATS Bridge with bundled dependencies"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"},
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: C++",
+    "Topic :: Software Development :: Libraries",
+]
+
+dependencies = [
+    "pybind11>=2.6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "black>=22.0",
+    "ruff>=0.0.243",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/eip2nats"
+Documentation = "https://github.com/yourusername/eip2nats/blob/main/README.md"
+Repository = "https://github.com/yourusername/eip2nats"
+
+[tool.hatch.build]
+packages = ["src/eip2nats"]
+# Excluir archivos fuente C++, solo incluir Python y .so
+exclude = [
+    "src/eip2nats/*.cpp",
+    "src/eip2nats/*.h",
+    "src/eip2nats/*.hpp",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/eip2nats"]
+# Incluir el módulo Python compilado y las librerías auxiliares
+artifacts = [
+    "src/eip2nats/eip_nats_bridge*.so",
+    "src/eip2nats/lib/*.so*",
+]
+# Excluir archivos fuente del wheel
+exclude = [
+    "src/eip2nats/*.cpp",
+    "src/eip2nats/*.h",
+    "src/eip2nats/*.hpp",
+]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "/.git",
+    "/build",
+    "/dist",
+    "/venv",
+    "*.pyc",
+    "__pycache__",
+]
+
+[tool.hatch.envs.default]
+dependencies = [
+    "pytest",
+    "pytest-cov",
+]
+
+[tool.hatch.envs.default.scripts]
+build-deps = "python scripts/build_dependencies.py"
+test = "pytest {args:tests}"
+cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=src/eip2nats {args:tests}"
+
+[tool.black]
+line-length = 100
+target-version = ['py37']
+
+[tool.ruff]
+line-length = 100
+select = ["E", "F", "W", "I", "N"]