Introduction aux scripts d'automatisation NX personnalisés

Siemens NX est une plate-forme puissante CAD/CAM/CAE qui va au-delà de la modélisation manuelle en exposant un riche ensemble d'API pour l'automatisation. L'écriture de scripts personnalisés en Python ou C# permet aux ingénieurs et aux développeurs d'éliminer le travail manuel répétitif, de faire appliquer les normes de conception et d'intégrer NX dans des pipelines d'ingénierie plus importants.

Cet article fournit un guide pratique et élargi pour développer des scripts d'automatisation NX personnalisés en utilisant Python et C#. Vous apprendrez les différences entre les deux langues, comment configurer votre environnement de développement, écrire des scripts prêts à la production et appliquer les meilleures pratiques pour éviter les pièges communs. L'objectif est de vous donner une base solide pour construire une automatisation robuste qui fonctionne parfaitement avec votre workflow NX.

Comprendre l'écosystème d'automatisation NX

L'automatisation NX est construite sur l'API ouverte NX, une bibliothèque complète qui expose presque toutes les fonctionnalités disponibles dans l'interface utilisateur NX. L'API est disponible dans plusieurs interfaces de programmation:

  • NX Open for Python – Fournit des liaisons Python pour l'API NX Open. Idéal pour le script rapide, le prototypage et l'intégration avec les bibliothèques de sciences des données.
  • NX Open for .NET[ – Assemblages .NET complets (C#, VB.NET) qui vous donnent accès à l'ensemble du modèle d'objet NX. Le meilleur pour les applications complexes et critiques en termes de performances avec des composants d'interface utilisateur.
  • NX Open C++[ – Pour les développeurs qui ont besoin d'un accès direct à la mémoire ou qui doivent se lier avec le code C++.
  • Journaling – NX peut enregistrer vos actions manuelles comme un fichier de journal (VB ou C#).Ces revues sont un excellent point de départ pour apprendre la syntaxe de l'API.

Toutes les API partagent un modèle d'objet similaire, mais il existe des nuances spécifiques à la langue. La clé est de comprendre que l'automatisation NX est axée sur les événements; vous créez généralement un objet , puis utilisez ses , et diverses classes de constructeurs pour interagir avec le modèle.

Choix entre Python et C#

La décision entre Python et C# pour l'automatisation NX dépend de vos besoins de projet, de votre expertise d'équipe et de votre environnement de déploiement.

Python pour l'automatisation NX

  • Sortie d'utilisation: La syntaxe propre de Python en fait la manière la plus rapide d'écrire des scripts d'automatisation. Il est idéal pour les ingénieurs qui ne sont pas des développeurs à temps plein.
  • Prototypage rapide:[ Vous pouvez tester les scripts de manière interactive en utilisant une console Python intégrée dans NX (depuis NX 12).
  • Intégration des données: Le vaste écosystème de Python (NumPy, Pandas, Matplotlib) vous permet de combiner l'automatisation NX avec l'analyse et la visualisation des données.
  • Performance: Python est interprété; pour les très grands ensembles ou les boucles serrées, il peut être plus lent que C#. Cependant, pour la plupart des tâches de script, le coût de revient est négligeable.
  • Déployment: Les scripts Python sont des fichiers texte simples. Ils peuvent être exécutés à l'intérieur de NX via le menu Fichier → Exécuter → NX Open[ ou en utilisant la commande dans la ligne de commande NX.

C# pour l'automatisation NX

  • Accès complet à .NET:[ C# vous donne le cadre complet de .NET, y compris les formulaires Windows ou WPF pour les dialogues d'interface utilisateur personnalisés, les threads de fond et le débogage avancé dans Visual Studio.
  • Typiquement typé:[ C# capture de nombreuses erreurs au moment de la compilation, ce qui facilite la maintenance de grandes bases de code.
  • Intégration avec d'autres outils Siemens:[ De nombreux produits Siemens PLM (comme Teamcenter) fournissent des API .NET natives qui s'apparient bien à l'automatisation C#.
  • Le code composé fonctionne plus rapidement que Python interprété, surtout pour les opérations qui itèrent sur des milliers de faces ou de bords.
  • Déployment: Les scripts C# doivent être compilés en DLLs ou exécutables. Ils peuvent être chargés en add-ons NX via File → Utilitaires → Outils utilisateur ou en plaçant la DLL dans le dossier de démarrage.

En pratique, de nombreuses équipes utilisent à la fois : Python pour les tâches ad hoc et les preuves de concepts, et C# pour les outils critiques de mission qui ont besoin d'une interface polie et de hautes performances.

Configuration du Python pour l'automatisation NX

Préalables

  • Siemens NX (version 12 ou ultérieure est recommandée ; le support Python a été amélioré dans la série NX 1926).
  • Python 3.x installé sur la même machine (NX n'envoie pas son propre Python ; vous devez installer une version compatible).
  • Le paquet est souvent inclus dans l'installation NX, mais peut nécessiter des variables d'environnement de réglage.

Configuration de l'environnement

Avant d'écrire votre premier script, assurez-vous que NX puisse trouver votre interprète Python. Dans Windows, ajoutez le dossier d'installation Python à la variable d'environnement . Ensuite, à l'intérieur de NX, vérifiez que Fichier → Exécuter → NX Ouvrir → Python fonctionne sans erreur. Si vous obtenez un -Incapacité de charger un message Python, vérifiez que la variable pointe vers votre répertoire racine Python.

Votre premier script Python

Lancez NX, créez un nouveau fichier de parties (par exemple ), puis ouvrez l'éditeur de Python NX (ou utilisez un IDE externe comme le code VS). Entrez le script suivant et lancez-le à partir de NX via Fichier → Exécuter → NX Ouvrir → Parcourir.

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

Une fois exécuté, ce script crée un bloc de 100×50×30 mm à l'origine. Le motif est le même pour presque toute création géométrique : obtenir un constructeur, définir des paramètres, commit, et détruire le constructeur.

Modules Python clés à connaître

  • – L'espace de noms principal pour tous les objets NX.
  • – Appels de fonction utilisateur (API plus ancienne, encore utilisée pour certaines tâches de bas niveau).
  • – Aides pour les conversions d'unité, les mathématiques, etc.

Configuration C# pour l'automatisation NX

Préalables

  • Siemens NX installé.
  • Visual Studio (toute édition prenant en charge .NET Framework 4.7.2 ou ultérieure).
  • NX Open .NET Assemblages. Ils sont généralement situés dans (numéro de version ajustable).

Création d'un projet Visual Studio

  1. Créer un nouveau projet de bibliothèque de classe C# (cadre.NET).
  2. Ajouter les références aux ensembles NX requis:
    • (facultatif, pour les appels UF)
  3. Réglez la cible de la plate-forme sur x64 (NX est 64 bits seulement).
  4. Construisez le projet pour créer une DLL.

Votre premier scénario C#

Cet exemple fait la même chose que Python : créez un bloc.

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

Pour tester cette DLL, compilez-la et puis à l'intérieur de NX aller à Fichier → Exécuter → NX Ouvrir → Parcourir et sélectionnez la DLL. NX exécutera automatiquement la méthode si vous la marquez comme point d'entrée (vous pouvez également utiliser la pour lancer une commande personnalisée).

Déboguer les Scripts C#

Joindre Visual Studio au processus NX (Debug → Joindre au processus → sélectionner ). Définissez les points d'arrêt dans votre code C# et exécutez le script à partir de l'intérieur de NX. Cela vous donne une inspection complète de la variable et le débogage pas à pas, un avantage sur les instructions Python=»s plus simples .

Modèles d'automatisation de base

Quel que soit le langage utilisé, chaque script d'automatisation NX suit un cycle de vie similaire :

  1. Obtenez la session en cours – dans les deux langues.
  2. Obtenez la partie de travail – (ou pour la partie visible).
  3. Créer un constructeur – Utiliser des méthodes comme .
  4. Set parameters – Utilisez les méthodes de construction (p. ex. , ).
  5. Commander le constructeur – Cela crée l'objet NX réel et le renvoie.
  6. Détruire le constructeur – Débloque la mémoire.
  7. Mise à jour de la partie – Habituellement, cela se produit automatiquement, mais pour certaines opérations, vous devez appeler .

Pour les opérations impliquant la sélection (p. ex., l'utilisateur choisit un visage), vous utilisez la classe . Vous pouvez créer une boîte de dialogue de sélection dans le script ou laisser l'utilisateur sélectionner des objets à l'avance en utilisant des méthodes de sélection interactives.

Écrire un scénario pratique : Exporter des pièces à STEP

Let , construit un utilitaire réel : exportez tous les fichiers en partie ouverts au format STEP. C'est une exigence commune pour la collaboration avec d'autres systèmes CAO.

Exportation de lots de Python

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

Ce script imite à travers toutes les pièces chargées (à l'exclusion de la partie d'affichage) et exporte chacune vers STEP en utilisant le .

C# Exportation par lots

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


Les deux scripts supposent que vous avez les autorisations d'exportation nécessaires et que NX peut écrire dans le dossier de sortie. La gestion des erreurs (try-catcher) doit être ajoutée dans le code de production.



 Meilleures pratiques pour le développement et le déploiement de scripts



Structure du code et maintien en vigueur


    
 
  • Modularisation:[ Découpez votre script en fonctions ou en classes. En C#, utilisez des fichiers séparés pour différents groupes de fonctionnalités.
    • 
 
  • Nom en accord: Suivez les conventions NX API de nommage. Utilisez dans C# et dans Python pour les variables locales.
    • 
 
  •  Contrôle de la configuration:[ Utilisez Git pour suivre les changements. Les scripts NX évoluent à mesure que vos conceptions de pièces changent.
    • 




 Gestion des erreurs et enregistrement


    
 
  • Enveloppez les appels d'API dans des blocs essai-sauf (Python) ou essai-capture (C#). Vérifiez pour les erreurs NX spécifiques.
    • 
 
  •  Utilisez NX="s pour les commentaires en temps réel. Pour les journaux, écrivez à un fichier texte en utilisant (C#) ou la logage standard de Python.
    • 
 
  • Détruisez toujours les constructeurs dans un bloc ou en utilisant une instruction (C#) pour éviter les fuites de mémoire.
    • 




 Considérations relatives aux performances


    
 
  • Minimisez le nombre d'appels API dans les boucles. Par exemple, si vous avez besoin d'accéder à une collection de fonctionnalités de part.
    • 
 
  • Pour les gros ensembles, utilisez des drapeaux pour éviter de charger complètement les composants dont vous n'avez pas besoin.
    • 
 
  •  Éteignez les mises à jour de l'écran pendant les opérations de lot. En C#, utilisez et ré-activer après.
    • 
 
  •  Dans Python, vous pouvez utiliser .
    • 




 Essais


    
 
  • Tester les scripts dans Session NX isolée[ (démarrer NX avec une nouvelle partie vide).
    • 
 
  •  Créer des pièces d'essai avec géométrie connue pour valider les sorties.
    • 
 
  • Pour les DLLs C#, écrire des tests unitaires en utilisant un cadre de simulation (comme Moq) pour simuler des objets NX – bien que les tests contre une instance NX réelle soient plus fiables.
    • 




Déploiement


    
 
  • scripts Python: Distribuer sous forme de fichiers . Assurez-vous que tous les utilisateurs ont des versions Python et NX compatibles.
    • 
 
  • C# scripts: Fournissez une DLL compilée avec un fichier manifeste () qui enregistre l'add-in. Sinon, placez la DLL dans le dossier sous l'installation NX pour charger automatiquement.
    • 




Dépannage de problèmes communs



Mismatches de version de l'API


Un script écrit pour NX 1926 ne peut pas fonctionner avec NX 1980 sans modifications. Vérifiez toujours le à l'exécution et ajustez les appels de méthode en conséquence. Reportez-vous à la documentation de l'API Siemens NX pour la bonne version.



 Erreurs d'importation de Python


Si vous voyez , assurez-vous que est dans votre chemin Python. Le fichier est habituellement dans . Ajoutez ce chemin à votre variable d'environnement .



Constructeur non engagé


Si votre script ne fait rien, vérifiez que vous avez appelé et pas seulement . Vérifiez également que les paramètres du constructeur sont valides (p. ex., les longueurs négatives causent des exceptions).



 Autorisations et accès aux fichiers


Les scripts d'exportation par lots échouent souvent parce que NX n'a pas d'accès écrit au dossier de sortie. Exécutez NX en tant qu'administrateur ou choisissez un dossier dans votre profil utilisateur. Utilisez pour résoudre les chemins relatifs.



Conclusion


Le développement de scripts d'automatisation personnalisés avec Python et C# permet de débloquer tout le potentiel de Siemens NX, vous permettant de rationaliser les tâches répétitives, d'appliquer les normes et de s'intégrer à des systèmes PLM plus grands. Python excelle dans le développement rapide et les processus riches en données, tandis que C# offre des performances robustes et des capacités d'interface utilisateur avancées.


 Commencez petit : Journalisez une opération manuelle, convertissez-la en script Python, puis ajoutez progressivement de la complexité. Au fur et à mesure que vous gagnez en confiance, explorez les capacités plus profondes de l'API – création de fonctionnalités personnalisées, automatisation de simulation, et même lier NX à des bases de données externes. La communauté Siemens PLM  est une excellente ressource pour trouver des exemples et poser des questions.