Les logiciels CAO propriétaires ou mieux encore les suites de logiciels comme CATIA, Inventor, Solidworks, NX, Creo, … sont merveilleux tant au point de vue des outils proposés que par leur ergonomie.
Seulement beaucoup d’entre vous sont face au problème évident du prix des licences souvent hors de porté du particulier ou de la très petite entreprise.
Dans cet article, voici une solution alternative qui répondra peut-être à vos attentes si vous êtes dans ce cas là.
FreeCAD est-il une alternative sérieuse à la CAO propriétaire ?
Dans cet article, je vais vous parler d’un sujet qui m’est personnellement un peu nouveau car il s’agit pour moi de pratiquer la CAO, non pas sur Catia, mais sur FreeCAD en vous montrant comment automatiser le tracé du jeu de nervures d’une aile de modèle réduit.
Création automatisée d’un jeu de nervures d’une aile d’avion RC sur FreeCAD.
La vidéo de l’article
FreeCAD, C’est quoi ?
FreeCad est un logiciel de CAO Open source, multiplateforme et gratuit.
Tout est dit… ou presque !
La CAO c’est la Conception Assistée par Ordinateur. Il faut comprendre là dedans qu’il ne s’agit pas seulement de dessin, même 3D mais bien de conception mécanique avec des cotes et des liens entre toutes sortes de dimensions.
On est loin de la liberté totale d’un logiciel Polygonal. Ici c’est du sérieux : )
En effet, FreeCAD n’a pas trop à rougir de ses grands frères propriétaires et très onéreux.
Non, FreeCAD propose toutes les fonctionnalités que l’on pourrait attendre d’un logiciel de CAO à commencer par la conception solide et dans une certaine mesure surfacique, le tout paramétrique et associatif.
L’interface est très claire et présente des ateliers pour retrouver les principaux outils.
Ah oui, paramétrique, cela veut dire que si l’on souhaite revenir sur la définition d’un objet (ses dimensions) alors il suffit de l’éditer et de changer une valeur. Cela modifie instantanément la forme du 3D.
Ça n’a l’air de rien mais dans certains logiciels du marché comme Rhino, il faut détruire les éléments et les reconstruire ou bien les déformer ! (pas de modification paramétrique)
Associative, cela veut dire que les éléments sont liés les uns aux autres par un lien de parenté.
Un élément existe car il est créé à partir d’un ou plusieurs autres éléments (ses parents).
On fera par exemple un arrondi au coin d’un cube mais l’arrondi n’existe que parce que le cube existe. Ainsi, si l’on modifie le cube (par ses paramètres), l’arrondi sera recalculé et redessiné au bon endroit.
En plus de ça, FreeCAD offre la possibilité de créer des formules qui lient les paramètres et même de piloter tout ça avec un tableur comme Excel !
Oui, toutes ces choses dans un logiciel gratuit comme dans les très couteux Catia, Créo, Inventor ou Solidworks !
Présenté comme ça c’est merveilleux. Mais il y a un mais.
Oui, FreeCAD n’est pas un clone de ce qui existe mais plutôt une plateforme vivante qui vous permet de créer vos propres outils de modélisation.
FreeCAD, c’est à la base un peu tout nu mais il existe de très nombreux addons (gratuits bien sûr) élaborés par la communauté permettant de rendre bien des services dans tous les domaines comme le bâtiment, le calcul FEM (et même fluide avec OpenFoam), l’électronique, le naval, l’aéromodélisme, etc…
Toutes ces choses ont été élaborées à partir de script écrits en langage Python.
FreeCAD permet avec ce langage, d’atteindre tout ce qui est présent dans le logiciel, c’est à dire des fonction natives construites sur le cœur du moteur Nurbs (OCCT). Plus que des outils de modélisation, on peut même créer des ateliers complets avec des boites de dialogue complètes.
Merveilleux non ?
Merveilleux certes mais il faut surtout du temps pour se faire ses outils.
J’ai suivi ici cette démarche pour produire les nervures mais j’aurais pu aller beaucoup plus loin en couplant les script entre eux et en produisant une interface graphique. Si cela vous tente, n’hésitez pas à copier le code, continuer le travail et partager sur mon blog ou celui de loïc.
Production du profil à partir d’un fichier de points
Sur Airfoil tools, on trouve tout ce qu’il faut.
Il suffit de prendre les coordonnées du profil en *.dat et de l’enregistrer sur son répertoire de travail.
Un fichier/importer nous propose directement de produire un profil à partir du fichier … Cool !
C’est un peu facettisé mais on peut le transformer en Bspline. Il faut penser à préciser profil ouvert pour éviter une déformation vers le bord de fuite.
En examinant le fichier de points on voit qu’au bord de fuite, il y a une petite ouverture.
Il suffit de la fermer avec un bout de ligne.
Une multi-sélection de la ligne et du profil permet de les joindre en cliquant une fois sur le bouton Upgrade.
En refaisant un Upgrade sur cet objet, on produit une face
Obtention de l’aile
Pour faire une aile, il nous faut maintenant agrandir un peu ce profil millimétrique.
Oui, il mesure un mm de long car le fichier de points va de 0.000 à 1.000 sans unité.
A l’import dans le logiciel de dessin, l’unité par défaut est le millimètre donc le profil est de cette taille.
Dans les paramètres de cet objet, je modifie le « Placement » en X de -0.25 pour que l’origine du modèle soit à 25% de la corde (au foyer profil).
Plutôt que de modifier cet objet pour l’agrandir, j’ai préféré le cloner et modifier le clone.
C’est facile, sur le clone, il y a directement des paramètres pour l’échelle.
On multiplie par 150 en X et en Y et nous voilà avec un profil d’emplanture de 150 mm.
Encore un clone de ce grand profil d’emplanture et un « Placement » en Z à 500mm puis un Scale de 0.5 en X et Y et nous voilà avec un profil de saumon moitié plus petit (pour faire une aile effilée).
Je m’arrête là dans les modifs mais on pourrait facilement mettre du dièdre et du vrillage négatif.
Avec ces deux surfaces en forme de profil on peut maintenant faire un solide « Loft » (raccord entre deux sections).
Ci-dessous voici le code Python pour faire ce travail à partir de la face millimétrique.
J’aurais aimé faire un script à partir de l’import du fichier de points mais je n’ai pas réussi à faire un automatisme pour produire la petite ligne au bord de fuite du profil.
J’ai bien trouvé pour récupérer les extrémités d’une ligne mais pas d’une spline… Dommage.
# -*- coding: utf-8 -*-
# Macro Begin: D:\Documents\Sujets\FreeCAD\Aile\De nervure mm a aile.FCMacro +++++++++++++++++++++++++++++++++++++++++++++++++
import FreeCAD
#import DraftTools
import Draft
import Part
FreeCAD.ActiveDocument.recompute()
Obj_Doc = FreeCAD.getDocument("Aile_2")
#récupération de la face millimétrique et déplacement de 25% de la corde
Obj_Profil = Obj_Doc.getObject("Face")
Position_Nerv_Ampl = App.Placement(App.Vector(-0.25,0,0),App.Rotation(App.Vector(0,0,1),0))
Obj_Profil.Placement = Position_Nerv_Ampl
#Création du profil emplanture
Obj_Nervure_amplanture = Draft.clone(Obj_Profil)
Obj_Nervure_amplanture.Label="Nervure amplanture"
Obj_Nervure_amplanture.Scale = (150.00, 150.00, 1.00)
Obj_Nervure_saumon = Draft.clone(Obj_Nervure_amplanture)
Obj_Nervure_saumon.Label = "Nervure saumon"
FreeCAD.ActiveDocument.recompute()
#Création du profil saumon
Position_Nerv_Saumon = App.Placement(App.Vector(-0.25,0,500),App.Rotation(App.Vector(0,0,1),0))
Obj_Nervure_saumon.Placement = Position_Nerv_Saumon
Obj_Nervure_saumon.Scale = (0.50, 0.50, 1.00)
FreeCAD.ActiveDocument.recompute()
# Création de l'aile solide pleine
#Gui.activateWorkbench("PartWorkbench")
from FreeCAD import Base
Obj_loft = Obj_Doc.addObject('Part::Loft','Loft')
Obj_loft.Sections=[Obj_Nervure_amplanture, Obj_Nervure_saumon, ]
Obj_loft.Solid=True
Obj_loft.Ruled=False
Obj_loft.Closed=False
FreeCAD.ActiveDocument.recompute()
# Macro End: D:\Documents\Sujets\FreeCAD\Aile\De nervure mm a aile.FCMacro +++++++++++++++++++++++++++++++++++++++++++++++++
Obtention d’une nervure
Cette aile est pleine et massive. Pour les spécialiste de la mousse, c’est parfait mais pour les anciens comme moi ce n’est pas suffisant… On aime la structure.
Nous allons alors saucissonner tout ça à plusieurs endroits.
L’intersection du solide avec une face plane sera parfait.
Il suffit de créer des surfaces planes et de demander une intersection avec le solide.
On obtient alors un profil (une surface) de la bonne taille selon la position en envergure.
Cette surface peut alors être épaissie avec une extrusion solide.
Cela est très bien mais imaginons qu’il faille faire l’opération 30 fois à la main !
C’est là qu’intervient encore une fois le code Python pour faire le travaille répétitif à notre place.
C’est ici plus intéressant que dans le programme précédent car cela serait vraiment fastidieux.
# -*- coding: utf-8 -*-
# Macro Begin: D:\Documents\Sujets\FreeCAD\Aile\nervure.FCMacro +++++++++++++++++++++++++++++++++++++++++++++++++
import FreeCAD
import DraftTools
import Draft
import Part
FreeCAD.ActiveDocument.recompute()
Obj_Doc = FreeCAD.activeDocument
DemiEnvergure = 500
NbNervure = 10
Pas = DemiEnvergure / NbNervure
# Création des surfaces planes
for Pos in range(0,DemiEnvergure + Pas ,Pas):
print (Pos)
pl = FreeCAD.Placement()
pl.Rotation.Q = (0.0,0.0,0.0,1.0)
pl.Base = FreeCAD.Vector(-50.0,-33.0,0.0)
Plan_coupe = Draft.makeRectangle(length=186.0,height=81.0,placement=pl,face=False,support=None)
Plan_coupe.Placement = App.Placement(App.Vector(-50,-33,Pos),App.Rotation(App.Vector(0,0,1),0))
Plan_coupe.Label = "Rectangle_"+str(Pos)
App.ActiveDocument.recompute()
Obj_aileSolide = FreeCAD.ActiveDocument.getObjectsByLabel("AileSolide")
#Création des intersection et épaississement pour l'obtention des nervures
for Pos in range(0,DemiEnvergure + Pas ,Pas):
Obj_clone_aile = Draft.clone(Obj_aileSolide)
Obj_clone_aile.Label = "AileSolide_"+str(Pos)
Obj_Plan_coupe = FreeCAD.ActiveDocument.getObjectsByLabel("Rectangle_"+str(Pos))
Obj_aileSol = FreeCAD.ActiveDocument.getObjectsByLabel("AileSolide_"+str(Pos))
FreeCAD.ActiveDocument.addObject("Part::MultiCommon","Common"+str(Pos))
Obj_intersect = FreeCAD.ActiveDocument.getObject("Common"+str(Pos))
Obj_intersect.Shapes = [Obj_aileSol[0],Obj_Plan_coupe[0],]
Obj_intersect.Label = ("Intersection_"+str(Pos))
Gui.ActiveDocument.ActiveObject.Visibility = False
FreeCAD.ActiveDocument.recompute()
Obj_intersection = FreeCAD.ActiveDocument.getObjectsByLabel("Intersection_"+str(Pos))
FreeCAD.ActiveDocument.addObject("Part::Extrusion","Nervure"+str(Pos))
Obj_Nervure = FreeCAD.ActiveDocument.getObject("Nervure"+str(Pos))
Obj_Nervure.Base = Obj_intersection[0]
Obj_Nervure.Dir = (0,0,2)
Obj_Nervure.Solid = (True)
Obj_Nervure.TaperAngle = (0)
Obj_Nervure.Label = 'Nervure_pos='+str(Pos)+"mm"
FreeCAD.ActiveDocument.recompute()
# Macro End: D:\Documents\Sujets\FreeCAD\Aile\nervure.FCMacro +++++++++++++++++++++++++++++++++++++++++++++++++
Ca mouline un peu et nous voilà avec toutes nos nervures en 3D.
Production du plan 2D
Encore une fois, FreeCAD propose des outils de projection de 3D dans un plan 2D comme les autres logiciels de CAO et ici encore, le script va nous permettre de produire les différentes vues et de les positionner dans le calque.
Ci dessous, le code pour faire le travail
# -*- coding: utf-8 -*-
# Macro Begin: D:\Documents\Sujets\FreeCAD\Aile\mise en plan.FCMacro +++++++++++++++++++++++++++++++++++++++++++++++++
import FreeCAD
import Drawing
# Paramètres utilisateur
PositionX_Initiale = 40
PositionY_Initiale = 70
EcartX_entre_vues=35
EcartY_entre_vues=0
Nombre_Nervure = 11
# Création du Calque
App.activeDocument().addObject('Drawing::FeaturePage','Page')
App.activeDocument().Page.Template = 'C:/Program Files/FreeCAD 0.16/data/Mod/Drawing/Templates/A3_Landscape_ISO7200.svg'
App.activeDocument().recompute()
Gui.activeDocument().getObject('Page').show()
# Création des vues
for NumVue in range(0,Nombre_Nervure,1):
# Ajout d'une vue
App.activeDocument().addObject('Drawing::FeatureViewPart','Vue_'+str(NumVue))
Obj_vue = App.ActiveDocument.getObject('Vue_'+str(NumVue))
Obj_ObjetProjete = App.ActiveDocument.getObjectsByLabel("Nervure_pos="+str(NumVue*50)+"mm")
Obj_vue.Source = Obj_ObjetProjete[0]
Obj_vue.Direction = (0.000000e+000,0.000000e+000,1.000000e+000)
Obj_vue.X = PositionX_Initiale + NumVue*EcartX_entre_vues
Obj_vue.Y = PositionY_Initiale + NumVue*EcartY_entre_vues
Obj_vue.Scale = 1.000000e+000
Obj_vue.Rotation = 90
App.activeDocument().Page.addObject(Obj_vue)
# Ajout d'une annotation
Obj_Annotation = App.activeDocument().addObject('Drawing::FeatureViewAnnotation','Annotation_'+str(NumVue))
Obj_Annotation.X = PositionX_Initiale + NumVue*EcartX_entre_vues + 10.0
Obj_Annotation.Y = PositionY_Initiale + NumVue*EcartY_entre_vues + 100.0
Obj_Annotation.Scale = 7.0
Obj_Annotation.Rotation = 90
Obj_Annotation.Label = "Annotation Nervure pos "+str(NumVue*50)+"mm"
Obj_Annotation.Text = [unicode("Position "+str(NumVue*50)+"mm", 'utf-8'),]
App.activeDocument().Page.addObject(Obj_Annotation)
# Renseignement du cartouche
FreeCAD.activeDocument().getObject("Page").EditableTexts = [unicode('Vincent', 'utf-8'),unicode('Nervures Aile RC', 'utf-8'),unicode('', 'utf-8'),unicode('', 'utf-8'),unicode('www.Apprendre-la-CAO.com', 'utf-8'),unicode('', 'utf-8'),unicode('', 'utf-8'),unicode('', 'utf-8'),unicode('A3', 'utf-8'),unicode('1 / 1', 'utf-8'),unicode('Ech 1', 'utf-8'),unicode('PN', 'utf-8'),unicode('DN', 'utf-8'),unicode('25/01/2018', 'utf-8'),unicode('REV A', 'utf-8'),]
App.ActiveDocument.recompute()
# Macro End: D:\Documents\Sujets\FreeCAD\Aile\mise en plan.FCMacro +++++++++++++++++++++++++++++++++++++++++++++++++
Conclusion
FreeCAD nous offre la possibilité de produire nos propres outils de modélisation afin de produire des 3D comme ici ces éléments de structure d’aile.
Moyennant un peu de temps pour la création des programmes (seul ou en communauté) il est tout à fait envisageable de produire un véritable logiciel de modélisation orienté aéronautique.
Imaginez-vous fasse à une interface dans laquelle vous pourriez indiquer l’envergure, le nom des profils, le nombre de nervure, le dièdre, le vrillage, …. et la machine dessine tout !
Et pourquoi pas pointer vers un fichier Excel ou mieux, Libre Office ? Oui, c’est possible mais c’est une autre histoire.
No responses yet