Introdução aos Scripts de Automação Personalizados do NX

A Siemens NX é uma poderosa plataforma CAD/CAM/CAE que vai além da modelagem manual, expondo um rico conjunto de APIs para automação. Escrever scripts personalizados em Python ou C# permite que engenheiros e desenvolvedores eliminem o trabalho manual repetitivo, imponham padrões de design e integrem o NX em pipelines de engenharia maiores. Se você precisa exportar arquivos em lote, automatizar a criação de geometria ou executar simulações sem intervenção do usuário, dominar scripts NX é um multiplicador de força para qualquer equipe de design.

Este artigo fornece um guia prático e expandido para desenvolver scripts de automação personalizados de NX usando Python e C#. Você aprenderá as diferenças entre as duas linguagens, como configurar seu ambiente de desenvolvimento, escrever scripts prontos para produção e aplicar as melhores práticas para evitar armadilhas comuns. O objetivo é dar-lhe uma base sólida para construir automação robusta que funcione perfeitamente com seu fluxo de trabalho NX.

Compreendendo o Ecosistema de Automação NX

A automação NX é construída sobre a API NX Open, uma biblioteca abrangente que expõe quase todas as funcionalidades disponíveis na interface de usuário NX. A API está disponível em múltiplas interfaces de programação:

  • NX Open for Python – Fornece ligações Python para a API NX Open. Ideal para scripts rápidos, prototipagem e integração com bibliotecas de ciência de dados.
  • NX Open for .NET – Montagens .NET completas (C#, VB.NET) que lhe dão acesso a todo o modelo de objeto NX. Melhor para aplicações complexas e críticas com componentes de interface.
  • NX Open C++ – Para desenvolvedores que precisam de acesso direto à memória ou precisam se conectar com o código C++ legado.
  • Journaling – NX pode gravar suas ações manuais como um arquivo de diário (VB ou C#). Estes periódicos são um ótimo ponto de partida para aprender a sintaxe da API.

Todas as APIs compartilham um modelo de objeto semelhante, mas existem nuances específicas de linguagem. A chave é entender que a automação NX é orientada para eventos; você normalmente cria um objeto , então usa seu , , e várias classes de construtor para interagir com o modelo.

Escolhendo Entre Python e C#

A decisão entre Python e C# para automação NX depende dos seus requisitos de projeto, experiência em equipe e ambiente de implantação. Aqui está uma comparação detalhada:

Python para a Automação NX

  • Fácil de Uso: A sintaxe limpa do Python torna-o a maneira mais rápida de escrever scripts de automação. É ideal para engenheiros que não são desenvolvedores em tempo integral.
  • Prototipagem rápida: Você pode testar scripts interativamente usando um console Python incorporado dentro do NX (desde NX 12).
  • Integração de dados: O vasto ecossistema do Python (NumPy, Pandas, Matplotlib) permite combinar automação NX com análise e visualização de dados.
  • Performance: Python é interpretado; para montagens muito grandes ou loops apertados, pode ser mais lento que C#. No entanto, para a maioria das tarefas de scripting, a sobrecarga é insignificante.
  • Deployment: Os scripts Python são arquivos de texto simples. Eles podem ser executados dentro do NX através do menu File → Execute → NX Open ou usando o comando na linha de comando NX.

C# para a Automação NX

  • Acesso completo a .NET: C# dá a você todo o framework .NET, incluindo Formulários Windows ou WPF para diálogos de interface personalizada, threads de fundo e depuração avançada no Visual Studio.
  • Fortalecido: C# captura muitos erros no momento da compilação, facilitando a manutenção de grandes bases de código.
  • Integração com Outras Ferramentas Siemens: Muitos produtos Siemens PLM (como Teamcenter) fornecem APIs nativas .NET que combinam bem com a automação C#.
  • Performance: O código compilado é executado mais rápido do que o Python interpretado, especialmente para operações que iteram mais de milhares de faces ou arestas.
  • Deployment: Os scripts C# devem ser compilados em DLLs ou executáveis. Eles podem ser carregados como complementos NX via Arquivo → Utilitários → Ferramentas de Usuário ou colocando o DLL na pasta de inicialização.

Na prática, muitas equipes usam ambos: Python para tarefas ad-hoc e provas de conceitos, e C# para ferramentas críticas à missão que precisam de uma interface polida e alto desempenho.

Configurar Python para a Automação NX

Pré-requisitos

  • Siemens NX (versão 12 ou posterior é recomendada; suporte Python foi melhorado na Série NX 1926).
  • Python 3.x instalado na mesma máquina (NX não envia seu próprio Python; você precisa instalar uma versão compatível).
  • O pacote . Isto é frequentemente incluído com a instalação do NX, mas pode requerer a configuração de variáveis de ambiente.

Configuração do Ambiente

Antes de escrever seu primeiro script, certifique-se de que NX pode encontrar seu interpretador Python. No Windows, adicione a pasta de instalação Python para a variável de ambiente . Então, dentro do NX, verifique que Arquivo → Executar → NX Open → Python funciona sem erros. Se você conseguir uma mensagem “Incapaz de carregar Python”, verifique se a variável aponta para o seu diretório raiz Python.

Seu Primeiro Programa em Python

Inicie o NX, crie um novo arquivo de parte (por exemplo, , então abra o editor NX Python (ou use um IDE externo como o VS Code). Digite o seguinte script e execute-o de dentro do NX via Arquivo → Executar → NX Abrir → Navegar.

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 executado, este script cria um bloco 100×50×30 mm na origem. O padrão é o mesmo para quase qualquer criação de geometria: obter um construtor, definir parâmetros, commit e destruir o construtor.

Módulos Python de Chaves a Saber

  • – O espaço principal para todos os objetos NX.
  • – Chamadas de função do usuário (a API mais antiga, ainda usada para algumas tarefas de baixo nível).
  • – Ajudantes para conversões de unidades, matemática, etc.

Configurar C# para a Automação NX

Pré-requisitos

  • Siemens NX instalado.
  • Visual Studio (qualquer edição que suporte .NET Framework 4.7.2 ou posterior).
  • NX Open .NET montages. Eles estão tipicamente localizados em (ajustar o número da versão).

Criando um projeto de estúdio visual

  1. Crie um novo projeto C# Class Library (.NET Framework).
  2. Adicionar referências aos conjuntos NX necessários:
    • (opcional, para chamadas da UF)
  3. Defina o alvo da plataforma para x64 (NX é apenas 64 bits).
  4. Compilar o projeto para criar uma DLL.

Seu Primeiro Programa C#

Este exemplo faz o mesmo que o Python: criar um bloco.

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

Para testar esta DLL, compilá-lo e, em seguida, dentro de NX ir para Arquivo → Executar → NX Abrir → Navegar e selecione o DLL. NX irá executar o método automaticamente se você marcá-lo como o ponto de entrada (você também pode usar o ] para lançar um comando personalizado).

Depurando scripts C#

Anexar Visual Studio ao processo NX (]Debug → Anexar ao Processo → selecionar ). Defina pontos de interrupção no seu código C# e execute o script de dentro do NX. Isso lhe dá inspeção de variáveis completa e depuração gradual, uma vantagem sobre as instruções mais simples do Python .

Padrões de Automação do Núcleo

Independentemente da linguagem, cada script de automação NX segue um ciclo de vida semelhante:

  1. Obtém a sessão actual – em ambas as línguas.
  2. Obtém a parte de trabalho – ] (ou ]] para a parte visível).
  3. Criar um construtor – Usar métodos como .
  4. Set parameters – Use os métodos do construtor (por exemplo, , ]).
  5. Compromete o construtor – Isto cria o objeto NX real e retorna-o.
  6. Destruir o construtor – Liberta a memória.
  7. Atualizar a parte – Normalmente acontece automaticamente, mas para algumas operações você precisa chamar .

Para operações que envolvam seleção (por exemplo, o usuário escolhe uma face), você usa a classe . Você pode criar uma janela de seleção dentro do script ou deixar o usuário selecionar objetos de antemão usando métodos de seleção interativos.

Escrevendo um script prático: Exportar partes em lote para o STEP

Vamos construir um utilitário real: exportar todos os arquivos de partes abertas para o formato STEP. Este é um requisito comum para a colaboração com outros sistemas CAD. Nós forneceremos versões Python e C#.

Exportar Lote em 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()

Este script itera através de todas as peças carregadas (excluindo a parte de exibição) e exporta cada uma para o STEP usando o .

Exportar em lote em C#

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


 Ambos os scripts assumem que você tem as permissões de exportação necessárias e que o NX pode escrever na pasta de saída. O tratamento de erros (try- catch) deve ser adicionado no código de produção.



 Melhores práticas para o desenvolvimento e implantação de scripts



 Estrutura do código e manutenção


    
 
  • Modularização: Partir o seu script em funções ou classes. Em C#, usar arquivos separados para diferentes grupos de recursos.
    • 
 
  • Nomeamento Consistente: Siga as convenções de nomenclatura da API NX. Use em C# e em Python para variáveis locais.
    • 
 
  • Controle de Versão: Use Git para rastrear mudanças. Os scripts NX evoluem conforme seus projetos de peças mudam.
    • 




 Erro no tratamento e registo


    
 
  •  Quebrar chamadas de API em blocos de tentativa-exceto (Python) ou try-catling (C#). Verifique para erros específicos de NX.
    • 
 
  • Use o do NX para feedback em tempo real. Para logs, escreva em um arquivo de texto usando (C#) ou registro padrão em Python.
    • 
 
  • Destruir sempre os construtores num bloco ou usando instrução (C#) para evitar vazamentos de memória.
    • 




 Considerações sobre o desempenho


    
 
  • Minimize o número de chamadas de API dentro de loops. Por exemplo, se você precisar acessar a coleção de recursos de uma peça muitas vezes, armazene-a em uma variável.
    • 
 
  • Para grandes conjuntos, use as bandeiras para evitar carregar completamente os componentes de que não necessita.
    • 
 
  •  Desligue as atualizações da tela durante as operações em lote. Em C#, use e reative depois.
    • 
 
  • Em Python, você pode usar .
    • 




 Teste


    
 
  •  Teste scripts em  Sessão NX isolada (iniciar NX com uma nova parte vazia).
    • 
 
  •  Crie peças de teste com geometria conhecida para validar saídas.
    • 
 
  • Para DLLs C#, escreva testes unitários usando um framework de simulação (como Moq) para simular objetos NX – embora testar contra uma instância NX real seja mais confiável.
    • 




 Implantação


    
 
  • scripts Python: Distribua como . Certifique-se de que todos os usuários tenham versões compatíveis em Python e NX.
    • 
 
  • C# scripts: Fornecer uma DLL compilada juntamente com um arquivo manifesto () que registra o add-in. Alternativamente, coloque a DLL na pasta sob instalação NX para carregar automaticamente.
    • 




 Resolver Problemas Comuns



Mismatches da Versão da API


A API NX Open é específica da versão. Um script escrito para o NX 1926 pode não funcionar com o NX 1980 sem modificações. Verifique sempre o [[FLT: 45]] em tempo de execução e ajuste as chamadas de acordo. Consulte a documentação da API [[FLT: 0] Siemens NX] para a versão correta.



 Erros de Importação em Python


Se você vir , certifique-se de que está no seu caminho Python. O arquivo geralmente está na . Adicione este caminho à sua variável de ambiente .



 Construtor não autorizado


Se o seu script não fizer nada, verifique se você chamou e não apenas . Além disso, verifique se os parâmetros do construtor são válidos (por exemplo, comprimentos negativos causam exceções).



Permissões e Acesso a Ficheiros


 Os programas de exportação em lote falham frequentemente porque o NX não tem acesso de escrita à pasta de saída. Execute o NX como administrador ou escolha uma pasta no seu perfil de utilizador. Use [[ FLT: 52]] para resolver os caminhos relativos.



 Conclusão


 Desenvolver scripts de automação personalizados com Python e C# desbloqueia todo o potencial da Siemens NX, permitindo que você agite tarefas repetitivas, faça cumprir padrões e se integre com sistemas PLM maiores. Python se destaca em processos de desenvolvimento rápido e ricos em dados, enquanto C# oferece desempenho robusto e recursos avançados de interface. Ao entender a API NX Open, configurar corretamente seu ambiente e seguir as melhores práticas para o manuseio e desempenho de erros, você pode construir scripts confiáveis e mantendíveis em todas as versões NX.


 Comece pequeno: uma operação manual do diário, converta-o para um script Python, e então adicione gradualmente complexidade. À medida que você ganha confiança, explore as capacidades mais profundas da API — criação de recursos personalizados, automação de simulação e até mesmo vinculando NX a bases de dados externas. A Siemens PLM Community[] é um excelente recurso para encontrar exemplos e fazer perguntas. Com o conhecimento deste artigo, você agora está equipado para construir seu próprio kit de ferramentas de automação NX.