// 1 // 1 2 3 4 5 6 7 8 9 0 //34567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 /*************************************************************************************************** Etude du train épicycloïdal en chevrons Rousset Jean-Pierre mai 2019 ---------------------------------------------------------------------------------------------------- -------------------------------------------- Le but est d'étudier le logiciel "OpenSCAD". -------------------------------------------- Un engrenage simple est l'assemblage de deux pignons dentés. Sa fonction est double : - transmettre une puissance mécanique de rotation entre deux arbres non-coaxiaux, - adapter la puissance en vue de modifier la vitesse de rotation ou de modifier le couple à transmettre. L'arbre d'entrée (ou "menant")est l'arbre moteur du mécanisme et l'arbre de sortie (ou "mené") est l'arbre relié au récepteur comme les roues d'une voiture. Composé d'un ensemble de pignons, un train épicycloïdal est un engrenage élaboré assez fascinant pour moi car c'est un modèle cinématique (mathématique) d'une grande simplicité mais qui semble l'être beaucoup moins technologiquement. Il est utilisé dans bien des domaines mais c'est pour l'automobile qu'il m'attire le plus. Les constructeurs y ont tous recours pour, en particulier, les différentiels en sortie de boïte afin d'éviter que les roues motrices patinent, glissent en force dans les virages, la roue intérieure roulant moins vite que celle extérieure. ---------------------------------------------------------------------------------------------------- Un train épicycloïdal présente un grand intérêt à plusieurs titres. C'est un mécanisme : - réducteur ou multiplicateur utilisé pour les perceuses et les moulins à café par exemple, - répartiteur utilisé pour les différentiels d'automobile (train épicycloïdal sphérique), - distributeur utilisé dans les boεtes de vitesses automatiques d'automobile, dans les boîtes de transmission du rotor principal et celle du rotor arrière sur un hélicoptère. C'est un ensemble mécanique 3 axes qui se compose : - d'une "couronne" à denture intérieure, - d'un pignon central appelé "planétaire", - d'un ou plusieurs pignons appelés "satellites" engrénés sur la couromme et le planétaire liés à un porte satéllite qui tourne sur lui-même à une vitesse dépendant linéairement de celle du planétaire et celle du porte-satellites. +-----------------------------------------------------------------------+ | Sa caractéristique : la vitesse de rotation d'un axe est LINEAIREMENT | | ------------------ dépendante de la vitesse de rotation des deux | | autres. | | | | Le nombre de satellites n'influent en rien sur les rapports de | |transmission. | +-----------------------------------------------------------------------+ Le planétaire, le porte-satellite et la couronne sont cocentriques. Une petite et modeste théorie mathématique élémentaire sur les engrenages : --------------------------------------------------------------------------- Soit donc un premier engrenage formé de deux pignons dentés extérieurs : - un pignon nommé "Planétaire" qui possède "Zp" dents et qui tourne à la vitesse angulaire "Wp" tours/minute, - un pignon nommé "Satellite" qui possède "Zs" dents et qui tourne à la vitesse angulaire "Ws" tours/minute. On a une première relation du rapport de transmission : Ws Zp - ------ = ----- On en déduit : Ws = - Wp * Zp / Zs (1) Wp Zs Soit maintenant un deuxième engrenage formé de deux pignons dentés intérieurs : - un pignon nommé "Couronne" qui possède "Zc" dents et qui tourne à la vitesse angulaire "Wc" tours/minute - un pignon nommé "Satellite" qui possède "Zs" dents et qui tourne à la vitesse angulaire "Ws" tours/minute On a une deuxième relation du rapport de transmission : Wc Zs ------ = ----- On en déduit : Wc = Ws * Zs / Zc (2) Ws Zc La vitesse de rotation (vitesse angulaire) est une fonction linéaire du temps donc proportinnelle à l'angle de rotation. Or, dans les formules (1) et (2), le temps intervient de part et d'autre des signes "=". On en déduit donc les deux relations avec des angles élémentaires par unité de temps : - de la relation (1), on en déduit : As = - Ap * Zp / Zs (3) - de la relation (2), on en déduit : Ac = As * Zs / Zc (4) L'association de ces deux engrenages forme un train épicycloidal dont on va déduire les formules de calcul en notant que les satellites sont solidaires d'un porte-satellites qui tourne à la vitesse angulaire de "Wps" tours/minutes soit un angle élémentaire de "Aps" par unité de temps. L'angle élémentaire de rotation des satellites va donc dépendre des angles élémentaires du planétaire et du porte-satellite. On a donc la formule à partir de (3) et (4) de l'angle élémentaire de rotation de la couronne : => Ac = (-Ap * Zp / Zs + Aps * Zps / Zs * 2) * Zs / Zc Je n'ai pas trouvé la justification mathématique du facteur 2 multiplicatif pour le porte- satellites !... Je suppose néanmoins que cela vient du fait que le nombre de dents de la couronne doit être égal au nombre de dents du planétaire plus 2 FOIS le nombre de dents des satellites. L'angle de rotation élémentaire de la couronne se calcule donc en fonction : - de l'angle élémentaire de rotation du porte-satellites, - de l'angle élémentaire de rotation du planétaire. Les cercles appelés "primitifs" des pignons d'un engrenage sont les cercles tangents sans glisser représentatifs des pignons. Le module "m" est caractéristique d'une roue dentée dont la valeur dépend des contraintes de fabrication. Si "Z" est le nombre de dents d'un pignon, son diamètre primitif "D" est donné par la formule : D = m*Z indispensable pour déterminer les rayons des pignons. Comme le diamètre est proportionnel au nombre de dents de par le module, on pourra donc indifférement utiliser les rapports de rayons ou de dents. Le module n'est pas spécifique aux trains épicycloïdaux, mais aux engrenages en général. Il correspond à la dimension STANDARDISEE d'une dent d'engrènement. Un module "1" donne un entraxe de 3,14 millimètres entre 2 dents. Un module "2" donnera ainsi un entraxe de 6.28 millimètres. Pour que les pignons s'engrènent correctement, ils doivent avoir le MEME module. ---------------------------------------------------------------------------------------------------- Par des donnée de départ, le train est personnalisable mais à condition que le nombre de satellites soit un commun diviseur du nombre de dents de tous les pignons !... Désolé, je n'ai pas réussi à trouver une formulation mathématique qui traite tous les cas de figure. ---------------------------------------------------------------------------------------------------- Le but du présent module modélise : - un train épicycloïdal à chevrons pour qu'il garde toute sa cohésion quand on le fait fonctionner. Il est donc indémontable mais pour ce faire, il convient de modéliser la couronne en deux demi-couronnes qui seront visées entre elles lors du montage. - un support muni de petites manivelles permet de le faire fonctionner. La méthode : on modélise la demi-épaisseur du train comme si c'était un train à dentures ---------- hélicoïdale puis on lui adjoint son symétrique (mirror()) avant de générer le fichier ".stl" pour impression. Note : Pour faciliter au mieux la compréhension, les expressions de positionnement et de ---- longueur ne sont pas contracté et garde la logique d'empilement. ***************************************************************************************************/ //include //================================================================================================= //*** Les données globales de départ : pour éviter d'avoir à "trifouiller dans le source !.... // -------------------------------- fn = 50 ; // résolution pour le rendu ajuste_pignons = 0.25 ; // ajustement (!!!!!!!!) // Ces drapeaux "generation_nnn..." servent à isoler les composants du train en vue de la // création d'un fichier ".stl" pour chacun d'eux par l'option "exporter". generation_support = true ; generation_train = true ; generation_eclate = false ; //*** traitement de la pignonnerie : generation_planetaire_directe = true ; generation_planetaire_symetrique = true ; generation_satellites_directe = true ; generation_satellites_symetrique = true ; generation_couronne_directe = true ; generation_couronne_symetrique = true ; //*** Traitement des accessoires generation_axe_planetaire = true ; generation_manivelle_planetaire = true ; generation_axe_porte_satellites = true ; generation_manivelle_porte_satellites = true ; generation_support_socle = true ; generation_support_jambage_direct = true ; // côté planétaire generation_support_jambage_symetrique = true ; // côté porte-satellites generation_rondelles_satellites = true ; generation_rondelles_porte_satellites = true ; // ------------------------------------------------------------------------------------------------- /* ATTENTION : contrainte --> règle du "haricot" --------- Pour que les satellites puissent s'engrener en même temps avec la couronne et le planétaire, le nombre "nu" donné par la formule ci-dessous doit être ENTIER : Zc Zp nu = ----- + ------ Nsat Nsat ====> le programme affiche la valeur de "nu" et contrôle l'exécution ( la règle est nécessaire mais pas suffisante !... ) -------------------------------------------------------- */ // --------------------------------------------------------------------------------------- //* Ajouter le "/" en début de ligne pour afficher le train 5 satellites 100 mm de diamètre // --------------------------------------------------------------------------------------- module_pignons = 2.12 ; epaisseur_train = 15.00 ; angle_vrillage_dentures = 10.00 ; // parmètre "twist" exprimé degrés en // dans linear_extrude : // c'est l'angle de la denture // hélicoïdale pour la première // moitié du pignon, négatif pour la // deuxième. nombre_dents_planetaire = 15 ; nombre_satellites = 5 ; nombre_dents_satellites = 10 ; angle_correction_vrillage_satellites = 5.00 ; angle_correction_vrillage_couronne = -5.50 ; rayon_axe_planetaire = 5.00 ; rayon_axe_satellites = 3.00 ; epaisseur_support = 5.00 ; epaisseur_rondelles = 3.00 ; epaisseur_clavette = 2.00 ; largeur_jeu = 0.50 ; diametre_vis = 4.00 ; // pour les vis de fixation diametre_taraudage = 2.00 ; diametre_tete = 6.00 ; // pour l'évidement des têtes de vis epaisseur_tete = 3.00 ; //----------------------------------- ------- //*/ // --------------------------------------------------------------------------------------- /* Ajouter le "/" en début de ligne pour afficher le train 8 satellites 200 mm de diamètre // --------------------------------------------------------------------------------------- module_pignons = 2.12 ; epaisseur_train = 50.00 ; angle_vrillage_dentures = 10.00 ; // parmètre "twist" exprimé degrés en // dans linear_extrude : // c'est l'angle de la denture // hélicoïdale pour la première // moitié du pignon, négatif pour la // deuxième. nombre_dents_planetaire = 80 ; nombre_satellites = 8 ; nombre_dents_satellites = 40 ; angle_correction_vrillage_satellites = 1.00 ; angle_correction_vrillage_couronne = -2.70 ; rayon_axe_planetaire = 8.00 ; rayon_axe_satellites = 3.50 ; epaisseur_support = 10.00 ; epaisseur_rondelles = 3.00 ; epaisseur_clavette = 3.00 ; largeur_jeu = 0.50 ; diametre_vis = 4.00 ; // pour les vis de fixation diametre_taraudage = 2.00 ; diametre_tete = 6.00 ; // pour l'évidement des têtes de vis epaisseur_tete = 3.00 ; //----------------------------------- ------- //*/ //*** On en déduit les variables suivantes : if (generation_eclate) { generation_support = true ; generation_train = true ; } rayon_primitif_planetaire = nombre_dents_planetaire * module_pignons / 2 ; angle_pas_planetaire = 360 / nombre_dents_planetaire ; rayon_primitif_satellites = nombre_dents_satellites * module_pignons / 2 ; angle_pas_satellites = 360 / nombre_dents_satellites ; nombre_dents_couronne = nombre_dents_planetaire + 2*nombre_dents_satellites ; rayon_primitif_couronne = nombre_dents_couronne * module_pignons / 2 ; angle_pas_couronne = 360 / nombre_dents_couronne ; rayon_porte_satellites = rayon_primitif_planetaire + rayon_primitif_satellites ; rayon_axe_porte_satellites = rayon_axe_planetaire + 0.5*epaisseur_support; rayon_saillies_creux = rayon_primitif_planetaire*tan((360/nombre_dents_planetaire)/4) ; rayon_exterieur_couronne = round(rayon_primitif_couronne + 3*epaisseur_support) ; //*** Position du socle en dessous de la couronne : x_socle = rayon_exterieur_couronne + 6*epaisseur_support ; unite_distance_eclate = epaisseur_train * rayon_exterieur_couronne / 100 ; //-------------------------------------------------------------------------------------------------- //* - En mettant le premier "/", on place les instructions suivantes en commentaire // - En l'enlevant, on exécute les instructions echo (" ") ; echo ("module_pignons = " , module_pignons, "
") ; echo ("épaisseur_train = " , epaisseur_train, "") ; echo ("angle_vrillage_dentures = " , angle_vrillage_dentures, "") ; echo (" ") ; echo ("nombre_dents_planetaire = " , nombre_dents_planetaire, "") ; echo ("rayon_primitif_planétaire = " , rayon_primitif_planetaire, "") ; echo ("angle_pas_planetaire = " , angle_pas_planetaire, "") ; echo (" ") ; echo ("nombre_satellites = " , nombre_satellites, "") ; echo ("nombre_dents_satellites = " , nombre_dents_satellites, "") ; echo ("rayon_primitif_satellites = " , rayon_primitif_satellites, "") ; echo ("rayon_porte_satellites = " , rayon_porte_satellites, "") ; echo (" ") ; echo ("nombre_dents_couronne = " , nombre_dents_couronne, "") ; echo ("rayon_primitif_couronne = " , rayon_primitif_couronne, "") ; echo (" ") ; echo ("rayon_extérieur_couronne = " , rayon_exterieur_couronne, "") ; echo (" ") ; /*------------------------------------------------------------------------------------------------*/ //*** On construit le train en 2D centré sur l'origine des axes : // ----------------------------------------------------------- if (generation_train) train() ; //*** On construit le support du train : // ---------------------------------- if (generation_support) support() ; //*** On modélise les rondelles des manivelles : // ---------------------------------- rondelles_satellites() ; /*================================================================================================== ==================================================================================================== Les modules du traitement du train ==================================================================================================== ==================================================================================================*/ module train() { nu = (nombre_dents_couronne + nombre_dents_planetaire) / nombre_satellites ; echo ("
==========================
" , "nu (règle du haricot) = ", nu , "
==========================") ; if ( (nu - floor(nu)) == 0) { planetaire () ; satellites () ; couronne () ; } } //================================================================================================== // -------------------------------------------------------------- //*** On génère le planétaire avec son axe centrés sur l'axe des Z : //------------------------------------------------------------------ module planetaire() { rotate([0, 0, angle_pas_planetaire/2]) { color("OrangeRed") difference() { union() { // 1°)- Première moitié du planétaire : // ------------------------------------ if (generation_planetaire_directe) { difference() { translate([ 0, 0, 0]) pignon( ajuste_pignons , nombre_dents_planetaire , epaisseur_train/2, angle_vrillage_dentures ) ; // On marque la position du planetaire à 0° : // ------------------------------------------ translate([rayon_primitif_planetaire - 2*rayon_saillies_creux , 0 , epaisseur_train /2 ]) sphere (r=1) ; } } // 2°)- Deuxième moitié du planétaire : elle est le symétrique de la première // ---------------------------------- par rapport au plan XOY if (generation_planetaire_symetrique) { union() { mirror ([0,0,1]) { translate([ 0, 0, 0]) pignon( ajuste_pignons , nombre_dents_planetaire , epaisseur_train/2, angle_vrillage_dentures ) ; } // Génération de la rondelle conique de centrage : // ----------------------------------------------- translate([ 0, 0, -epaisseur_train/2 - epaisseur_rondelles]) // => la rondelle conique cylinder( r1=rayon_axe_planetaire*1.3 , r2=1.5*rayon_axe_planetaire , h=epaisseur_rondelles ) ; } } } if (generation_planetaire_directe || generation_planetaire_symetrique) { // 3°)- Perçage du pignon pour le passage de son axe : // --------------------------------------------------- translate ([0,0,-3*epaisseur_train]) cylinder(h=6*epaisseur_train, r=rayon_axe_planetaire) ; // 4°)- Aménagement de la fente à clavette (pour solidariser le pignon avec son axe) : // ----------------------------------------------------------------------------------- translate([ 0, -epaisseur_clavette/2, -2*epaisseur_train]) cube([ rayon_axe_planetaire + epaisseur_clavette , epaisseur_clavette , 3*epaisseur_train]) ; } } } // fin du rotate([0, 0, angle_pas_planetaire/2]) } // Fin du module planetaire() //================================================================================================== // ------------------------------------------------------------------------------------- //*** On génère les satellites centrés sur le cercle du porte-satellites : // Les satellites sont percés pour le passage de leurs axes solidaires du porte satellite. module satellites() { for (n = [1 : nombre_satellites]) { // ----------------------------------------------------------------------------------------- //*** On génère un ou tous les satellites portés par le porte-satellites centré sur l'axe des // des cotes Z : // On rappelle que le centre des satellites tournent le long du cercle dont le rayon est // égal au rayon du planétaire plus le rayon du satellite. // ----------------------------------------------------------------------------------------- // Les satellites sont portés par le porte-satellite. Pour l'engrenement, l'angle de // décalage dépend du nombre de dents et de celui du porte-satellite. angle_porte_satellites = (n-1) * 360 / nombre_satellites ; angle_calage = (n-1) * angle_porte_satellites * rayon_primitif_planetaire / rayon_primitif_satellites ; x = rayon_porte_satellites * cos(angle_porte_satellites) ; y = rayon_porte_satellites * sin(angle_porte_satellites) ; angle_correction = angle_porte_satellites % angle_pas_satellites ; color("Aquamarine") difference() { union() { // 1°)- Génération de la première moitié du satellite : // ---------------------------------------------------- if (generation_satellites_directe) { difference() { translate([x, y, 0]) rotate([ 0, 0, angle_calage + 180 + angle_correction]) pignon( ajuste_pignons , nombre_dents_satellites , epaisseur_train/2-0.5, -angle_vrillage_dentures -angle_correction_vrillage_satellites ) ; // On marque la position du satellite à 0° : // ----------------------------------------- translate([ x + rayon_primitif_satellites - 2*rayon_saillies_creux , y , epaisseur_train /2 ]) sphere (r=1) ; } } // 2°)- Génération de la deuxième moitié du satellite : elle est symétrique de la // -------------------------------------------------- première par rapport au plan XOY if (generation_satellites_symetrique) { mirror ([0,0,1]) { translate([x, y, 0]) rotate([ 0, 0, angle_calage + 180 + angle_correction]) pignon( ajuste_pignons , nombre_dents_satellites , epaisseur_train/2-0.5, -angle_vrillage_dentures -angle_correction_vrillage_satellites ) ; } } } // 3°)- Perçage du pignon pour le passage de son axe : // --------------------------------------------------- if (generation_satellites_directe || generation_satellites_symetrique) { translate ([x, y, -1.5*epaisseur_train]) cylinder(h=3*epaisseur_train, r=rayon_axe_satellites) ; } } } } //================================================================================================== // ---------------------------------------------------------------------------------------------- //*** On génère la couronne créant le pignon à denture externe que l'on retranche du cylindre de // rayon "rayon_exterieur_couronne" qui fait 1,5 fois de rayon des saillies. // ---------------------------------------------------------------------------------------------- module couronne() { angle_calage = angle_pas_couronne ; if ( (nombre_dents_planetaire%2 != 0) && (nombre_dents_couronne%2 != 0) ) { angle_calage = angle_calage / 2 ; } color("DarkGoldenrod") rotate([0,0,0]) { if (generation_couronne_directe) { difference() { // 1°)- Génération de la première moitié de la couronne : // ------------------------------------------------------ // - génération du cylindre de la couronne : translate ([0, 0, 0]) rotate([0,0,angle_calage ]) cylinder(h=epaisseur_train/2, r=rayon_exterieur_couronne) ; // - Découpage du cylindre de la couronne par le pignon : translate([ 0, 0, -0.1]) rotate([0,0,angle_calage ]) pignon( -ajuste_pignons , nombre_dents_couronne , epaisseur_train/2+0.2, -angle_vrillage_dentures -angle_correction_vrillage_couronne ) ; // - Perçage de la couronne pour 8 vis rayon = (rayon_exterieur_couronne + rayon_primitif_couronne + rayon_saillies_creux)/2 ; for (angle = [0 : 360/8 : 359]) { x = rayon * cos(angle) ; y = rayon * sin(angle) ; translate([ x, y, -epaisseur_train]) cylinder(h=3*epaisseur_train, r=diametre_vis/2) ; // - Perçage de la couronne à 0° pour la tête de vis translate([ x, y, epaisseur_train/2 - epaisseur_tete]) cylinder(h=epaisseur_train, r2=diametre_tete/2, r1=diametre_vis/2) ; } // - Marquage la position de la couronne à 0° translate([rayon_primitif_couronne +(rayon_exterieur_couronne-rayon_primitif_couronne)*0.20 , 0 , epaisseur_train /2 ]) sphere (r=1) ; } } if (generation_couronne_symetrique) { mirror([0,0,1]) { difference() { // 2°)- Deuxième moitié de la couronne : // -------------------------------------- // - Génération du cylindre de la couronne translate ([0, 0, 0]) rotate([0,0,angle_calage ]) cylinder(h=epaisseur_train/2, r=rayon_exterieur_couronne) ; // - Découpage du cylindre de la couronne translate([ 0, 0, -0.1]) rotate([0,0,angle_calage ]) pignon( -ajuste_pignons , nombre_dents_couronne , epaisseur_train/2+0.2, -angle_vrillage_dentures -angle_correction_vrillage_couronne ) ; // - Perçage de la couronne pour 8 vis : rayon = (rayon_exterieur_couronne + rayon_primitif_couronne + rayon_saillies_creux)/2 ; for (angle = [0 : 360/8 : 359]) { x = rayon * cos(angle) ; y = rayon * sin(angle) ; translate([ x, y, -epaisseur_train]) cylinder(h=3*epaisseur_train, r=diametre_taraudage/2) ; } } } } } } /*================================================================================================== ==================================================================================================== Le module de traitement d'un pignon ==================================================================================================== ==================================================================================================== Il dessine un pignon avec des saillies et des creux en arc de cercle. Pour construire le pignon, on génère d'abord la base qui se composée dans l'ordre : 1°)- du cercle primitif plein, 2°)- de l'ensemble des arcs pleins des saillies que l'on ajoute au cercle primitif, 3°)- de l'ensemble des arcs pleins des creux que l'on décale d'un angle 2*alpha sous lequel on voir un arc de cercle du creux et que l'on retranche au 2°. */ module pignon( ajuste, nombre_dents, epaisseur, angle_vrillage ) { //*** On travaille sur le pignon positionné au départ c'est à dire que la première dent // est centrée sur l'axe des abscisses : Dp = nombre_dents*module_pignons ; // diamètre priitif du pignon Rp = Dp/2 ; // rayon pas = 3.1415927*Dp/nombre_dents ; // pas du pignon c'est la longueur de l'arc sur // le cercle primitif pour une dent alpha = (360/nombre_dents)/4 ; // angle de vue d'un rayon d'une saillie ou d'un creux Rsc = Rp/cos(alpha) ; // rayon du cercle des centres des saillies et des creux rsc = Rp*tan(alpha) ; // rayon des cercles des saillies et des creux linear_extrude( height=epaisseur, twist=angle_vrillage) difference() { union() { circle(r=Rp, $fn=fn) ; // on dessine le cercle primitif cercles(-ajuste) ; // et les saillies } rotate(2*alpha) cercles(+ajuste) ; // on y retranche les creux } //*** module intégré au module "pignon" (portée locale) qui dessine les cercles // directeurs des dents et des entre-dents : module cercles(ajuste) { for (i = [1:nombre_dents]) rotate((i-1)*(alpha*4)) translate([Rsc,0,0]) circle(r=rsc+ajuste, $fn=fn) ; } } /*================================================================================================== ==================================================================================================== Le module du traitement du support ==================================================================================================== ==================================================================================================== */ module support() { //================================================================================================== echo ( " On est bien dans support " , "
") ; support_socle() ; support_jambage() ; support_planetaire_axe_manivelle() ; support_porte_satellites_axe_manivelle() ; } //================================================================================================== // ---------------------------------------------------------------------------------------------- //*** On génère ici le socle de soutien du train // ---------------------------------------------------------------------------------------------- module support_socle() { if (generation_support_socle) { trans = (generation_eclate) ? [-5*unite_distance_eclate, 0, 0] : [0, 0, 0] ; color("Burlywood") translate(trans) difference() //====== { translate([ -x_socle , -(rayon_exterieur_couronne + 2*epaisseur_train) , -4*epaisseur_train]) cube([ 2*epaisseur_support , 2*rayon_exterieur_couronne + 4*epaisseur_train , 7*epaisseur_train + epaisseur_support]) ; // ATTENTION : la position en Z des vis dépend de la position de la jambe // --------- // 1°)- côté planétaire.: // ----------------- color("Brown") translate([ -x_socle - epaisseur_support // => le passage de la vis 1 , -0.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , epaisseur_train/2 + epaisseur_rondelles + largeur_jeu - 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_vis/2 , r2=diametre_vis/2 , h=5*epaisseur_support ) ; color("Maroon") translate([ -x_socle - epaisseur_support // => l'évidement de la tete de vis 1 , -0.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , epaisseur_train/2 + epaisseur_rondelles + largeur_jeu - 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_tete/2 , r2=diametre_tete/2 , h=epaisseur_support + epaisseur_tete ) ; color("Turquoise") translate([ -x_socle - epaisseur_support // => le passage de la vis 2 , 1.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , epaisseur_train/2 + epaisseur_rondelles + largeur_jeu - 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_vis/2 , r2=diametre_vis/2 , h=5*epaisseur_support ) ; color("Maroon") translate([ -x_socle - epaisseur_support // => l'évidement de la tete de vis 2 , 1.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , epaisseur_train/2 + epaisseur_rondelles + largeur_jeu - 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_tete/2 , r2=diametre_tete/2 , h=epaisseur_support + epaisseur_tete ) ; // 2°)- côté porte-satellites.: // ----------------------- color("Turquoise") translate([ -x_socle - epaisseur_support // => le passage de la vis 1 , -1.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , - epaisseur_train/2 - epaisseur_rondelles - largeur_jeu - epaisseur_support - largeur_jeu - epaisseur_rondelles + 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_vis/2 , r2=diametre_vis/2 , h=5*epaisseur_support ) ; color("Brown") translate([ -x_socle - epaisseur_support // => l'évidement de la tete de vis 1 , -1.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , - epaisseur_train/2 - epaisseur_rondelles - largeur_jeu - epaisseur_support - largeur_jeu - epaisseur_rondelles + 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_tete/2 , r2=diametre_tete/2 , h=epaisseur_support + epaisseur_tete ) ; color("Maroon") translate([ -x_socle - epaisseur_support // => le passage de la vis 2 , 0.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , - epaisseur_train/2 - epaisseur_rondelles - largeur_jeu - epaisseur_support - largeur_jeu - epaisseur_rondelles + 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_vis/2 , r2=diametre_vis/2 , h=5*epaisseur_support ) ; // color("Brown") translate([ -x_socle - epaisseur_support // => l'évidement de la tete de vis 2 , 0.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , - epaisseur_train/2 - epaisseur_rondelles - largeur_jeu - epaisseur_support - largeur_jeu - epaisseur_rondelles + 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_tete/2 , r2=diametre_tete/2 , h=epaisseur_support + epaisseur_tete ) ; } } } //================================================================================================== // ---------------------------------------------------------------------------------------------- //*** On génère ici le jambage de soutien du train // ---------------------------------------------------------------------------------------------- module support_jambage() { if (generation_support_jambage_direct) //*** => c'est la jambe côté planétaire { trans = (generation_eclate) ? [0, 0, 3*unite_distance_eclate] : [0, 0, 0] ; color("LightSkyBlue") translate(trans) translate ([0,0, epaisseur_train/2 + largeur_jeu ]) // pour ajuster la position de la jambe difference() ///======= { union() { // 1°) - Génération de la rondelle conique de centrage : // ----------------------------------------------- translate([ 0, 0, 0]) cylinder( r1=rayon_axe_planetaire*1.3 , r2=1.5*rayon_axe_planetaire , h=epaisseur_rondelles ) ; // 2°) - Génération de la jambe pleine à partir d'un cylindre et de deux petits cubes : // ------------------------------------------------------------------------------ hull() { translate([ 0, 0, epaisseur_rondelles]) // cylindre du haut cylinder( r1=rayon_axe_planetaire*2 , r2=rayon_axe_planetaire*2 , h=epaisseur_support ) ; translate([ -x_socle + 2*epaisseur_support , 0.5*rayon_primitif_couronne , epaisseur_rondelles]) cube([ epaisseur_support , epaisseur_support , epaisseur_support]) ; translate([ -x_socle + 2*epaisseur_support , -(0.5*rayon_primitif_couronne + epaisseur_support) , epaisseur_rondelles]) cube([ epaisseur_support , epaisseur_support , epaisseur_support]) ; } // 3°) - Génération de le pied de la jambe : // ----------------------------------- // Il est formé de deux languettes qui s'encastrent éventuellement avec celle du // pied côté porte-satellites. // Elles sont tournées vers l'intérieur du support pour une plus grande facilité // d'impression. // color("red") translate([ -x_socle + 2*epaisseur_support // => 1ère languette , -0.25*rayon_primitif_couronne - 0.5*epaisseur_support , epaisseur_rondelles - 3*epaisseur_support]) cube([ epaisseur_support , 0.25*rayon_primitif_couronne + 0.5*epaisseur_support , 3*epaisseur_support]) ; color("green") translate([ -x_socle + 2*epaisseur_support // => 2ème languette , 0.25*rayon_primitif_couronne + 0.5*epaisseur_support , epaisseur_rondelles - 3*epaisseur_support]) cube([ epaisseur_support , 0.25*rayon_primitif_couronne + 0.5*epaisseur_support , 3*epaisseur_support]) ; } // 4°) - Génération du passage des vis pour le taraudage : // ------------------------------------------------- // color("Bisque") translate([ -x_socle - epaisseur_support // => taraudage 1ère languette , -0.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , epaisseur_rondelles - 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_taraudage/2 , r2=diametre_taraudage/2 , h=5*epaisseur_support ) ; color("Turquoise") translate([ -x_socle - epaisseur_support // => taraudage 2ème languette , 1.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , epaisseur_rondelles - 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_taraudage/2 , r2=diametre_taraudage/2 , h=5*epaisseur_support ) ; // 5°) - Génération du passage de l'axe : // -------------------------------- translate([ 0 // => le passage de l'axe , 0 , -0.5*epaisseur_support ]) rotate([ 0, 0, 0]) cylinder( r1=rayon_axe_planetaire , r2=rayon_axe_planetaire , h=2.5*epaisseur_support ) ; // 6°)- Aménagement de la fente pour le passage de la clavette : // ------------------------------------------------------------- translate([ 0, -epaisseur_clavette/2-0.2, -0.5*epaisseur_support]) cube([ rayon_axe_planetaire + epaisseur_clavette , epaisseur_clavette + 0.4 , 2.5*epaisseur_support]) ; // 7°) - Génération de l'évidement de la jambe à partir de trois cylindres : // ------------------------------------------------------------------- hull() { translate([ - 4*rayon_axe_planetaire // => le cylindre du haut , 0 , -0.5*epaisseur_support ]) rotate([ 0, 0, 0]) cylinder( r1=rayon_axe_planetaire , r2=rayon_axe_planetaire , h=2.5*epaisseur_support ) ; translate([ -(x_socle-2*epaisseur_support)/4*3 // => le cymlindre du bas 1 , -0.25*rayon_primitif_couronne , -0.5*epaisseur_support ]) rotate([ 0, 0, 0]) cylinder( r1=epaisseur_support , r2=epaisseur_support , h=2.5*epaisseur_support ) ; translate([ -(x_socle-2*epaisseur_support)/4*3 // => le cymlindre du bas 2 , 0.25*rayon_primitif_couronne , -0.5*epaisseur_support ]) rotate([ 0, 0, 0]) cylinder( r1=epaisseur_support , r2=epaisseur_support , h=2.5*epaisseur_support ) ; } } } if (generation_support_jambage_symetrique) //*** => c'est la jambe côté porte-satellites { trans = (generation_eclate) ? [0, 0, -10*unite_distance_eclate] : [0, 0, 0] ; color("LightSkyBlue") translate(trans) translate ([0,0, -( epaisseur_train/2 + epaisseur_rondelles + 2*largeur_jeu + epaisseur_support) ]) difference() //====== { union() { // 1°) - Génération de la rondelle conique de centrage : // ----------------------------------------------- translate([ 0, 0, -epaisseur_rondelles]) cylinder( r1=1.5*rayon_axe_porte_satellites + 2.0 , r2=rayon_axe_porte_satellites*1.3 + 2.0 , h=epaisseur_rondelles ) ; // 2°) - Génération de la jambe pleine à partir d'un cylindre et de deux petits cubes : // ------------------------------------------------------------------------------ // color("LightSkyBlue") hull() { translate([ 0, 0, -(epaisseur_rondelles + epaisseur_support)]) // cylindre du haut cylinder( r1=rayon_axe_porte_satellites*2 , r2=rayon_axe_porte_satellites*2 , h=epaisseur_support ) ; translate([ -x_socle + 2*epaisseur_support , 0.5*rayon_primitif_couronne , -(epaisseur_rondelles + epaisseur_support)]) cube([ epaisseur_support , epaisseur_support , epaisseur_support]) ; translate([ -x_socle + 2*epaisseur_support , -(0.5*rayon_primitif_couronne + epaisseur_support) , -(epaisseur_rondelles + epaisseur_support)]) cube([ epaisseur_support , epaisseur_support , epaisseur_support ]) ; } // 3°) - Génération de le pied de la jambe : // ----------------------------------- // Il est formé de deux languettes qui s'encastrent éventuellement avec celle du // pied côté planétaire. // Elle est tourné vers l'intérieur du support pour une plus grande facilité // d'impression. // color("red") translate([ -x_socle + 2*epaisseur_support // => 1ère languette , -0.5*rayon_primitif_couronne - epaisseur_support , -epaisseur_rondelles]) cube([ epaisseur_support , 0.25*rayon_primitif_couronne + 0.5*epaisseur_support , 3*epaisseur_support ]) ; color("green") translate([ -x_socle + 2*epaisseur_support // => 2ème languette , 0 , -epaisseur_rondelles]) cube([ epaisseur_support , 0.25*rayon_primitif_couronne + 0.5*epaisseur_support , 3*epaisseur_support ]) ; } // 4°) - Génération du passage des vis pour le taraudage : // ------------------------------------------------- // color("Brown") translate([ -x_socle - epaisseur_support // => le taraudage de la vis 1ère languette , -1.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , -epaisseur_rondelles + 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_taraudage/2 , r2=diametre_taraudage/2 , h=5*epaisseur_support ) ; color("Turquoise") translate([ -x_socle - epaisseur_support // => le passage de la vis 2ème languette , 0.5*(0.25*rayon_primitif_couronne + 0.5*epaisseur_support) , -epaisseur_rondelles + 1.5*epaisseur_support ]) rotate([ 0, 90, 0]) cylinder( r1=diametre_taraudage/2 , r2=diametre_taraudage/2 , h=5*epaisseur_support ) ; // 5°) - Génération du passage de l'axe : // -------------------------------- translate([ 0 // => le passage de l'axe , 0 , -2*epaisseur_support ]) rotate([ 0, 0, 0]) cylinder( r1=rayon_axe_porte_satellites + 2.0 , r2=rayon_axe_porte_satellites + 2.0 , h=2.5*epaisseur_support ) ; // 6°) - Génération de l'évidement de la jambe à partir de trois cylindres : // ------------------------------------------------------------------- hull() { translate([ - 2*rayon_axe_porte_satellites // => le cylindre du haut - 2*rayon_axe_planetaire , 0 , -(epaisseur_rondelles + 2*epaisseur_support) ]) rotate([ 0, 0, 0]) cylinder( r1=rayon_axe_porte_satellites , r2=rayon_axe_porte_satellites , h=2.5*epaisseur_support ) ; translate([ -(x_socle-2*epaisseur_support)/4*3 // => le cymlindre du bas 1 , -0.25*rayon_primitif_couronne , -(epaisseur_rondelles + 2*epaisseur_support) ]) rotate([ 0, 0, 0]) cylinder( r1=epaisseur_support , r2=epaisseur_support , h=2.5*epaisseur_support ) ; translate([ -(x_socle-2*epaisseur_support)/4*3 // => le cymlindre du bas 2 , 0.25*rayon_primitif_couronne , -(epaisseur_rondelles + 2*epaisseur_support) ]) rotate([ 0, 0, 0]) cylinder( r1=epaisseur_support , r2=epaisseur_support , h=2.5*epaisseur_support ) ; } } } } //================================================================================================== // ---------------------------------------------------------------------------------------------- //*** On génère ici l'axe du planétaire et la manivelle maintenue avec une vis rondelle. // ---------------------------------------------------------------------------------------------- module support_planetaire_axe_manivelle() { if (generation_axe_planetaire) { trans = (generation_eclate) ? [0, 0, 12*unite_distance_eclate] : [0, 0, 0] ; color("Tomato") translate(trans) difference() { union() { // 1°) - Génération de l'axe du planétaire : // ----------------------------------- translate ([ 0 , 0 , epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support ]) rotate([ 180, 0, 0 ]) // => pour pouvoir facilement jouer sur la longueur cylinder( r1=rayon_axe_planetaire , r2=rayon_axe_planetaire , h= epaisseur_train/2 // + largeur_jeu + epaisseur_rondelles // côté planétaire + 3*epaisseur_support // + 0.5*epaisseur_train // + epaisseur_rondelles // + largeur_jeu // côté porte-satellites + 5*epaisseur_support // + largeur_jeu // + epaisseur_support // + largeur_jeu ) ; // // 2°) - Génération de la clavette prisonnière solidaire de l'axe : // ---------------------------------------------------------- // On ne se préoccupe pas de son angle de rotation translate([ 0, epaisseur_clavette/2, epaisseur_train/2]) rotate([180, 0, 0]) cube([ rayon_axe_planetaire + epaisseur_clavette/2 , epaisseur_clavette , epaisseur_train]) ; // 3°) - Génération du carré de solidarisation de la manivelle : // ------------------------------------------------------- translate([ 0 , 0 , epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support + epaisseur_support/2 // à cause du center=true ]) cube ([ rayon_axe_planetaire*1.25 , rayon_axe_planetaire*1.25 , epaisseur_support + largeur_jeu] , center=true) ; // 4°) - Génération de la bague de calage : // ---------------------------------- translate ([ 0 , 0 , epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support ]) rotate([ 180, 0, 0 ]) // => pour pouvoir facilement jouer sur la longueur cylinder( r1=rayon_axe_planetaire*1.2 , r2=rayon_axe_planetaire*1.2 , h=epaisseur_train - epaisseur_support ) ; } // 5°)- Perçage de l'axe pour de taraudage la vis de fixation côté planétaire : // ----------------------------------------------------------------------- translate([ 0, 0, epaisseur_train + epaisseur_support]) cylinder ( r1=diametre_taraudage/2, r2=diametre_taraudage/2 , h=6*epaisseur_support ) ; // 6°)- Perçage de l'axe pour de taraudage la vis de fixation côté porte-satellites : // ----------------------------------------------------------------------------- translate([ 0, 0, -4*epaisseur_train]) cylinder ( r1=diametre_taraudage/2, r2=diametre_taraudage/2 , h=6*epaisseur_support ) ; } } if (generation_manivelle_planetaire) { trans = (generation_eclate) ? [0, 0, 14*unite_distance_eclate] : [0, 0, 0] ; color("LightGreen") translate(trans) difference() { union() { // 1°) - Génération du bras de la manivelle : // ------------------------------------ hull() { translate([ 0, 0, epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support ]) cylinder ( r1=rayon_axe_planetaire + epaisseur_support/2 , r2=rayon_axe_planetaire + epaisseur_support/2 , h=epaisseur_support ) ; translate([ -x_socle/2, 0, epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support]) cylinder ( r1=rayon_axe_planetaire , r2=rayon_axe_planetaire , h=epaisseur_support ) ; } // 2°) - Génération de la poignée de la manivelle (elle est fixe) : // ---------------------------------------------------------- translate([ -x_socle/2, 0, epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support]) cylinder ( r1=epaisseur_support*0.75 , r2=epaisseur_support*0.75 , h=4*epaisseur_support ) ; } // 3°) - Génération de l'évidement carré de solidération de la manivelle : // ----------------------------------------------------------------- translate([ 0 , 0 , epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 3*epaisseur_support + epaisseur_support/2 // à cause du center=true ]) cube ([ rayon_axe_planetaire*1.25 , rayon_axe_planetaire*1.25 , epaisseur_support] , center=true) ; } } } //================================================================================================== // ---------------------------------------------------------------------------------------------- //*** On génère ici le porte-satellites. // ---------------------------------------------------------------------------------------------- module support_porte_satellites_axe_manivelle() { if (generation_axe_porte_satellites) { trans = (generation_eclate) ? [0, 0, -4*unite_distance_eclate] : [0, 0, 0] ; color("Khaki") translate(trans) difference() //===== { //*** Génération des branches de support des satéllites : // --------------------------------------------------- union() { for(n = [1 : nombre_satellites]) { angle_porte_satellites = (n-1) * 360 / nombre_satellites ; angle_calage = (n-1) * angle_porte_satellites * rayon_primitif_planetaire / rayon_primitif_satellites ; x = rayon_porte_satellites * cos(angle_porte_satellites) ; y = rayon_porte_satellites * sin(angle_porte_satellites) ; angle_correction = angle_porte_satellites % angle_pas_satellites ; // 1°) - Génération de la branche n°n du porte-satellites : // -------------------------------------------------- hull() { translate([x, y, -(epaisseur_train/2 + epaisseur_rondelles + largeur_jeu)]) rotate([ 0, 180, 0]) cylinder ( r1=rayon_axe_satellites + epaisseur_support , r2=rayon_axe_satellites + epaisseur_support , h=epaisseur_support ) ; translate([ 0, 0, -(epaisseur_train/2 + epaisseur_rondelles + largeur_jeu)]) rotate([ 0, 180, 0]) cylinder ( r1=rayon_axe_porte_satellites , r2=rayon_axe_porte_satellites , h=epaisseur_support ) ; } // 2°) - Génération de l'axe du satellites n°n : // --------------------------------------- translate([x, y, - (epaisseur_train/2 + epaisseur_rondelles + largeur_jeu) + epaisseur_train + epaisseur_rondelles + largeur_jeu]) rotate([ 0, 180, 0]) cylinder ( r1=rayon_axe_satellites , r2=rayon_axe_satellites , h= epaisseur_train + epaisseur_rondelles + largeur_jeu ) ; } // 4°) - Génération de l'axe du porte-satellites qui tourne autour de l'axe du // --------------------------------------- planétaire : translate([0,0, - epaisseur_train/2 - epaisseur_rondelles - largeur_jeu] ) rotate([ 0, 180, 0]) cylinder ( r1=rayon_axe_porte_satellites + 2.0 , r2=rayon_axe_porte_satellites + 2.0 , h= 5*epaisseur_support ) ; // 5°) - Génération de cube de solidarisation de la manivelle : // ------------------------------------------------------ translate([ 0, 0, -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 5*epaisseur_support + epaisseur_support/2 // à cause du center sur le cube )] ) rotate([ 0, 0, 0]) cube ( [ 1.75*rayon_axe_porte_satellites , 1.75*rayon_axe_porte_satellites , epaisseur_support + largeur_jeu ], center=true ) ; } // 6°)- Perçage de l'axe pour de taraudage la vis de fixation : // ------------------------------------------------------- translate([ 0, 0, - epaisseur_train/2]) rotate([ 0, 180, 0]) cylinder ( r1=rayon_axe_planetaire , r2=rayon_axe_planetaire , h=10*epaisseur_support) ; } } if (generation_manivelle_porte_satellites) { trans = (generation_eclate) ? [0, 0, -12*unite_distance_eclate] : [0, 0, 0] ; color("Brown") translate(trans) difference() //======= { union() { // 1°) - Génération du bras de la manivelle : // ------------------------------------ hull() { translate([ 0, 0, -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 6*epaisseur_support ) ]) cylinder ( r1= rayon_axe_planetaire + epaisseur_support + epaisseur_rondelles , r2= rayon_axe_planetaire + epaisseur_support + epaisseur_rondelles , h=epaisseur_support ) ; translate([ 0, x_socle/2 , -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 6*epaisseur_support ) ]) cylinder ( r1=rayon_axe_planetaire , r2=rayon_axe_planetaire , h=epaisseur_support ) ; } // 2°) - Génération de la poignée de la manivelle (elle est fixe) : // ---------------------------------------------------------- translate([ 0, x_socle/2, -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 6*epaisseur_support ) ]) rotate([ 0, 180, 0]) cylinder ( r1=epaisseur_support*0.75 , r2=epaisseur_support*0.75 , h=4*epaisseur_support ) ; } // 3°) - Génération de l'évidement carré de solidération de la manivelle : // ----------------------------------------------------------------- translate([ 0 ,0 , -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 6*epaisseur_support )]) cube ([ 1.75*rayon_axe_porte_satellites , 1.75*rayon_axe_porte_satellites , epaisseur_support + 10 ] , center=true) ; } } } //================================================================================================== // ---------------------------------------------------------------------------------------------- //*** On génère ici les rondelles de blocage de l'ensemble. // ---------------------------------------------------------------------------------------------- module rondelles_satellites() { if (generation_rondelles_satellites) { color("yellow") difference() //======= { translate([ 0, 0, ( epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 4*epaisseur_support + 0.25 )] ) rotate([ 0, 0, 0]) cylinder ( r1= rayon_axe_planetaire + epaisseur_support/3 , r2= rayon_axe_planetaire , h= epaisseur_support ) ; translate([ 0, 0, ( epaisseur_train/2 + largeur_jeu + epaisseur_rondelles + 4*epaisseur_support )] ) rotate([ 0, 0, 0]) cylinder ( r1= diametre_taraudage , r2= diametre_vis , h=epaisseur_support + 0.5); } } if (generation_rondelles_porte_satellites) { color("yellow") difference() //======= { translate([ 0, 0, -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 7*epaisseur_support - 0.25 )] ) rotate([ 0, 0, 0]) cylinder ( r2= rayon_axe_planetaire + epaisseur_support , r1= rayon_axe_planetaire + epaisseur_support/2 , h= epaisseur_support ) ; translate([ 0, 0, -( epaisseur_train/2 + epaisseur_rondelles + largeur_jeu + 7*epaisseur_support )] ) rotate([ 0, 0, 0]) cylinder ( r2= diametre_taraudage , r1= diametre_vis , h=epaisseur_support + 0.5); } } }