Introduzione agli script di automazione NX personalizzati

Siemens NX è una potente piattaforma CAD/CAM/CAE che va oltre la modellazione manuale esponendo un ricco insieme di API per l'automazione. Scrivere script personalizzati in Python o C# consente agli ingegneri e agli sviluppatori di eliminare il lavoro manuale ripetitivo, rispettare gli standard di progettazione e integrare NX in più grandi linee di ingegneria.

Questo articolo fornisce una guida estesa e pratica per lo sviluppo di script di automazione NX personalizzati utilizzando sia Python che C#. Imparerai le differenze tra le due lingue, come impostare il tuo ambiente di sviluppo, scrivere script pronti alla produzione e applicare le migliori pratiche per evitare insidie comuni. L'obiettivo è quello di darvi una solida base per la costruzione di una solida automazione che funziona senza soluzione di continuità con il flusso di lavoro NX.

Comprendere l'ecosistema di automazione NX

L'automazione NX è costruita sul NX Open API[], una libreria completa che espone quasi tutte le funzionalità disponibili nell'interfaccia utente NX. L'API è disponibile in più interfacce di programmazione:

  • NX Open for Python[] – Fornisce binding Python per l'API NX Open. Ideale per scripting rapido, prototipazione e integrazione con le librerie di data science.
  • NX Open for .NET[ – Assemblaggi .NET completamente realizzati (C#, VB.NET) che consentono di accedere all'intero modello di oggetto NX.
  • NX Open C++[] – Per gli sviluppatori che hanno bisogno di accesso diretto alla memoria o di link con codice C++ legacy.
  • Journaling[[] – NX può registrare le tue azioni manuali come file di giornale (VB o C#). Queste riviste sono un ottimo punto di partenza per imparare la sintassi API.

Tutte le API condividono un modello simile di oggetto, ma esistono sfumature specifiche per la lingua. La chiave è capire che l'automazione NX è orientata agli eventi; in genere si crea un oggetto , quindi utilizzare il suo , , e varie classi di costruttori per interagire con il modello.

Scegliere tra Python e C#

La decisione tra Python e C# per l’automazione NX dipende dai requisiti del progetto, dalle competenze del team e dall’ambiente di distribuzione.

Python per NX Automation

  • Ease of Use:[ La sintassi pulita di Python lo rende il modo più veloce per scrivere script di automazione.
  • Rapid Prototyping:[] È possibile testare gli script in modo interattivo utilizzando una console Python incorporata all'interno di NX (dal NX 12).
  • Integrazione dei dati:[ Il vasto ecosistema di Python (NumPy, Pandas, Matplotlib) permette di combinare l'automazione NX con l'analisi dei dati e la visualizzazione.
  • Performance:[] Python è interpretato; per le assemblee molto grandi o i loop stretti, può essere più lento di C#. Tuttavia, per la maggior parte delle attività di scripting, la testa è trascurabile.
  • Deployment:[] Gli script Python sono file di testo semplici. Possono essere eseguiti all'interno di NX tramite il [File → Execute → NX Open[] menu o utilizzando il comando ] nella riga di comando NX.

C# per l'automazione NX

  • Accesso completo a .NET:[] C# ti dà l'intero framework .NET, tra cui Windows Forms o WPF per finestre personalizzate UI dialoghi, filetti di sfondo e debugging avanzato in Visual Studio.
  • Tipo di forza:[[ C# cattura molti errori nel tempo di compilazione, rendendo più facile mantenere grandi codebases.
  • Integrazione con altri strumenti Siemens:[ Molti prodotti PLM Siemens (come Teamcenter) forniscono API native .NET che si abbinano bene all'automazione C#.
  • Performance:[] Il codice compilato corre più velocemente di Python interpretato, specialmente per le operazioni che iterano su migliaia di volti o bordi.
  • Deployment:[[] Gli script C# devono essere compilati in DLL o eseguibili. Possono essere caricati come componenti aggiuntivi NX via File → Utilities → Strumenti utente]] o mettendo la DLL nella cartella di avvio.

In pratica, molte squadre usano entrambe: Python per compiti ad-hoc e proof-of-concepts, e C# per strumenti mission-critical che hanno bisogno di un'interfaccia lucida e alte prestazioni.

Impostazione di Python per NX Automation

Prerequisiti

  • Siemens NX (versione 12 o successiva è raccomandato; Python supporto è stato potenziato nella serie NX 1926).
  • Python 3.x installato sulla stessa macchina (NX non spedisce il proprio Python; è necessario installare una versione compatibile).
  • Il pacchetto è spesso incluso con l'installazione NX ma può richiedere l'impostazione delle variabili ambientali.

Configurazione dell'ambiente

Prima di scrivere il tuo primo script, assicurati che NX trovi il tuo interprete Python. In Windows, aggiungi la cartella di installazione Python alla variabile di ambiente [. Quindi, all'interno di NX, controlla che File → Execute → NX Open → Python] funziona senza errori. Se ottieni un messaggio "Impossibile caricare Python", verifica che la directory

Il tuo primo script Python

Avviare NX, creare un nuovo file di parti (ad esempio, [), quindi aprire l'editor NX Python (o utilizzare un IDE esterno come VS Code). Inserisci il seguente script e eseguirlo dall'interno NX via [File → Execute → NX Open → Sfoglia].

import NXOpen

def main():
 session = NXOpen.Session.GetSession()
 work_part = session.Parts.Work
 # Create a block
 body_feature = work_part.Features.CreateBlockBuilder(NXOpen.Features.BlockBuilder.Null)
 body_feature.BlockBuilder.SetOrigin(NXOpen.Point3d(0, 0, 0))
 body_feature.BlockBuilder.SetLengths(NXOpen.Point3d(100, 50, 30))
 nx_object = body_feature.Commit()
 body_feature.Destroy()
 print("Block created successfully!")

if __name__ == '__main__':
 main()

Quando eseguito, questo script crea un blocco 100×50×30 mm all'origine. Il modello è lo stesso per quasi tutte le creazioni geometriche: ottenere un costruttore, impostare parametri, commit e distruggere il costruttore.

Moduli Python chiave da sapere

  • – Lo spazio principale per tutti gli oggetti NX.
  • – Funzioni utente (API più vecchia, ancora utilizzata per alcune attività di basso livello).
  • – Aiutanti per le conversioni unità, matematica, ecc.

Impostazione C# per l'automazione NX

Prerequisiti

  • Siemens NX installato.
  • Visual Studio (ogni edizione che supporta .NET Framework 4.7.2 o versioni successive).
  • NX Open .NET assemblaggi. Sono in genere situati in (solo numero di versione).

Creazione di un progetto Visual Studio

  1. Creare un nuovo progetto C# Class Library (.NET Framework).
  2. Aggiungi riferimenti ai gruppi NX richiesti:
    • []
    • (opzionale, per le chiamate UF)
  3. Impostare il target della piattaforma a x64 (NX è solo a 64 bit).
  4. Costruire il progetto per creare una DLL.

Il tuo primo script C#

Questo esempio fa lo stesso di quello Python: creare un blocco.

using NXOpen;

public class CreateBlockExample
{
 public static void Main()
 {
 Session session = Session.GetSession();
 Part workPart = session.Parts.Work;

 Features.BlockBuilder blockBuilder = workPart.Features.CreateBlockBuilder(null);
 blockBuilder.SetOrigin(new Point3d(0, 0, 0));
 blockBuilder.SetLengths(new Point3d(100, 50, 30));
 NXObject block = blockBuilder.Commit();
 blockBuilder.Destroy();

 session.ListingWindow.WriteLine("Block created.");
 }
}

Per testare questa DLL, compilarla e poi all'interno di NX vai a []File → Eseguite → NX Open → Sfoglia[] e selezionare la DLL. NX eseguirà automaticamente il metodo se lo contrassegnate come punto di entrata (puoi anche usare il ] per lanciare un comando personalizzato).

Debug C# Scripts

Attacca Visual Studio al processo NX ([Debug → Attach to Process[] → select ]]). Impostare i punti di rottura nel codice C# e eseguire lo script dall'interno NX. Questo ti dà l'ispezione completa e il debugging passo-passo, un vantaggio sulle dichiarazioni più semplici di Python .

Modelli di automazione core

Indipendentemente dal linguaggio, ogni script di automazione NX segue un ciclo di vita simile:

  1. Get the current session[ – in entrambe le lingue.
  2. Get the working part[ – (o ] per la parte visibile).
  3. Crea un costruttore[] – Usa metodi come .
  4. Parametri di sicurezza[] – Utilizzare i metodi del costruttore (ad esempio , ]).
  5. Commettere il costruttore[] – Questo crea l'oggetto NX reale e lo restituisce.
  6. Distruggere il costruttore[[] – Rilascia la memoria.
  7. Aggiornare la parte[[] – Di solito avviene automaticamente, ma per alcune operazioni è necessario chiamare .

Per operazioni che coinvolgono la selezione (ad esempio, l'utente sceglie un volto), si utilizza la classe [. È possibile creare una finestra di dialogo di selezione all'interno dello script o lasciare che l'utente selezioni oggetti in anticipo utilizzando metodi di selezione interattivi.

Scrivere un pratico script: Batch Export Parts to STEP

Costruiremo un'utilità del mondo reale: esportare tutti i file open part in formato STEP. Questo è un requisito comune per la collaborazione con altri sistemi CAD.

Python Batch Esportazione

import NXOpen
import os

def export_part_to_step(part, output_folder):
 part_fsa = part.FullPath # full file path
 if not part_fsa:
 print(f"Part {part.Name} has no file path, skipping.")
 return
 step_filename = os.path.join(output_folder, part.Name.replace(".prt", ".stp"))
 # Create step export builder
 step_builder = part.StepExportBuilder()
 step_builder.FileName = step_filename
 step_builder.Commit()
 step_builder.Destroy()
 print(f"Exported {part.Name} to {step_filename}")

def main():
 session = NXOpen.Session.GetSession()
 parts = session.Parts
 output = r"C:\temp\step_exports"
 if not os.path.exists(output):
 os.makedirs(output)
 for part in parts:
 # Skip display part and work part duplicates
 if part == parts.Display or part == parts.Work:
 continue
 export_part_to_step(part, output)

if __name__ == '__main__':
 main()

Questo script itera attraverso tutte le parti caricate (escluso la parte di visualizzazione) e esporta ogni a STEP utilizzando il .

C# Esportazione di bacca

using NXOpen;
using System.IO;

public class BatchStepExport
{
 public static void Main()
 {
 Session session = Session.GetSession();
 PartCollection parts = session.Parts;
 string outputFolder = @"C:\temp\step_exports";
 Directory.CreateDirectory(outputFolder);

 foreach (Part part in parts)
 {
 if (part == parts.Display || part == parts.Work) continue;

 string partPath = part.FullPath;
 if (string.IsNullOrEmpty(partPath)) continue;

 string stepFile = Path.Combine(outputFolder,
 Path.GetFileNameWithoutExtension(partPath) + ".stp");

 StepExportBuilder builder = part.StepExportBuilder();
 builder.FileName = stepFile;
 builder.Commit();
 builder.Destroy();

 session.ListingWindow.WriteLine($"Exported {part.Name} -> {stepFile}");
 }
 }
}


Entrambi gli script presumono che si hanno le autorizzazioni di esportazione necessarie e che NX può scrivere alla cartella di uscita.



Migliori Pratiche per lo Sviluppo e la Distribuzione di script



Struttura del codice e Manutenzione


    
 
  • Modularizzazione:[]] Interrompere lo script in funzioni o classi. In C#, utilizzare file separati per diversi gruppi di funzionalità.
    • 
 
  • Consistent Naming:[] Seguire le convenzioni di denominazione API NX. Usa in C# e in Python per variabili locali.
    • 
 
  •  Controllo di domanda:[[]] Usa Git per monitorare i cambiamenti.
    • 




Gestione e registrazione degli errori


    
 
  • Wrap API chiama in tripudio (Python) o in blocchi di prova (C#). Controlla per errori NX specifici.
    • 
 
  • Per i log, scrivere a un file di testo usando (C#) o logging standard Python.
    • 
 
  • Distruggere sempre i costruttori in un blocco ] o usando dichiarazione (C#) per evitare perdite di memoria.
    • 




Considerazioni sulle prestazioni


    
 
  • Minimizza il numero di chiamate API all'interno di loop. Ad esempio, se è necessario accedere a una collezione di funzionalità di una parte molte volte, memorizzarlo in una variabile.
    • 
 
  • Per grandi assemblaggi, utilizzare bandiere per evitare componenti di carico completamente non è necessario.
    • 
 
  • Attivare gli aggiornamenti della schermata durante le operazioni batch. In C#, utilizzare e riattivare dopo.
    • 
 
  • In Python, è possibile utilizzare .
    • 




Testing


    
 
  • Test script in Impostata sessione NX] (avvia NX con una nuova parte vuota).
    • 
 
  • Crea parti di prova con geometria nota per convalidare le uscite.
    • 
 
  • Per le DLL C#, scrivere test di unità utilizzando un framework di mocking (come Moq) per simulare oggetti NX – anche se il test contro un'istanza NX reale è più affidabile.
    • 




Distribuzione


    
 
  • script Python: Distribuisci come file . Assicurare a tutti gli utenti di versioni Python e NX compatibili.
    • 
 
  • C# script: Fornire una DLL compilata insieme a un file manifesto ([[]) che registra l'add-in. In alternativa, posizionare la DLL nella cartella sotto NX installazione per caricare automaticamente.
    • 




Risoluzione dei problemi Problemi comuni



Versione API Mismatches


NX Open API è specifica per la versione. Uno script scritto per NX 1926 potrebbe non funzionare con NX 1980 senza modifiche. Controllare sempre il a runtime e regolare le chiamate di metodo di conseguenza.



Errori di importazione di Python


Se vedete , assicuratevi che [] sia nel vostro percorso Python. Il file è solitamente in ]. Aggiungete questo percorso alla vostra variabile di ambiente .



Costruttore non immesso


Se il tuo script non fa nulla, verifica che hai chiamato e non solo . Inoltre, controlla che i parametri del costruttore siano validi (ad esempio, le lunghezze negative causano eccezioni).



Permessi e accesso ai file


Gli script di esportazione batch spesso falliscono perché NX non ha accesso di scrittura alla cartella di output. Eseguire NX come amministratore o scegliere una cartella nel profilo utente.



Conclusioni


Sviluppando script di automazione personalizzati con Python e C# sblocca il pieno potenziale di Siemens NX, consentendo di ottimizzare le attività ripetitive, rispettare gli standard e integrare con i più grandi sistemi PLM. Python eccelle a processi rapidi di sviluppo e di dati, mentre C# offre prestazioni robuste e funzionalità avanzate dell'interfaccia utente.


Iniziare piccolo: diario di un'operazione manuale, convertirlo in uno script Python, quindi aggiungere gradualmente la complessità. Mentre si guadagna fiducia, esplorare le capacità più profonde dell'API—creazione di funzionalità personalizzate, automazione di simulazione, e anche collegare NX con database esterni.