Qu’est-ce qu’iLogic ?
La plupart des utilisateurs d’applications de bureau comprennent le concept d’automatisation. Si vous utilisez Microsoft Excel, vous connaissez probablement les macros, ces outils développés et conçus dans Excel pour réaliser des tâches spécifiques. Inventor L’automatisation est très similaire. Quelle que soit sa forme, il s’agit d’un outil ou d’une série d’outils qui sert à exécuter automatiquement une tâche, un processus ou une fonction spécifique. Dans Inventor, l’automatisation prend notamment la forme d’iLogic.
iLogic est une fonctionnalité d’Inventor qui permet aux utilisateurs et aux administrateurs de créer une logique en langage VB.net afin de réaliser certaines tâches. Il est possible de développer et d’organiser des règles à l’aide d’extraits et d’autres instructions d’écriture de code de sorte à les exécuter à des moments précis afin d’effectuer de manière cohérente des tâches d’ingénierie et de conception.
Vous pouvez développer une série de règles iLogic pour effectuer des tâches telles que la mise à jour d’iPropriétés en fonction de différents critères de modèle ou le remplacement de composants dans un assemblage sur la base de sélections faites dans un formulaire iLogic. Vous pouvez également mettre à jour des blocs de texte dans un dessin associé. iLogic permet de réaliser un grand nombre de tâches. À vous de choisir laquelle.
Pourquoi utiliser iLogic ?
Maintenant que nous avons présenté les fonctions d’iLogic, intéressons-nous aux raisons qui font d’iLogic un outil idéal pour vos processus d’ingénierie.
J’ai eu l’occasion de collaborer avec des entreprises internationales de toutes tailles, spécialisées dans différents types de produits, et j’ai appris que chaque environnement comporte des modèles répétitifs et des scénarios reproductibles. Il est essentiel d’identifier les situations dans lesquelles iLogic peut être utile. Cette tâche simple nécessite une bonne connaissance de toutes les étapes dans lesquelles Inventor intervient au cours de votre processus.
Supposons que vous utilisez un format spécifique pour la description des iPropriétés de vos modèles 3D ou toute autre iPropriété. Si le format est prévisible et normalisé, iLogic peut être utile. Vous pouvez développer une logique pour collecter des informations dans le modèle, convertir ces informations, puis remplacer les iPropriétés par les informations correctes possédant le nouveau format. L’outil ne se trompe jamais, il est toujours cohérent et il n’a pas besoin de pause.
Article connexe : Taking It to the Next Level: Drawing Automation with Autodesk Inventor par Thomas Fitzgerald
Configuration d’Inventor pour l’utilisation d’iLogic
Comment puis-je configurer Inventor pour utiliser efficacement iLogic ?
iLogic est inclus dans Inventor : vous pouvez donc l’utiliser immédiatement et commencer à créer. Pour en tirer le meilleur parti, vous devez toutefois configurer certains paramètres. Le bouton Configuration iLogic permet aux utilisateurs de configurer différents paramètres afin de définir l’emplacement d’informations utiles pour Inventor.
Les utilisateurs et les administrateurs ont parfois besoin de modifier ces paramètres pour définir l’emplacement des répertoires de règles externes utilisés par Inventor ainsi que l’ordre de priorité de ces répertoires. Les utilisateurs peuvent également définir l’emplacement des répertoires des bibliothèques de liens dynamiques (DLL). Les fichiers DLL sont générés dans Microsoft Visual Studio pour gérer et déclencher les règles iLogic et d’autres logiques dans le cadre du développement d’interfaces utilisateur personnalisées.
La boîte de dialogue Paramètres permet de définir l’extension des fichiers d’enregistrement des règles externes et le niveau de journalisation par défaut des informations de débogage. Les options de sécurité permettent de protéger les ordinateurs et les systèmes réseau contre l’exécution de codes potentiellement dangereux dans l’environnement Inventor. Pour plus d’informations sur les règles externes et le débogage, reportez-vous aux sections suivantes.
Règles internes et règles externes
Lesquelles dois-je utiliser et quand ?
iLogic permet de définir des règles internes et des règles externes. Le processus de création de ces deux types de règles est similaire dans le navigateur iLogic d’Inventor.
Les règles internes sont créées et stockées dans le contexte d’un fichier. Grâce aux fichiers pièce, assemblage et dessin, il est possible de stocker, de compiler et d’exécuter des règles en fonction de chaque fichier. Les règles externes sont très similaires, à la différence près qu’elles ne sont pas stockées dans des fichiers Inventor. Les règles internes étant stockées dans les fichiers, tous les utilisateurs disposant des autorisations appropriées peuvent y accéder. Les règles externes sont stockées dans un répertoire, soit sur un système utilisateur local soit sur un serveur central, indépendamment de l’emplacement.
Les règles externes étant stockées dans un dossier et non dans des fichiers, un niveau de sécurité plus élevé peut être appliqué à ces règles. Les utilisateurs peuvent ouvrir et afficher le code des règles. Toutefois, les administrateurs système peuvent contrôler l’accès en lecture et en écriture en définissant des autorisations d’accès au dossier des règles externes. C’est pourquoi les règles externes conviennent davantage dans un environnement d’entreprise dans lequel de nombreux utilisateurs souhaitent exécuter du code tout au long du processus de conception. Si les conditions ne nécessitent pas le contrôle des autorisations ou si seulement quelques utilisateurs ont besoin d’appliquer simultanément la logique des règles, les règles internes peuvent suffire.
Comme illustré ci-dessous, ces deux types de règles sont visibles dans le navigateur iLogic.
En cliquant avec le bouton droit de la souris sur chaque type de règle, plusieurs fonctionnalités s’affichent (comme le masquage ou l’annulation du masquage des règles) pour contrôler les délais de déclenchement, la suppression des règles ou leur suppression d’une liste.
Paramètres et propriétés
Comment dois-je les utiliser ?
Autodesk Inventor est une application de conception paramétrique 3D. Qu’est-ce que cela signifie ? Les paramètres sont des espaces réservés de valeurs nommées correspondant à un type spécifique. La plupart des paramètres d’Inventor sont numériques et associés aux cotes qui contrôlent la géométrie. Lorsque les valeurs des paramètres changent, les cotes associées à ces paramètres changent également et la présentation graphique des modèles est mise à jour en conséquence. Inventor comporte 4 types de paramètres :
1) Paramètres de modèle
2) Paramètres utilisateur
3) Paramètres de référence
4) Paramètres liés
Les paramètres de modèle sont créés dans des conditions de fonctionnement normal d’Inventor. Dans la boîte de dialogue Paramètres, ils sont automatiquement nommés d0, d1, d2, etc. Les paramètres de modèle sont contrôlés par Inventor, ce qui signifie qu’ils sont créés et supprimés par le système en fonction des besoins.
Les paramètres utilisateur sont créés par les utilisateurs. Il s’agit des paramètres suivants : numérique, texte, chaîne, vrai/faux ou booléen. Les paramètres utilisateur sont particulièrement importants, car ils sont créés par les utilisateurs et utilisés par plusieurs fonctionnalités ainsi que par le code iLogic. Par ailleurs, ils ne sont pas créés ou supprimés par Inventor dans le cadre d’un fonctionnement normal.
Remarque : pour utiliser des informations de paramètres dans les règles iLogic, il est recommandé de créer des paramètres utilisateur en appliquant une convention de dénomination et un type. Il n’est pas recommandé de renommer les paramètres de modèle, même si cela est possible.
Des paramètres de référence sont créés lorsqu’Inventor définit une cote pilotée. Vous avez peut-être déjà vu cette boîte de dialogue dans l’environnement Esquisse :
Pour créer un paramètre de référence, il suffit de cliquer sur le bouton Accepter. Dans la boîte de dialogue Paramètres, le nom et la valeur du paramètre s’affichent, mais la valeur n’est pas modifiable. Vous pouvez modifier le nom, ce qui est utile pour utiliser la valeur dans le code iLogic.
Les paramètres liés sont liés à Inventor, généralement à partir d’une feuille de calcul Excel. Lorsqu’un utilisateur met à jour les noms et les valeurs dans une feuille de calcul Excel, ces modifications sont reflétées dans Inventor. Elles déterminent les valeurs des cotes, contrôlent les fonctionnalités et gèrent les assemblages, etc.
Les propriétés, ou iPropriétés dans le jargon Inventor, sont des descripteurs supplémentaires ou d’autres informations utiles sur vos fichiers. Elles sont parfois appelées métadonnées. Les propriétés ne constituent pas une nouveauté et peuvent être très utiles lorsque vous essayez de collecter de grandes quantités d’informations sur les fichiers. Par exemple, le nom d’un fichier, sa taille, son auteur et sa date de modification sont des propriétés. Lors de l’utilisation de données de fichier iLogic et Inventor, le nom et le chemin du fichier sont généralement les deux propriétés les plus employées. D’autres propriétés sont également utilisées (comme les numéros de pièce et de stock, la masse, le coût) ainsi que des propriétés personnalisées. Toutes les propriétés sont accessibles en lecture et la plupart en écriture.
Déclaration de variables, conversion de type et variables partagées
Quelle est l’importance de ce langage de codage ?
iLogic est tout simplement du code. Vous n’avez pas besoin d’être programmeur ou de savoir écrire du code. Toutefois, il peut être utile d’avoir quelques notions de base et de connaître les meilleures pratiques, car tous les programmeurs suivent certaines normes. La déclaration de variables et la conversion de type font partie de ces normes. Pourquoi est-ce important ? Cela équivaut à parler une langue : l’application d’une norme simplifie l’écriture de la logique.
Déclaration de variables et conversion de type
La déclaration de variables est très simple. Dans iLogic, cela consiste à écrire un nom et à lui attribuer une valeur :
Length = 20
Après avoir créé une variable, je peux l’utiliser pour effectuer certaines tâches. Je peux lire une valeur et la traiter dans un calcul ou je peux l’écrire afin d’effectuer une mise à jour. Dans iLogic, il est possible de saisir une paire nom-valeur. Toutefois, il est préférable de saisir un nom, puis de lui attribuer un type et une valeur.
Dim Length As Double = 20
Ici, vous indiquez à iLogic de créer une variable qui contiendra uniquement une valeur « double », puis vous lui attribuez une valeur. Cette opération s’appelle la conversion de type. Elle permet de s’assurer que seule une valeur spécifique peut être attribuée à la variable. Si j’essayais d’attribuer une valeur Chaîne ou Texte à la variable Length, mon code ne fonctionnerait pas. En indiquant un type, il est possible d’utiliser un code beaucoup plus sophistiqué dans les règles, tout en analysant et en visualisant le flux d’informations. Par exemple, si j’écris une instruction dans une règle pour générer un calcul mathématique et qu’une erreur s’affiche, cela m’indiquera que toutes les variables de type Chaîne sont correctes.
Voici des exemples de différents types de déclaration de variables et de conversion de type :
Dim cylinderHeight As Double = Parameter("CylinderHeight")
Dim fileName As String = "This is a string value!"
Dim holeCount As Integer = 2
Dim occurrenceName As String = String.Empty
Dim plateWidth As Double = Nothing
Dans les deux derniers exemples, je n’ai pas indiqué de valeur, mais une valeur vide (Empty) ou rien (Nothing). Parfois, il se peut qu’une valeur soit nécessaire, mais que vous ne la connaissiez pas encore. Dans ce cas, afin de déclarer cette variable de manière cohérente, vous pouvez convertir le type et spécifier une valeur après le symbole « = ». Cette méthode est également utile pour déboguer du code afin de vérifier si une valeur a été fournie par le programme.
Dans le premier exemple, vous avez peut-être remarqué que j’ai déclaré une variable, converti le type et indiqué la même valeur que celle d’un paramètre utilisateur. Cette méthode sera utile lors de la construction d’une logique à des fins de calcul, de la transmission de valeurs à d’autres constructions et de la manipulation d’autres paramètres. Elle peut également servir à obtenir ou à définir immédiatement la valeur du paramètre utilisateur, au moment où le code en a besoin. C’est pour cette raison que les débutants ont parfois des problèmes lors de l’exécution des règles iLogic. Ils s’attendent à un comportement particulier, mais Inventor semble être en retard d’une étape. Observez les exemples suivants :
cylinderHeight = CylinderHeight
Dim cylinderHeight As Double = Parameter("CylinderHeight")
Bien que similaires, ces deux instructions ne produisent pas le même résultat. Le premier exemple déclare une variable qui pourrait être de tout type, avec une valeur égale à celle du paramètre utilisateur. Inventor reconnaît le paramètre utilisateur, car le texte est en bleu. Toute règle dont le masquage est annulé à l’aide de ce format est automatiquement exécutée, car Inventor reconnaît le paramètre utilisateur. Vous ne souhaitez peut-être pas exécuter les règles de cette façon.
Cela signifie également que la variable sera définie sur la valeur du paramètre utilisateur correspondant à la dernière mise à jour. Si la logique a modifié la valeur du paramètre utilisateur entre le moment où la variable a besoin de la valeur et la dernière mise à jour, le paramètre utilisateur devient obsolète et une mise à jour est nécessaire. Parfois, de nombreuses mises à jour peuvent être requises pour obtenir le résultat souhaité.
Pour résoudre ce problème, vous disposez de deux méthodes. Tout d’abord, vous pouvez utiliser la deuxième instruction. En déclarant la variable, en convertissant le type et en utilisant la fonction Parameter, vous définissez directement la variable sur la valeur du paramètre utilisateur et vous avez ainsi la certitude que la valeur sera à jour. Cela vous permet également de mieux contrôler le moment d’exécution des règles. Ensuite, vous pouvez utiliser l’extrait iLogic RuleParametersOutput() de sorte que tous les paramètres utilisateur soient à jour. Effectuez une mise à jour pour vous assurer que les modèles associés sont également à jour.
Variables partagées
Nous avons parlé des pratiques de code applicables aux variables. Toutefois, les variables partagées sont une fonctionnalité d’iLogic. Lorsque vous déclarez des variables dans une règle iLogic, ces variables sont accessibles uniquement dans le contexte de cette règle. Si vous avez besoin de créer une variable et que vous définissez sa valeur de sorte à l’utiliser dans de nombreuses règles, je vous conseille les variables partagées.
Dans le panneau d’extraits iLogic de l’éditeur de règles iLogic, les fonctions de variables partagées sont disponibles sous l’index Variables.
Pour utiliser des variables partagées, vous devez procéder de la même façon que pour la déclaration d’autres variables. Tout d’abord, déclarez la variable partagée, nommez-la, puis attribuez-lui une valeur. Vous pouvez utiliser une valeur statique ou la valeur d’une autre variable, d’un autre paramètre ou d’une autre propriété.
SharedVariable("VariableName") = "This is the value" SharedVariable("cylinderHeight") = Parameter("CylinderHeight")
Après avoir déclaré une variable partagée et spécifié sa valeur, vous pouvez l’utiliser et la mettre à jour selon les besoins.
Dim cylinderHieght As Double = SharedVariable("cylinderHeight")
Vous pouvez utiliser les autres fonctions de variables partagées pour vérifier si une variable partagée est disponible ou pour supprimer toutes les variables partagées de la mémoire.
Expressions conditionnelles et boucles
Un humain doit-il toujours prendre des décisions ?
Dans le cadre d’une utilisation normale d’Inventor, il est possible de sélectionner une géométrie dans la fenêtre graphique afin d’en spécifier l’utilisation. Dans un assemblage, la relation entre les composants est facile à comprendre. En ce qui concerne les règles iLogic, il peut être nécessaire de définir le processus décisionnel en analysant les différentes conditions d’une conception. Pour réaliser ces tâches, les utilisateurs d’iLogic peuvent définir ces conditions à l’aide d’expressions.
L’expression conditionnelle la plus courante est l’expression If Then. Le résultat ressemble à ceci :
If someValue = True Then
'Do Something
Else
'Do Something Else
End If
Nous recherchons une condition dans le code. Si elle est présente, le code génère une action. Si la condition n’est pas présente ou qu’une autre condition est présente, le code génère une autre action. Nous pouvons appliquer cette fonctionnalité lors de la recherche de nombreuses conditions, notamment :
If someValue = True Then
'Do Something
ElseIf someValue = False Then
'Do Something Else
ElseIf someValue = Nothing Then
'Yet Do Something Else
End If
Cela semble simple et parfaitement logique, mais les possibilités sont limitées. Les conditions ne peuvent pas continuer indéfiniment. À un moment donné, il devient difficile de comprendre ce qui se passe, en particulier lorsque vous commencez à ajouter des opérateurs. Au-delà de 3 ou 4 conditions, je conseille d’utiliser une autre méthode.
La méthode Select Case est une autre expression conditionnelle courante. Son fonctionnement est similaire, mais je pense qu’elle est plus facile à lire et à comprendre. Elle présente également l’avantage de nécessiter moins de code. La méthode Select Case ressemble à ceci :
Select Case someValue
Case True
'Do Something
Case False 'Do Something Else
Case Nothing
'Yet Do Something Else End Select
Comme vous le voyez, cette méthode est plus facile à comprendre et à adapter au nombre de conditions souhaité.
Le concept des boucles est l’une des méthodes les plus utiles pour l’écriture de code. Utilisons l’exemple de l’itération via un assemblage pour obtenir les noms des occurrences. Les boucles permettent de parcourir toutes les occurrences sans connaître leur nombre. Pour construire le code et développer la logique, il convient de comprendre les modèles, la cohérence et la prévisibilité. Certaines méthodes permettent d’intégrer l’imprévisibilité. Il s’agit des boucles. Voici un exemple de boucle For Next :
Dim counter As Integer = 3
For t As Integer = 1 To counter
MessageBox.Show("Number of Iterations: " & t)
Next
Dans cet exemple, nous avons défini le point de départ de la boucle (1). Nous avons également défini la fin de la boucle sur 3. Cela signifie que la boucle sera itérée 3 fois pour générer une boîte de message. Si nous ne connaissons pas la fin de la boucle, nous pouvons compter les éléments d’un ensemble pour la déterminer. Observez l’exemple suivant :
Dim items As New List(Of String)
items.Add("Pizza")
items.Add("Sandwich")
items.Add("Milk")
items.Add("Eggs")
For i = 0 To (items.Count - 1)
MessageBox.Show(items(i))
Next
Dans cet exemple, nous avons créé un ensemble et nous l’avons renseigné. Nous avons ensuite indiqué à la boucle de s’itérer autant de fois qu’il y a d’éléments dans l’ensemble. Nous commençons la boucle à 0 et la terminons à moins 1. Dans ce cas, il est essentiel de comprendre l’indexation. Il s’agit tout simplement d’identifier un point de départ (généralement, 0 ou 1). Dans ce type d’ensemble, le premier élément de la liste commence à 0 au lieu de 1.
Thomas Fitzgerald est consultant senior en mise en œuvre, spécialisé dans l’automatisation et la gestion des données dans Inventor. Il a conseillé des services d’ingénierie de toutes tailles dans de nombreuses entreprises. Fort de plus de 20 ans d’expérience dans les domaines de la conception mécanique et de la fabrication avec de nombreux produits Autodesk, il est également formateur certifié Autodesk et administrateur certifié de systèmes Microsoft.
Vous souhaitez en savoir plus ? Téléchargez la documentation de cours complète.