pydaasiot 0.2.0__tar.gz

pydaasiot-0.2.0/.github/workflows/build-pypi.yml

@@ -0,0 +1,100 @@
+name: build-and-publish-pypi
+
+on:
+  push:
+    tags: ["v*.*.*"]    # Esempio: v0.2.0
+  workflow_dispatch:     # Avvio manuale dalla tab Actions
+
+jobs:
+  build-wheels:
+    name: Build wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, windows-2022]
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+
+      - name: Show SDK files (pre-build check)
+        shell: bash
+        run: |
+          echo "== include =="
+          ls -l include || true
+          echo "== lib/windows-msvc-x64 =="
+          ls -l lib/windows-msvc-x64 || true
+          echo "== lib/linux-gcc-x86_64 =="
+          ls -l lib/linux-gcc-x86_64 || true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - run: python -m pip install --upgrade pip cibuildwheel==2.*
+
+      - name: Build wheels
+        env:
+          CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-* cp313-*"
+          CIBW_SKIP: "*-win32 *-manylinux_i686 pp* *-musllinux_*"
+          CIBW_ARCHS_WINDOWS: "AMD64"
+          CIBW_ARCHS_LINUX: "x86_64"
+          CIBW_MANYLINUX_X86_64_IMAGE: "manylinux2014"
+          CIBW_BUILD_VERBOSITY: "3"
+          CIBW_ENVIRONMENT_WINDOWS: 'CMAKE_ARGS="-DDAAS_WIN_ROOT=lib/windows-msvc-x64 -DCMAKE_VERBOSE_MAKEFILE=ON" SKBUILD_VERBOSE=1'
+          CIBW_ENVIRONMENT_LINUX:  'CMAKE_ARGS="-DDAAS_LINUX_ROOT=lib/linux-gcc-x86_64 -DCMAKE_VERBOSE_MAKEFILE=ON" SKBUILD_VERBOSE=1'
+        run: cibuildwheel --output-dir wheelhouse
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - run: python -m pip install --upgrade pip build
+
+      - name: Build sdist
+        run: python -m build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish-pypi:
+    needs: [build-wheels, sdist]
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-ubuntu-22.04
+          path: dist
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-windows-2022
+          path: dist
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: sdist
+          path: dist
+
+      - name: Upload to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          python -m pip install --upgrade pip twine
+          twine upload dist/*

pydaasiot-0.2.0/.github/workflows/build-testpypi.yml

@@ -0,0 +1,100 @@
+name: build-and-publish-testpypi
+
+on:
+  push:
+    tags: ["pre*"]      # Esempio: pre0.2.0
+  workflow_dispatch:     # Avvio manuale dalla tab Actions
+
+jobs:
+  build-wheels:
+    name: Build wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, windows-2022]
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true  # ok anche se non usi LFS
+
+      - name: Show SDK files (pre-build check)
+        shell: bash
+        run: |
+          echo "== include =="
+          ls -l include || true
+          echo "== lib/windows-msvc-x64 =="
+          ls -l lib/windows-msvc-x64 || true
+          echo "== lib/linux-gcc-x86_64 =="
+          ls -l lib/linux-gcc-x86_64 || true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - run: python -m pip install --upgrade pip cibuildwheel==2.*
+
+      - name: Build wheels
+        env:
+          CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-* cp313-*"
+          CIBW_SKIP: "*-win32 *-manylinux_i686 pp* *-musllinux_*"
+          CIBW_ARCHS_WINDOWS: "AMD64"
+          CIBW_ARCHS_LINUX: "x86_64"
+          CIBW_MANYLINUX_X86_64_IMAGE: "manylinux2014"
+          CIBW_BUILD_VERBOSITY: "3"
+          CIBW_ENVIRONMENT_WINDOWS: 'CMAKE_ARGS="-DDAAS_WIN_ROOT=lib/windows-msvc-x64 -DCMAKE_VERBOSE_MAKEFILE=ON" SKBUILD_VERBOSE=1'
+          CIBW_ENVIRONMENT_LINUX:  'CMAKE_ARGS="-DDAAS_LINUX_ROOT=lib/linux-gcc-x86_64 -DCMAKE_VERBOSE_MAKEFILE=ON" SKBUILD_VERBOSE=1'
+        run: cibuildwheel --output-dir wheelhouse
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - run: python -m pip install --upgrade pip build
+
+      - name: Build sdist
+        run: python -m build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish-testpypi:
+    needs: [build-wheels, sdist]
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-ubuntu-22.04
+          path: dist
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-windows-2022
+          path: dist
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: sdist
+          path: dist
+
+      - name: Upload to TestPyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.TEST_PYPI_API_TOKEN }}
+        run: |
+          python -m pip install --upgrade pip twine
+          twine upload --repository-url https://test.pypi.org/legacy/ dist/*

pydaasiot-0.2.0/CMakeLists.txt

@@ -0,0 +1,72 @@
+cmake_minimum_required(VERSION 3.20)
+project(pydaasiot_native LANGUAGES CXX)
+
+# Python & pybind11
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+find_package(pybind11 CONFIG REQUIRED)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Allinea la CRT alla runtime di Python su MSVC
+if (MSVC)
+  set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+endif()
+
+# Percorsi include (globali o per-target; manteniamo semplici i globali)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third-parties)
+
+# Percorsi librerie (override da riga di comando se vuoi)
+set(DAAS_WIN_ROOT   "${CMAKE_CURRENT_SOURCE_DIR}/lib/windows-msvc-x64" CACHE PATH "Path to Windows .lib")
+set(DAAS_LINUX_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/lib/linux-gcc-x86_64" CACHE PATH "Path to Linux .a/.so")
+
+# Normalizza eventuali backslash in input (Windows) -> sempre forward-slash
+file(TO_CMAKE_PATH "${DAAS_WIN_ROOT}"   DAAS_WIN_ROOT)
+file(TO_CMAKE_PATH "${DAAS_LINUX_ROOT}" DAAS_LINUX_ROOT)
+
+# Sorgenti C++ del binding
+set(SRC_CPP
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp/pydaasiot.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp/daaswrapper.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/src/cpp/net_utils.cpp
+)
+
+# Modulo Python nativo: verrà installato come pydaasiot/_core.* (pyd/so)
+pybind11_add_module(_core MODULE ${SRC_CPP})
+
+# Su libreria statica, abilita PIC (utile su Linux)
+set_target_properties(_core PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+# Link a lib daas
+if (WIN32)
+  target_link_libraries(_core PRIVATE
+    $<$<CONFIG:Release>:${DAAS_WIN_ROOT}/daas.lib>
+    $<$<CONFIG:Debug>:${DAAS_WIN_ROOT}/daas_Debug.lib>
+    ws2_32
+  )
+elseif(UNIX)
+  # Preferisci statica se presente
+  if (EXISTS "${DAAS_LINUX_ROOT}/libdaas.a")
+    target_link_libraries(_core PRIVATE ${DAAS_LINUX_ROOT}/libdaas.a)
+  elseif (EXISTS "${DAAS_LINUX_ROOT}/libdaas.so")
+    target_link_libraries(_core PRIVATE ${DAAS_LINUX_ROOT}/libdaas.so)
+  else()
+    message(FATAL_ERROR "libdaas non trovata in ${DAAS_LINUX_ROOT}")
+  endif()
+
+  # BlueZ opzionale (se disponibile)
+  find_library(BLUEZ_LIB bluetooth)
+  if (BLUEZ_LIB)
+    target_link_libraries(_core PRIVATE ${BLUEZ_LIB})
+  endif()
+
+  # RPATH per caricare .so accanto al modulo
+  set_target_properties(_core PROPERTIES
+    INSTALL_RPATH "\$ORIGIN"
+    BUILD_WITH_INSTALL_RPATH ON
+  )
+endif()
+
+# Installa il modulo dentro il package Python
+install(TARGETS _core DESTINATION pydaasiot)

pydaasiot-0.2.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md LICENSE
+recursive-include include *.hpp *.h *.hh *.hxx
+recursive-include third-parties *.hpp *.h *.txt *.md
+prune docs
+prune docs/html
+exclude examples/*
+prune examples

pydaasiot-0.2.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.2
+Name: pydaasiot
+Version: 0.2.0
+Summary: Python bindings for DaaS-IoT (Windows + Linux manylinux).
+Author-Email: Tuo Nome <you@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: C++
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: License :: OSI Approved :: MIT License
+Project-URL: Homepage, https://github.com/tuo-org/pydaasiot
+Project-URL: Issues, https://github.com/tuo-org/pydaasiot/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# pydaasiot
+
+[![PyPI version](https://img.shields.io/pypi/v/pydaasiot.svg)](https://pypi.org/project/pydaasiot/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pydaasiot.svg)](https://pypi.org/project/pydaasiot/)
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux-blue.svg)](#-supported-platforms)
+[![License](https://img.shields.io/pypi/l/pydaasiot.svg)](LICENSE)
+
+**pydaasiot** are the official Python bindings for the **DaaS‑IoT SDK**.  
+They expose the full power of the Device‑as‑a‑Service paradigm directly into Python, making it easy to integrate IoT communication primitives, overlay networking and time synchronization into Python applications.
+
+---
+
+## 🌐 Overview
+
+The **DaaS‑IoT SDK** is a high‑performance library designed for distributed IoT environments.  
+It provides an overlay communication model on top of TCP/IP, with support for multiple drivers and precise ATS (Accurate Time Synchronization) mechanisms.
+
+The Python package `pydaasiot` allows developers and researchers to access these capabilities without writing C++ code, simplifying prototyping and integration into data pipelines, experiments and services.
+
+---
+
+## ✨ Main Features
+
+- Initialization and management of **DaaS‑IoT nodes**.
+- Add and configure network drivers (currently **INET4** and **Bluetooth**; more drivers such as Serial, USB, UART, MQTT are planned).  
+- Send and receive packets between devices.  
+- Retrieve and manage ATS synchronization parameters.  
+- Cross‑platform: distributed as prebuilt wheels for **Windows (MSVC)** and **Linux (manylinux2014)**.  
+
+---
+
+## 🚀 Installation
+
+Install from PyPI with:
+
+```bash
+pip install pydaasiot
+```
+
+Wheels are available for Python 3.9 – 3.12.  
+`pip` will automatically choose the correct wheel for your OS and Python version.
+
+---
+
+## 🧪 Quick Example
+
+```python
+import pydaasiot
+
+# Initialize a DaaS-IoT node
+node = pydaasiot.Node()
+node.init()
+
+# Add a network driver (example: IPv4 link)
+node.add_driver(2, "127.0.0.1:5000")
+
+# Send a packet
+node.push(b"Hello from Python")
+
+# Receive packets (non-blocking)
+packets = node.pull()
+print("Received:", packets)
+
+# Access ATS parameters
+ats = node.get_sync_params()
+print("ATS:", ats)
+```
+
+---
+
+## 🖥️ Supported Platforms
+
+- **Windows** (x86_64, MSVC)
+- **Linux** (x86_64, manylinux2014)
+
+macOS support is planned for a future release.
+
+---
+
+## 📚 Documentation
+
+- Full SDK documentation: [GitHub repository](https://github.com/your-org/pydaasiot)  
+- Examples: available in the repository under `examples/` (not included in the PyPI package).  
+
+---
+
+## 🔧 Development
+
+Development is organized into feature branches for specific platforms.  
+The `main` branch is cross‑platform and serves as the source for official PyPI releases.  
+Tagged versions (`vX.Y.Z`) trigger CI pipelines that build wheels for Windows and Linux and publish them to PyPI.
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please use GitHub issues and pull requests to propose improvements or report bugs.
+
+---
+
+## 📄 License
+
+Released under the terms of the **MIT License**.  
+See the [LICENSE](LICENSE) file for details.

pydaasiot-0.2.0/README.md

@@ -0,0 +1,104 @@
+# pydaasiot
+
+[![PyPI version](https://img.shields.io/pypi/v/pydaasiot.svg)](https://pypi.org/project/pydaasiot/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pydaasiot.svg)](https://pypi.org/project/pydaasiot/)
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux-blue.svg)](#-supported-platforms)
+[![License](https://img.shields.io/pypi/l/pydaasiot.svg)](LICENSE)
+
+**pydaasiot** are the official Python bindings for the **DaaS‑IoT SDK**.  
+They expose the full power of the Device‑as‑a‑Service paradigm directly into Python, making it easy to integrate IoT communication primitives, overlay networking and time synchronization into Python applications.
+
+---
+
+## 🌐 Overview
+
+The **DaaS‑IoT SDK** is a high‑performance library designed for distributed IoT environments.  
+It provides an overlay communication model on top of TCP/IP, with support for multiple drivers and precise ATS (Accurate Time Synchronization) mechanisms.
+
+The Python package `pydaasiot` allows developers and researchers to access these capabilities without writing C++ code, simplifying prototyping and integration into data pipelines, experiments and services.
+
+---
+
+## ✨ Main Features
+
+- Initialization and management of **DaaS‑IoT nodes**.
+- Add and configure network drivers (currently **INET4** and **Bluetooth**; more drivers such as Serial, USB, UART, MQTT are planned).  
+- Send and receive packets between devices.  
+- Retrieve and manage ATS synchronization parameters.  
+- Cross‑platform: distributed as prebuilt wheels for **Windows (MSVC)** and **Linux (manylinux2014)**.  
+
+---
+
+## 🚀 Installation
+
+Install from PyPI with:
+
+```bash
+pip install pydaasiot
+```
+
+Wheels are available for Python 3.9 – 3.12.  
+`pip` will automatically choose the correct wheel for your OS and Python version.
+
+---
+
+## 🧪 Quick Example
+
+```python
+import pydaasiot
+
+# Initialize a DaaS-IoT node
+node = pydaasiot.Node()
+node.init()
+
+# Add a network driver (example: IPv4 link)
+node.add_driver(2, "127.0.0.1:5000")
+
+# Send a packet
+node.push(b"Hello from Python")
+
+# Receive packets (non-blocking)
+packets = node.pull()
+print("Received:", packets)
+
+# Access ATS parameters
+ats = node.get_sync_params()
+print("ATS:", ats)
+```
+
+---
+
+## 🖥️ Supported Platforms
+
+- **Windows** (x86_64, MSVC)
+- **Linux** (x86_64, manylinux2014)
+
+macOS support is planned for a future release.
+
+---
+
+## 📚 Documentation
+
+- Full SDK documentation: [GitHub repository](https://github.com/your-org/pydaasiot)  
+- Examples: available in the repository under `examples/` (not included in the PyPI package).  
+
+---
+
+## 🔧 Development
+
+Development is organized into feature branches for specific platforms.  
+The `main` branch is cross‑platform and serves as the source for official PyPI releases.  
+Tagged versions (`vX.Y.Z`) trigger CI pipelines that build wheels for Windows and Linux and publish them to PyPI.
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please use GitHub issues and pull requests to propose improvements or report bugs.
+
+---
+
+## 📄 License
+
+Released under the terms of the **MIT License**.  
+See the [LICENSE](LICENSE) file for details.

pydaasiot-0.2.0/examples/DaaSChat.py

@@ -0,0 +1,179 @@
+import pydaasiot
+from pydaasiot import DDO, IDaasApiEvent, DaasWrapper
+
+class HandlerBidirezionale(IDaasApiEvent):
+    
+    def __init__(self, nodo):
+        super().__init__()
+        self.nodo = nodo
+
+    def ddoReceivedEvent(self, dimensione_payload, typeset, din_sorgente):
+        print(f"Messaggio ricevuto da: {din_sorgente}, dimensione: {dimensione_payload}, typeset: {typeset}")
+
+        result, ddo = self.nodo.wrapper.pull(din_sorgente)
+        print(f"DEBUG pull() -> result = {result} , ddo = {ddo}")
+
+        if result == pydaasiot.daas_error_t.ERROR_NONE and ddo is not None:
+            
+            payload = ddo.getPayloadAsBinary()
+
+            try:
+                msg = payload.decode('utf-8')
+                print(f"Messaggio: {msg}")
+            except Exception:
+                print(f"Messaggio: {payload}")
+        else:
+            print(f"Pull non riuscito con errore {result}")
+            
+    def dinAcceptedEvent(self, din): 
+        print(f"DIN {din} accettato")
+        
+
+    def nodeStateReceivedEvent(self, din): pass
+    def frisbeeReceivedEvent(self, din): pass
+    def atsSyncCompleted(self, din): pass
+    def frisbeeDperfCompleted(self, din, p, s): pass
+
+
+class NodoBidirezionale:
+    def __init__(self, sid, din, ip_locale, porta_locale, din_remoto, ip_remoto,
+                 porta_remota):
+        
+        self.sid = sid
+        self.din = din
+        self.ip_locale = ip_locale
+        self.porta_locale = porta_locale
+        self.din_remoto = din_remoto
+        self.ip_remoto = ip_remoto
+        self.porta_remota = porta_remota
+        
+        self.handler = HandlerBidirezionale(self)
+        self.wrapper = DaasWrapper("",self.handler)
+        self.handler.nodo = self   
+        self.running = False
+
+    def chat_interattiva(self):
+        """Interfaccia chat interattiva"""
+        print("CHAT ATTIVA - Scrivi un messaggio per il nodo remoto")
+        print("    Scrivi: '!quit' per interrompere")
+        print("    Scrivi: '!status' per lo stato")
+
+        while self.running:
+            try:
+                messaggio = input("> ")
+
+                if not messaggio:
+                    continue 
+
+                if messaggio.lower() == '!quit':
+                    break
+
+                if messaggio.lower() == '!status':
+                    print(f"Nodo ativo - DIN: {self.din}")
+                    continue
+
+                self.invia_messaggio(messaggio)
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+               print(f"Errore Input: {e}")
+
+    def inizializza_mio_nodo(self):
+        """Inizializzo nodo"""
+        print("Inizializzo nodo locale")
+
+        nodo = self.wrapper.doInit(self.sid, self.din)
+        if nodo != pydaasiot.daas_error_t.ERROR_NONE:
+            print("Errore inizializzazione")
+            return False
+        print("Nodo inizializzato")
+        return True 
+        
+    def configura_miei_driver(self):
+        print("Configuro Driver nodo locale")
+        uri_locale = f"{self.ip_locale}:{self.porta_locale}"
+        driver = self.wrapper.enableDriver(pydaasiot.link_t._LINK_INET4, uri_locale)
+        if driver != pydaasiot.daas_error_t.ERROR_NONE:
+            print("Errore Driver!")
+            return False
+        print("Driver configurati")
+        return True
+        
+    def mappa_nodo_remoto(self):
+        uri_remoto = f"{self.ip_remoto}:{self.porta_remota}"
+        nodo_remoto = self.wrapper.map(self.din_remoto, pydaasiot.link_t._LINK_INET4,
+                                       uri_remoto)
+        
+        if nodo_remoto != pydaasiot.daas_error_t.ERROR_NONE:
+            print("Errore mappatura nodo remoto")
+            return False
+        print("Mappatura nodo remoto completata")
+        return True
+
+    def invia_messaggio(self, messaggio):
+        ddo = DDO()
+        ddo.setOrigin(self.din)
+        ddo.setTypeset(1)
+        ddo.allocatePayload(len(messaggio))
+        ddo.appendPayloadData(messaggio.encode('utf-8'))
+        
+
+        invio = self.wrapper.push(self.din_remoto, ddo)
+        if invio == 0:
+            print(f"Messaggio inviato a: {self.din_remoto}")
+            return True
+        else:
+            print("Invio messaggio non riuscito")
+            return False
+        
+    def start(self):
+        self.running = True
+        avvio = self.wrapper.doPerform(pydaasiot.performs_mode_t.PERFORM_CORE_THREAD)
+        if avvio != pydaasiot.daas_error_t.ERROR_NONE:
+            print("Avvio non riuscito")
+            return False
+        print("Esecuzione nodo avviata")
+        return True
+    
+    def stop(self):
+        self.running = False
+        self.wrapper.doEnd()
+        print("Esecuzione nodo arrestata")
+
+    
+def main():
+    SID = 100
+    MIO_DIN = int(input("Inserisci il tuo DIN: ").strip())
+    MIO_IP = input("Inserisci il tuo IP: ").strip() 
+    MIA_PORTA = int(input("Inserisci la tua porta").strip())
+
+    DIN_REMOTO = int(input("Inserisci il DIN remoto").strip())
+    IP_REMOTO = input("Inserisci IP remoto").strip()
+    PORTA_REMOTA = int(input("Inserisci la porta remota").strip())
+
+    nodo = NodoBidirezionale(sid=SID, din=MIO_DIN, ip_locale=MIO_IP, 
+                                porta_locale=MIA_PORTA, din_remoto=DIN_REMOTO,
+                                ip_remoto=IP_REMOTO,
+                                porta_remota=PORTA_REMOTA)
+        
+    if not nodo.inizializza_mio_nodo():
+        return
+        
+    if not nodo.configura_miei_driver():
+        return
+        
+    if not nodo.mappa_nodo_remoto():
+        return 
+        
+    if not nodo.start():
+        return
+        
+    try:
+        nodo.chat_interattiva()
+    except KeyboardInterrupt:
+        print("Interruzione da tastiera...")
+    finally:
+            nodo.stop()
+
+if __name__ == "__main__":
+    main()