NX אוטומציה תסריטים

סימנס NX היא פלטפורמה CAD /CAM / CAE רבת עוצמה מעבר למודל ידני על ידי חשיפת קבוצה עשירה של APIs עבור אוטומציה.כתיבה תסריטים מותאמים אישית ב Python או C# מאפשר מהנדסים ומפתחים לחסל עבודה ידנית חוזרת, לאכוף תקני עיצוב, ושילוב NX לתוך צינורות הנדסיים גדולים יותר.אם אתה צריך לקבץ קבצים, יצירת גיאומטריה אוטומטית, או לרוץ ללא התערבות משתמש, עיצוב NX לתוך כל כוח מעצב הוא מכפיל.

מאמר זה מספק מדריך מורחב ומעשי לפיתוח תסריטי אוטומציה NX מותאמים אישית באמצעות Python ו- C#. תלמד את ההבדלים בין שתי השפות, כיצד להגדיר את סביבת הפיתוח שלך, לכתוב תסריטים קריאים בייצור, וליישם שיטות הטובות ביותר כדי למנוע מלכודות נפוצות.המטרה היא לתת לך בסיס מוצק לבניית אוטומציה חזקה שעובדת בצורה חלקה עם זרימת העבודה שלך NX.

NX אוטומציה Ecosystem

NX אוטומציה בנויה על ה-FLT:0 NX Open APIearFLT:1, ספרייה מקיפה שחשפה כמעט כל פונקציונליות הזמינה בממשק המשתמש של NX.ה- API זמין בממשקי תכנות מרובים:

  • (FLT:0 NX פתוח עבור PythonFLT:1) - מספק פייתון מחייבת עבור ממשק API פתוח NX. אידיאלי עבור תסריט מהיר, פשטות ושילוב עם ספריות מדע נתונים.
  • (FLT:0 NX פתוח עבור .NETFLT:1 - מלא ביצועים .NET Assemblies (C#, VB.NET) אשר נותן לך גישה למודל האובייקט NX כולו. Best forמורכב, ביצועים קריטיים יישומים עם רכיבי UI.
  • (FLT:0 NX Open C++FLT:1) - עבור מפתחים הזקוקים לגישה ישירה של זיכרון או צורך לקשר עם קוד C++ מורשת.
  • (FLT:0)JournalingFLT:1 NX יכול להקליט את הפעולות ידניות שלך כקובץ יומן (VB או C#) כתבי עת אלה הם נקודת התחלה נהדרת ללמידה של מס ה- API.

כל ה- API חולק מודל אובייקט דומה, אך ניאנסים ספציפיים בשפה קיימים.המפתח הוא להבין כי NX אוטומציה היא מונחה אירוע; בדרך כלל יוצרים FLT:0 אובייקט, ולאחר מכן להשתמש ב-FLT:1, בין היתר, ושיעורי בניה שונים כדי לתקשר עם המודל.

בחירת פייתון ו-C#

ההחלטה בין Python ו- C# עבור NX אוטומציה תלויה בדרישות הפרויקט שלך, מומחיות הצוות והסביבה של פריסה.כאן השוואה מפורטת:

Python for NX אוטומציה

  • (FLT:0)Ease of Userea: FLT:1 syntax הנקי של פייתון הופך את הדרך המהירה ביותר לכתוב תסריטי אוטומציה.זה אידיאלי עבור מהנדסים שאינם מפתחים במשרה מלאה.
  • (FLT:0) ראופיד פרוטוטיפינג: 1FLT: ניתן לבדוק תסריטים באופן אינטראקטיבי באמצעות קונסולת פייתון מוטבעת בתוך NX (מאז NX 12).
  • אינטגרציה:0 (איור 1:1) מערכת האקולוגית העצומה של Python (NumPy, Pandas, Matplotlib) מאפשרת לך לשלב NX אוטומציה עם ניתוח נתונים ודמיון.
  • (ב) התגלות:0 (הפסקה:0) ,(הפייתון) מפרש; עבור ניגודים גדולים מאוד או לולאות צמודות, ייתכן שהוא איטי יותר מ-C# עם זאת, עבור רוב משימות התסריטאיות, ראש הממשלה אינו ניתן להכחשה.
  • (ב) ,0) ,[דרוש מקור]: [ה] [ה] [ה], [ה], [ה]], [ה], [ה], [ה]]], [ה],] ‭ ‬התחילה], או באמצעות [ה-FLT 3:2], באמצעות פיקוד הפיקוד על NX.

C# עבור NX אוטומציה

  • (FLT:0) גישה מלאה ל-.NET:FLT:1 C# נותן לך את כל המסגרת .NET, כולל טפסים של Windows או WPF עבור דיאלוגים או UI מותאם אישית, חוטי רקע, ו debugging מתקדם באולפן חזותי.
  • (ב) ⁇ :0) ,בטיפוס: 1FLT:1 , C# תופס שגיאות רבות בעת יצירת זמן, מה שהופך את זה קל יותר לשמור על בסיס קוד גדול.
  • (FLT:0) אינטגרציה עם כלי סימנס אחרים:03F1) מוצרים רבים של סימנס PLM (כמו Teamcenter) מספקים ממשקי API מקומיים.NET אשר יחד עם C# אוטומציה.
  • (ב) ,0) רפורמות: קוד תושלם פועל מהר יותר מאשר פייתון, במיוחד עבור פעולות כי הוא מתפרש על פני אלפי פרצופים או קצוות.
  • (ב) יש להוסיף את ה-DLLS או ל-DLLs או ל-exetable: הם יכולים להיות טעון כ-NX תוספות באמצעות FLT:2File - Utilities - ToolsFLT 3 או על ידי הצבת ה-DLL בתיקיה הסטארט-אפ.

בפועל, קבוצות רבות משתמשות הן: Python עבור משימות אד-הוות והוכחה של תפיסות, ו- C# עבור כלים קריטיים למשימה שזקוקים לממשק מלוטש וביצועים גבוהים.

עקבו אחרי NX Automation

Prerequisites

  • סימנס NX (הגרסה 12 ואילך מומלצת: התמיכה ב- Python הורחבה ב- NX 1926.
  • Python 3.x מותקן על אותה מכונה (NX אינה אוניית Python משלה; עליך להתקין גרסה מתאימה).
  • חבילת ה-FLT:4 (FLT:4 ).זה כל הזמן נכלל עם ההתקנה NX אבל עשוי לדרוש שינויים סביבתיים.

איכות הסביבה

לפני כתיבת התסריט הראשון שלך, להבטיח NX יכול למצוא את מתורגמנים Python שלך ב- Windows, להוסיף את תיקיית ההתקנה של Python ל-FLT:5 סביבה משתנה, בתוך NX, לבדוק כי FLT:0File; הוצאה להורג NX Open, PythonFLT 1 פועל ללא שגיאות.

צילום: The First Python Script

ההשקה NX, יצירת קובץ חלק חדש (למשל, FLT 7), ולאחר מכן פתח את עורך Python NX (או להשתמש ב- IDE חיצוני כמו קוד V) להיכנס לתסריט הבא ולהפעיל אותו מבפנים NX באמצעות NC:0File) הוצא להורג NX Open NX Open NX , BrowseFLT:1.

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

כאשר הוצא להורג, התסריט הזה יוצר בלוק 100×50 מ"מ במקור.התבנית זהה כמעט לכל יצירה גיאומטרית: קבל בונה, לקבוע פרמטרים, להתחייב, להרוס את הבנאי.

מודולים של Python כדי לדעת

  • (ב) LT:9 - מקום השם העיקרי לכל NX אובייקטים.
  • (FLT:10 ), ייעוד המשתמש (ממשק משתמש, עדיין בשימוש עבור כמה משימות ברמה נמוכה).
  • (ב) , (ב) , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

הגדרת C# עבור NX אוטומציה

Prerequisites

  • סימנס NX מותקנת.
  • Visual Studio (כל מהדורה שתומכת ב-.NET Framework 4.7.2 ואילך).
  • NX Open .NET Assemblies, הם ממוקמים בדרך כלל ב NX:12 (מספר גירסה מדויקת).

יצירת פרויקט Visual Studio

  1. יצירת פרויקט חדש של C# Class Library (.NET Framework)
  2. ← NX Assmblies:0.10.10.10.10.10.
  3. (במילים אחרות)
  4. (ב) .
  5. הגדר את היעד ל- x64 (NX הוא 64 סיביות בלבד).
  6. לבנות את הפרויקט כדי ליצור DLL.

תסריט ראשון

דוגמה זו היא ה- Python One: ליצור בלוק.

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

כדי לבדוק את ה-DLL, לעיין בו ולאחר מכן בתוך NX ללכת ל-FLT:0 (File) הוציאו להורג את שיטת ה-NX Open (BrowsephFLT:1), ובחרו את ה-DLL. NX יבצע את שיטת ה-FLT:17 באופן אוטומטי אם תסמן אותה כנקודת הכניסה (אפשר להשתמש גם ב-FLT:18 כדי להפעיל את הפקודה המתאימה).

ביקורת C# Scripts

סטודיו חזותי המצורף לתהליך NX (ראה FLT:0)Debug המצורפת ל- ProcessFreaLT:1 ; בחר באפשרות FLT:19 ; Set Breakpoints בקוד C# שלך והפעלה של התסריט מבפנים NX.זה נותן לך בדיקה משתנה מלאה וצעד-דרך debugging, יתרון על הצהרות FLT:20 פשוטות יותר של Python.

תבניות אוטומציה Core

ללא קשר לשפה, כל תסריט אוטומציה של NX עוקב אחר מחזור חיים דומה:

  1. (ב) בפסוקים (ב"ב) "ה'" (ב"ב) "ה' (ב"ב)" (ב"ב)" (ב"ב)"ב).
  2. (ב) "ה'" (ב"ב) "ה', "ה', ב'" (ב)" (ב"ב)" (ב"ב)"ה)
  3. (ב) ויקרא י"ד: "ה' אֱלֹהֶיךָ" (בראשית כ"ד, ט).
  4. (ב) , (ב) , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  5. (ב) ,0) למקם את הבונים הבאים (ב) - זה יוצר את האובייקט האמיתי של NX וחוזר.
  6. (ב) ויקרא י"ד: "ה' י'"א י"א , ויקרא י"ד ,
  7. (ב) ,0) , מדרש (ב) הוא בדרך כלל באופן אוטומטי, אך עבור חלק מהפעולות שאתה צריך לקרוא להן FLT:27.

עבור פעולות הכרוכות בבחירת (למשל, המשתמש בוחר פנים), אתה משתמש ב-FLT:28 כיתה.You יכול ליצור דיאלוג בחירה בתוך התסריט או לתת למשתמש לבחור אובייקטים מראש באמצעות שיטות בחירה אינטראקטיביות.

כותב תסריט מעשי: בינץ' יחלק ל- STEP

בואו נבנה שירות בעולם האמיתי: לייצא את כל הקבצים הפתוחים לפורמט STEP.זוהי דרישה נפוצה לשיתוף פעולה עם מערכות CAD אחרות.We'll לספק הן Python ו- C# גירסאות.

Python Batchיצוא

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

התסריט הזה מתעדכן בכל החלקים המוטעים (לא כולל חלק התצוגה) וייצוא כל אחד ל- STEP באמצעות ה- 30.

C# Batchיצוא

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


שני התסריטים מניחים שיש לך את הרשאות הייצוא הדרושות, וכי NX יכול לכתוב לתיקיית הפלט.טיפול בשגיאות (try-catch) צריך להוסיף בקוד הייצור.



שיטות טובות ביותר עבור פיתוח Script ו- Deployment



מבנה קוד ושמירה


    
 
  • (ב) .0)Modularization: FLT:1 לשבור את התסריט שלך לפונקציות או שיעורים.ב-C#, השתמש בקבצים נפרדים לקבוצות תכונות שונות.
    • 
 
  • (ב) [15] , ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ 
    • 
 
  • (ב) .0;0) בקרת ההנעה: 1FLT (ה) השתמש ב- Git כדי לעקוב אחר שינויים. NX תסריטים מתפתחים ככל שהעיצובים שלך משתנים.
    • 




טעויות וקידוד


    
 
  • Wrap API קורא לנסות (Python) או לנסות-catch (C#) בלוקים (C#) לבדוק את ה-DipFLT:34 עבור שגיאות NX ספציפיות.
    • 
 
  • השתמש ב-NX's (FLT:35 עבור משוב בזמן אמת. עבור יומני, לכתוב קובץ טקסט באמצעות שימוש ב-C# (C#) או סטנדרטי Python.
    • 
 
  • תמיד להרוס את הבנאים בבלוק (FLT:37) או באמצעות הצהרה (C#) כדי למנוע דליפות זיכרון.
    • 




שיקולים


    
 
  • מזער את מספר ה- API קורא בתוך לולאות.לדוגמה, אם אתה צריך לגשת לאוסף המאפיין של חלק פעמים רבות, לאחסן אותו במשתנה.
    • 
 
  • עבור מחאות גדולות, השתמש דגלים כדי למנוע מרכיבים טעינה מלאה אתה לא צריך.
    • 
 
  • הפעל את עדכוני המסך במהלך פעילות אצווה.ב-C#, השתמש ב-FLT:40 וניתן יהיה לשחזר אותם מחדש לאחר מכן.
    • 
 
  • ב- Python ניתן להשתמש ב-FLT:41.
    • 




בדיקות


    
 
  • תסריטי מבחן ב-[[1924]]:0]], NX, ]] ו[[1924]], [[1924]], [[1924]]]]
    • 
 
  • צור חלקי מבחן עם גיאומטריה ידועה כדי לאמת את התפוקה.
    • 
 
  • עבור C# DLLs, לכתוב מבחנים באמצעות מסגרת לעג (כמו Moq) כדי לדמות NX אובייקטים - למרות שבדיקות נגד מקרה NX אמיתי הן אמינות יותר.
    • 




המונחים:


    
 
  • תצלום: Distribute as FLT:42 קבצים.להבטיח כי כל המשתמשים יש גירסאות Python ו NX תואמים.
    • 
 
  • (ב) כתוב: "תן תיק מורכב יחד עם קובץ מצורף (ראה:בפרקים) אשר נרשם לתוספת-באלטרנטיבה, להציב את ה-DLL בתיקיה FLT:44 תחת התקנת NX לעומס אוטומטי.
    • 




בעיות נפוצות



גירסה API Mismatchs


NX Open API הוא מפרט גרסאות.תסריט שנכתב עבור NX 1926 אינו יכול לעבוד עם NX 1980 ללא שינויים.תמיד לבדוק את ה-FLT:45 בזמן ריצה ולהתאים את הקריאות בהתאם.



Python מקבל שגיאות


אם אתה רואה את ה-FLT:46, ודא כי ה-FLT:47 הוא בדרך כלל במסלול פייתון שלך.



לא כוונון


אם התסריט שלך אינו מספק, בדוק כי אתה קורא FLT:50 ולא רק (FLT:51) וגם לבדוק כי הפרמטרים של בונה הם בתוקף (למשל, אורכו שלילי גורם חריגים).



דרישות וגישה לקובץ


תסריטי בינץ של בנץ נכשלים לעתים קרובות משום ש-NX לא יש גישה לתיקיית הפלט. Run NX כמנהל או בחר תיקיה בפרופיל המשתמש שלך. השתמש ב-FLT:52 כדי לפתור נתיבים יחסיים.



מסקנה


פיתוח תסריטי אוטומציה מותאמים אישית עם Python ו- C# פותח את מלוא הפוטנציאל של סימנס NX, המאפשר לך לייעל משימות חוזרות ונשנות, לאכוף סטנדרטים, ולשלב עם מערכות PLM גדולות יותר. Python מצטיין בפיתוח מהיר ותהליכים עשירי נתונים, בעוד C# מציע ביצועים חזקים ויכולות UI מתקדמות. על ידי הבנת ממשק API פתוח NX, הגדרת הסביבה שלך נכונה, ולאחר שיטות הטובות ביותר לטיפול וביצועים, אתה יכול לבנות תסריטים אמינים ומאובטחים על פני גירסאות.


התחל קטן: יומן פעולה ידנית, להמיר אותו לתסריט פייתון, ולאחר מכן להוסיף בהדרגה מורכבות.כפי שאתה מקבל ביטחון, לחקור את היכולות העמוקות יותר של ה- API - תכונה אישית, סימולציה, ואפילו קישור NX עם מסדי נתונים חיצוניים.ה-FLT:0Siemens PLM CommunityFLT:1 הוא משאב מצוין למציאת דוגמאות ולשאול שאלות.