Tutorial KinematicController/fr

Introduction
Ce tutoriel décrit comment générer un contrôleur cinématique simple à utiliser avec les assemblages créés avec l'atelier Assembly3 à partir de quelques lignes de code Python.

N'importe quel éditeur de texte peut être utilisé pour coder. Mon choix se porte sur Atom, mais l'éditeur intégré de FreeCAD fonctionne bien aussi.

Les exemples de code suivants peuvent être copiés et collés dans un fichier texte vide, puis enregistrés sous le nom de votre choix comme fichier ou.

Structure de base
La structure de base consiste en une fonction et un commutateur pour vérifier si la macro est utilisée comme un conteneur pour les classes, les méthodes, etc. ou si elle est exécutée seule. Seule la deuxième option lancera la fonction. Cette fonction est vide pour le moment.

Trouver les contraintes pilotes
Les contraintes pilotes sont des objets dans un document FreeCAD. Elles doivent être marquées pour pouvoir être trouvées.

Pour ce contrôleur, le suffixe doit être attaché au label d'une contrainte pilote. Il peut être séparé par un ou  pour plus de clarté, car nous ne vérifierons que si le label se termine par.

Une fonction qui reçoit un objet document et renvoie une liste de contraintes pilotes (les noms dans ce cas) fera l'affaire.

La fonction charge le document actif dans la variable, puis appelle la fonction  et lui transmet le contenu de. La liste retournée est chargée dans qui est ensuite vérifiée pour contenir au moins un élément. Si c'est le cas, la liste est finalement imprimée dans la Vue rapport.

La macro jusqu'à présent...

Panneau de contrôle
Le panneau de contrôle est construit à partir de widgets Qt, une fenêtre principale contenant plusieurs widgets d'entrée/sortie.

Chaque widget doit être importé avant de pouvoir être utilisé, mais ils peuvent être importés en un seul ensemble. La ligne d'importation est placée en haut du fichier.

Fenêtre principale
Pour la fenêtre principale, la ligne d'importation ressemble à ceci :

La fenêtre principale appelée est un objet de classe instancié à partir du widget.

Elle possède deux méthodes init. initialise le nouvel objet de la classe, gère les arguments entrants et lance qui gère tous les widgets de la fenêtre principale.

Pour lancer un seul panneau de commande, une instance, appelée, de cette classe sera créée avec (l'objet document) et  (le premier de la liste des contraintes de conduite) transférés à cette instance. Enfin, la méthode de la classe ouvre la fenêtre de dialogue.

Pour gérer plus d'un contrôleur (driver), nous devons vérifier la liste des contrôleurs et créer une instance pour chaque élément de la liste et transférer l'élément en cours.

Ces lignes remplacent la commande dans la branche else de la fonction.

Remarque : La collecte d'une nous permet de lancer tous les panneaux en même temps. (Je ne peux pas encore expliquer ce comportement...)

L'exécution de la macro affichera une fenêtre de dialogue vide et propre, en attente de widgets :



La macro jusqu'à présent...

Paramètres de réglage
Il est maintenant temps de remplir la méthode :

représente la contrainte pilote et stocke un mot clé pour son type. Ce dernier est utilisé pour choisir la propriété correcte avec chaque contrainte.

Méthode getDriverType
Pour une utilisation future, nous avons besoin du type de pilote (Angle, Distance, Longueur) et donc une méthode doit être définie :

Cette méthode vérifie si le type de la contrainte donnée peut être trouvé dans l'une des listes, et renvoie le type de dimension qui doit être contrôlé.

On suppose que dans le document cinématique, le pilote est marqué correctement et fonctionne s'il était édité manuellement. Dans ce cas, il n'est pas nécessaire de filtrer les contraintes géométriques telles que Colinear ou PointsCoincidence (mais ce serait l'endroit pour le faire...).

Propriétés de la fenêtre
La taille de la fenêtre est définie par ses dimensions minimale et maximale. En utilisant les mêmes valeurs, on obtient une taille fixe.

Le titre indique le nom du pilote et précise s'il s'agit d'un angle, d'une distance ou d'une longueur. Enfin, on demande à la fenêtre de rester au dessus de toutes les fenêtres.

Paramètres de réglage supplémentaires
L'étape suivante consiste à extraire la valeur actuelle du pilote et à définir les valeurs de début et de fin par défaut en fonction du type de pilote.

Une distance ne peut pas être négative et exactement nulle, ce qui rend le solveur perplexe. La valeur de départ est donc fixée à 0,001. Les angles acceptent des valeurs négatives et obtiennent des valeurs symétriques. (Si les longueurs acceptent des valeurs négatives reste à prouver finalement...)

Le suffixe de l'unité doit être conservé pour renvoyer la valeur à la propriété de la contrainte à la fin. Les distances et les longueurs nécessitent des valeurs avec des unités.

Le traitement des unités et l'affichage des valeurs sous forme de chaînes de caractères dans plusieurs widgets nécessitent de convertir assez souvent les chiffres en chaînes de caractères et inversement.

Pour compléter les paramètres, nous définissons un nombre de pas par défaut qui doivent être calculés lorsque le mouvement est automatisé et si le commutateur est réglé sur, une photo sera prise à chaque pas du mouvement.

Intitulés
Maintenant, trois intitulés sont ajoutés pour afficher le début, la fin et la valeur en cours.

Tout d'abord, la classe doit être importée, c'est-à-dire que la liste d'importation doit être étendue comme ceci :

Dans la méthode, nous insérons :

Le placement est fait avec la méthode héritée. Dans ce cas, la description d'un rectangle est utilisée (position X, position Y, largeur, hauteur).

Les première et troisième lignes pourraient être combinées, mais cela n'est pas recommandé pour des raisons de clarté :

L'exécution de la macro avec un document d'assemblage cinématique créerait une fenêtre de dialogue comme celle-ci :



La macro jusqu'à présent...

Curseur
Pour changer la valeur courante à n'importe quel nombre entre la valeur de début et la valeur de fin, un widget de curseur conviendrait.

Tout d'abord, la classe doit être importée, c'est-à-dire que la liste d'importation doit être étendue comme ceci :

De retour dans la méthode et juste après la section des intitulés (labels), nous insérons :

Le bouton du curseur est placé avec la méthode. Sa valeur doit être calculée à partir de la valeur actuelle et d'un rapport de progression. Le rapport doit être calculé à chaque fois qu'une valeur de début ou de fin est modifiée. Nous insérons donc une autre méthode après la méthode.

Travailler avec un ratio au lieu de modifier les valeurs min et max du curseur présente l'avantage d'une résolution plus fine pour les petites valeurs.

Et après celle-ci, vient une autre méthode définissant ce qu'il faut faire lorsque la position du curseur ou la valeur du curseur change. La méthode est appelée par la méthode  qui fournit également la valeur du curseur comme argument.

Il recalcule la valeur courante à partir de la position du curseur, réécrit le texte de l'intitulé et modifie la propriété de la contrainte en fonction du type de curseur.

L'exécution de la commande lance le solveur pour réorganiser les pièces de l'assemblage avec la valeur modifiée.

La fenêtre de dialogue avec le curseur doit ressembler à ceci et est prête à contrôler un mouvement :



We can start a dialog window for any opened document, they won't interfere with each other.

Text entry fields
To set the start and end value we use a line edit widget.

First the class must be imported i.e. the import list has to be extended like this:

Back in the method and between the labels and the slider sections we insert:

The entry fields display the default start and end values. They are not complete until we add the methods to deal with altered entries. This will be done by the methods and  that are inserted between the  and the  methods.

Both convert the received string value to a floating point number and change either or  and the corresponding label accordingly. After that the slider value is updated.

The dialog window with text entry fields should look like this and is ready to change the range of a motion:



And the macro so far...

Motion
To get the assembly in motion we need:
 * Buttons to trigger motion in the desired direction.
 * An input field to alter the number of steps for faster or smoother motions.
 * A check box to indicate if we want to shoot a sequence of images.

Forward and Backward buttons
To move the assembly parts automatically we need two buttons to trigger the motions, one towards the start position and one towards the end position. These two and a close button will use a widget.

Small assemblies compute a bit too fast and show jumps instead of a smooth motion. To slow it down we use the method of the  module which has to be imported first.

Another import and another widget:

Back in the method we insert the buttons after the slider section:

The methods dealing with pressed buttons are, , and. They are inserted after the method.

The method invokes the inherited method  which just closes the dialog window and thereby ends the macro.

Both and  count the steps that are left to go to reach the wanted position and calculate the length of a step according to the number of steps. For now we go with the default number of 10 steps.

Each round on the while loop increases/decreases the current value and updates the slider values which triggers in the background (see Slider paragraph). After a pause to let the computer provide another updated 3D view, counting down the steps left to go finishes the loop.

With no steps left the slider is set to the first/last slider position, just in case if a rounding error had occurred.

The dialog window with buttons should look like this and can now move the assembly by 10 steps towards the wanted start/end position:



And the macro so far...

Number of steps
The default setting is to get a quick impression if the assembly is moving as expected without wasting too much computing time.

If the parts jump rather than move smoothly, or if drivers based on angles tend to cause trouble when the difference between two angles is too large, then both can be fixed by increasing the number of steps.

And so another line edit widget is used to alter the number steps (placed after the existing line edit widgets):

The related method just fills the parameter  with the entered value. It is inserted after the method.

The dialog window able to change the number of steps should look like this:



Image sequence
When the motion of our assembly meets our expectations, we can take a picture of each step. The resulting sequence of images can be used to create a short gif animation.

To implement this functionality we need a widget, and a directory to store the images.

One more import and widget:

Back in the method we insert the check box after the slider section:

The method synchronises the parameter  and the display of the check mark.

To define the output parameters we use the method :

First the image path has to be adapted to your OS; the last part is the image name without current number and file tag. This must be done manually for now.

Then follow file tag to finish the image name, image height and width, and how the background should be filled ( (3D view background),, , or ).

To always have a 3 digit number leading zeros have to be prefixed to the counter parameter.

Finally the scripted version of the command Std ViewScreenShot is used to take a picture based on the mentioned parameters.

Still no pictures taken!?! No problem, as this method doesn't get called yet, and so we need to insert a call in the while loop of and. Right after we insert this line:

Now the macro should be ready to control an assembly and to take pictures for an animated gif.

The final version of the dialog window:



And finally the whole macro

Don't forget to set the path in the output method!

Some imperfections

 * The order of the image sequence is reversed as we use the variable steps_left which is counted down.
 * The image directory and the image name are hard-coded.
 * Multiple Controllers are not synchronised.