123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686 |
- include <math.scad>
- /*Certaines fonctions utilisées dans ce fichier
- sont définies dans le fichier math.scad.
- Notamment la développante de cercle et la fonction permettant
- de calculer son point d'intersection avec un cercle.
- Pour des détails et explications il faut donc regarder
- dans le fichier math.scad*/
- /**************ENGRENAGE DROIT**************
- **************DÉFINITIONS**************
- le cercle de pied, qui est le cercle passant par la base des dents ;
- le cercle de tête, qui passe par le sommet des dents ;
- le cercle de base, qui est celui qui sert à générer le profil des dents (les dents sont des développantes de ce cercle) ;
- le cercle primitif : les cercles primitifs des roues dentées d'un engrenage ont la même vitesse tangentielle ; ils passent à peu près au milieu des dents.
- **************NOTATIONS**************
- diamètre primitif => d
- diamètre de pied => df
- diamètre de tête => da
- diamètre de base => db
- angle de pression => alpha
- module => m
- pas (distance entre 2 dents sur le cercle primitif) => p
- saillie => ha
- creux => hf
- hauteur de dent => h
- nombre de dents => z
- largeur de la dent sur le cercle primitif => l
- angle d'une dent sur le cercle primitif => la
- **************RELATIONS**************
- d = m*z
- p = m*pi
- ha = m
- si m<=1.25 hf = 1.40*m
- sinon hf = 1.25*m
- si m<=1.25 h = 2.40*m
- sinon h = 2.25*m
- h = ha + hf <=> ha = h - hf <=> ha = 2.25m - 1.25m = m
- ha = m
- da = d + 2*ha = d + 2*m
- df = d - 2*hf = d -2.5*m
- db = d*cos(alpha)
- l = pi*m/2 = pi/2 * d/z = (pi * d)/(2 * z) = pi*r/z = p/2
- deport de denture
- calcul de la largeur d'une dent avec déport :
- http://www.sidermeca.com/ficheconseil.php?fiche=1
- /*************ATTENTION*************
- la différence entre le nombre de dents de 2 roues
- est limité dans certains cas
- si Za=13, Zbmax=16
- si Za=14, Zbmax=26
- si Za=15, Zbmax=45
- si Za=16, Zbmax=101
- si Za=17, Zbmax=sans limite
- de préférence choisir des nombres premiers entres eux
- */
- $fn = 200;
- /*FONCTION EXPERIMENTALE*/
- //function recherche_limite(limite = 6, etape = 0, x = 0, y = 0, angle = 0) =
- //limite == etape ? atan(x) :
- //etape%2 == 0 ? recherche_limite(limite = limite, etape = etape + 1, x = y + rad(angle), y = y, angle = angle) :
- //recherche_limite(limite = limite, etape = etape + 1, x = x, y = rad(atan(x)), angle = angle);
- function creux(m = 1) = m <= 1.25 ? 1.4*m : 1.25*m;
- module evider(diam_int = 15, diam_ext = 50, larg = 8, nbr = 6)
- {
- facteur = 1.7;
- offset(r = larg/facteur)
- {
- difference()
- {
- circle(d = diam_ext -0.1);
- union()
- {
- for(i = [0:nbr - 1])
- {
- rotate([0, 0, i*360/nbr])
- {square([diam_ext - larg/2, facteur*larg], center = true);}
- }
-
- difference()
- {
- circle(d = diam_ext);
- circle(d = diam_ext - 2*larg);
- }
- }
- }
- }
- }
- module dent_cremaillere_2D(m = 1, alpha = 20)
- {
- //hauteurs
- hf = creux(m);
- ha = m;
- h = hf + ha;
- //pas
- p = m*pi;
- //vecteurs
- /*calcul des points de la dents
- 1) Premier point [0, 0]
- En partant de l'origine, on monte jusqu'à y = h suivant un angle alpha. On notera l la longueur de la dent.
- On peut donc écrire :
- l*sin(alpha) = decalage_x
- l*cos(alpha) = h
- en faisant la première ligne divisé par la seconde on obtient :
- l*sin(alpha) / l*cos(alpha) = decalage_x / h
- Or l se simplifie et sin/cos = tan, on obtient donc :
- tan(alpha) = decalage_x / h
- et donc decalage_x = h*tan(alpha)
-
- 2) Deuxième point : [h*tan(alpha), h]
-
- Pour le troisième point il faut connaitre la largeur de la dent. Pour y = hf, la largeur de la dent vaut p/2, la largeur de la base est donc :
- largeur_base = hf*tan(alpha) + p/2 + hf*tan(alpha)
- <=> largeur_base = 2*hf*tan(alpha) + p/2
- 3) Troisième point : [largeur_base - h*tan(alpha), h]
- Le quatrième point lui est simplement la largeur de la dent avec y = 0
- 4) Quatrième point : [largeur_base, 0]
- */
- largeur_base = 2*hf*tan(alpha) + p/2;
- polygon([ [0, 0], [h*tan(alpha), h], [largeur_base - h*tan(alpha), h], [largeur_base, 0] ]);
- }
- module cremaillere_2D(z = 10, m = 1, alpha = 20, largeur = 10)
- {
- //hauteurs
- hf = creux(m);
- //pas
- p = m*pi;
- union()
- {
- //corps de la crémaillère
- translate([0, -largeur, 0])
- {square([p* (z - 1) + p/2 + 2*hf*tan(alpha), largeur]);}
- //dents de la crémaillère
- for(i=[0:z-1])
- {
- translate([p*i, 0, 0])
- {dent_cremaillere_2D(m, alpha);}
- }
- }
- }
- module cremaillere_3D(z = 10, m = 1, alpha = 20, largeur = 10, epaisseur = 3)
- {
- linear_extrude(epaisseur)
- {cremaillere_2D(z, m, alpha, largeur);}
- }
- module roue_dentee_2D(z = 40, m = 1, alpha = 20, deport = 0, evider = false)
- {
- //hauteurs
- hf = creux(m) - deport;
- ha = m + deport;
- //pas
- p = m*pi;
- //calcul des diamètres
- d = m * z;
- db = d * cos(alpha);
- df = d - 2*hf;
- da = d + 2*ha;
- //calcul de l'angle entre 2 dents
- angle_dent = 360 / z;
- //largeur de la dent sur le cercle primitif
- //l = pi*d/(2*z) + 2*deport*sin(alpha);
- l = p/2 + 2*deport*sin(alpha);
- //angle de la dent sur le cercle primitif
- la = degre(2*l/d);
- //paramètre d'intersection de la developpante avec le cercle primitif
- //Id = intersect(db/2, d/2); équivalent à :
- Id = intersect(db, d);
- Idx = developpante_x(db/2,Id);
- Idy = developpante_y(db/2,Id);
- //angle entre la base de la dent et l'intersection avec le cercle primitif
- angle = atan2(Idy, Idx);
- //angle de la dent à sa base
- angle_base = la + 2*angle;
- //paramètre d'intersection de la developpante avec le cercle de tête
- //Ida = intersect(db/2, da/2); équivalent à :
- Ida = intersect(db, da);
- //GENERATION DE LA DENT
- /*Lors d'un déport de denture trop prononcé les développantes de cercles se croisent donnant lieu à
- un "petit triangle" sur la pointe de la dent. Pour éviter ça il faut déterminer l'angle à ne pas dépasser.
- La développante de cercle ne devrait jamais croiser l'axe de symétrie de la dent.
- On en déduit donc que la droite passant par l'origine O et faisant un angle de "angle_base/2" avec l'axe x est la limite.
- On note I le point d'intersection de cette droite avec la développante de cercle et T un point du cercle de base (angle positif) tel que
- IT soit une tangente.
- CARACTÉRISTIQUES CONNUES DE LA FIGURE :
- 0) L'angle xOI est angle_base/2
- 1) L'angle IOT sera appelé alpha
- 2) L'angle xOT est le paramètre de la développante de cercle, on le notera a.
- 3) De part sa construction le triangle OIT est rectangle en T.
- 4) OT est un rayon du cercle de base, on notera sa longueur r
- 5) La longueur IT est proportionnelle à r et à l'angle xOT. Avec a en radiant on obtient : IT = ra
- 6) D'après le théorème de pythagore OI² = IT² + TO²
- 7) Dans un triangle rectangle : hypothénuse * cos(alpha) = coté adjacent
- DÉDUCTIONS :
- OI² = IT² + TO²
- OI² = r²a² + r² = r² * (1 + a²)
- OI = sqrt(r² * (1 + a²) )
- OI = r * sqrt(1 + a²)
- Or OI est l'hypoténuse on peut dont écrire :
- OI * cos(alpha) = r
- r * sqrt(1 + a²) * cos(alpha) = r
- sqrt(1 + a²) * cos(alpha) = 1
- cos(alpha) = 1 / sqrt(1 + a²)
- alpha = acos( 1 / sqrt(1 + a²) )
- Dans le cas où la developpante de cercle est tracé jusqu'au point I alors on a :
- a = angle_base/2 + alpha
- Le paramètre a ne doit donc pas dépasser cette valeur.
- */
-
- A = [ for(i=[0: ceil(Ida)])
- if( i < angle_base/2 + acos( sqrt( 1/(1 + rad(i) * rad(i)))) )
- [developpante_x(db/2,i), developpante_y(db/2,i)] ];
-
- Matrice_de_rotation = [ [cos(angle_base), -sin(angle_base)], [sin(angle_base), cos(angle_base)] ];
- //Pour continuer le polygone il faut parcourir les valeurs dans l'autre sens
- B = [ for(i=[floor(-Ida):0])
- if( i > -angle_base/2 - acos( sqrt( 1/(1 + rad(i) * rad(i)))) )
- Matrice_de_rotation*[developpante_x(db/2,i), developpante_y(db/2,i)] ];
-
- C = concat(A, B);
- difference()
- {
- union()
- {
- //pied de la dent
- circle(d=df);
- for(j = [0:1:z-1])
- {
- rotate([0, 0, j*angle_dent])
- {polygon(C);}
- }
- }
- if(evider)
- {evider(diam_int = 3*da/10, diam_ext = 9*da/10, larg = 1.2*da/10, nbr = 6);}
- }
- }
- module roue_dentee_3D(z = 20, m = 5, alpha = 20, epaisseur = 2, deport = 0, evider = false)
- {
- linear_extrude(epaisseur)
- {roue_dentee_2D(z,m,alpha, deport, evider);}
- }
- module roue_dentee_3D_globoide(z = 20, m = 5, alpha = 20, epaisseur = 2, deport = 0, evider = false)
- {
- /*pour créer une roue globoïde on coupe les dents de la roue avec un tore
- le rayon R du cercle qui engendre le tore par révolution peut être calculer en considérant
- que les extrémités d'une dent forment une corde de ce cercle.
- https://fr.wikipedia.org/wiki/Segment_circulaire
- l'angle theta peut être trouvé en traçant la bissectrice de cet angle,
- on obtient un triangle rectangle avec des cotés ayant pour longueur h et c/2.
- B angle beta
- |\
- h| \
- __|__\A
- c/2
- l'angle beta peut se calculer en utilisant la tangente :
- tan(beta) = (c/2)/h
- beta = atan(c/2h)
- Or le triangle ABO, avec O le centre du cercle est isocèle, et l'angle en 0 est theta/2
- On en déduit que 2*beta + theta/2 = 180 et donc que :
- theta/2 = 180 - 2*beta
- En remplaçant dans la relation c = 2*R*sin(theta/2) on obtient :
- c = 2*R*sin(180 - 2*beta)
- or sin(180 - x) = sin(x)
- c = 2*R*sin(2*beta)
- on peut maintenant déduire R :
- R = c / 2*sin(2*beta) = c / 2*sin( 2*atan(c/2h) )
- Dans le cas de notre roue dentée :
- c = epaisseur
- h = (da - d)/2
- On en conclue que :
- R = epaisseur / 2*sin(2*atan(epaisseur/(da-d))
- On peut également utiliser la fonction atan2
- R = epaisseur / 2*sin(2*atan2(epaisseur, (da-d))
- */
- d = m*z;
- da = d + 2*m;
- difference()
- {
- linear_extrude(epaisseur)
- {roue_dentee_2D(z,m,alpha, deport, evider);}
- rayon = epaisseur / (2*sin(2*atan2(epaisseur, (da-d))));
- translate([0, 0, epaisseur/2])
- {
- rotate_extrude()
- {
- translate([d/2 + rayon, 0, 0])
- {circle(rayon);}
- }
- }
- }
- }
- /**************ENGRENAGE HELICOÏDAL**************/
- /*Dans un engrenage hélicoïdal la denture est "penchée", on distingue donc 2 profiles
- -Le profil réel, qui correspond à une coupe droite de la dent, une coupe par un plan perpendiculaire aux arêtes, module réel noté mr (noté parfois mn)
- -Le profil apparent, qui correspond à une coupe selon un plan perpendiculaire à l'axe du cylindre, module apparent : ma (noté parfois mt)
- le module réel "mr" et le module apparent "ma" sont lié par :
- mr = ma*cos(beta)
- beta étant l'angle que fait la dent avec l'axe de rotation
- **************RELATIONS**************
- relation pas - module :
- p = pi*m
- relation pas réel - pas apparent :
- pa = pr/cos(beta)
- relation module apparent - module réel :
- ma = mr/cos(beta)
- relation angle de pression réel - angle de pression apparent :
- tan(alpha_r) = tan(alpha_a)*cos(beta)
- alpha_a = arctan(tan(alpha_r)/cos(beta))
- diamètre primitif :
- d = Z*mr / cos(beta)
- d = Z*ma
- diamètre de tête
- D = d + 2*mr
- nombre de dent :
- Z = d*cos(beta)/mr
- */
- module roue_dentee_helicoidale(z = 40, m = 1, alpha = 20, beta = 60, epaisseur = 10, deport = 0, evider = false)
- {
- /*le paramètre twist est le nombre de degrés effectué pendant l'extrusion
- pour un schéma détaillé voir :
- http://www.zpag.net/Machines_Simples/engrenage_droit_dent_helicoidale.htm
- ATTENTION !!
- Pour engrainer les différentes roues dentées doivent avoir :
- - le même MODULE RÉEL !!
- - Le même angle Bêta, pour un contact extérieur : beta1 = -beta2
- pour un contact intérieur : beta1 = beta2
- Or roue_dentee_2D correspond à la coupe transversale de la roue dentée, dans ce plan là il s'agit du module apparent.
- La conversion se fait grâce à la relation : mr = ma*cos(beta);
- */
- //CALCUL DES PARAMETRES APPARENTS
- ma = m/cos(beta);
- alpha_a = atan2(tan(alpha),cos(beta));
- //CALCUL DU TWIST
- /*Dans la suite tous les paramètres seront sur le cercle primitif. Pour calculer l'angle de rotation pendant l'extrusion il faut résoudre 2 triangles. Le premier est celui qui part du bord d'une dent à la base de la roue dentée (point A), monte à la verticale sur surface supérieure (point B) et termine sur le point équivalent au point A mais sur la surface supérieure (point C). Le deuxième triangle est OBC avec O le centre de la roue dentée.
- CARACTÉRISTIQUES CONNUES DE LA FIGURE :
- 0) l'angle BAC = beta
- 1) la distance AB est l'épaisseur de la roue dentée
- 2) les distances OB et OC sont le rayon du cercle primitif
- DÉDUCTIONS :
- Sachant que AB*tan(beta) = BC et que BC est une corde du cercle alors si on nomme l'angle BOC theta on peut écrire :
- 2*OC*sin(theta/2) = BC. En égalisant les deux relations on obtient :
- AB*tan(beta) = 2*OC*sin(theta/2)
- AB*tan(beta)/(2*OC) = sin(theta/2)
- asin(AB*tan(beta)/(2*OC)) = theta/2
- 2*asin(AB*tan(beta)/(2*OC)) = theta
- Theta est notre angle de twist. Les notations du script sont :
- AB = epaisseur
- beta = beta
- 2*OC = d = z*ma
- theta = angle
- On obtient donc :
- angle = 2*asin(epaisseur * tan(beta) / (z*ma));
- Cependant lorsque l'épaisseur devient trop importante alors on sort du domaine de définition de la fonction asin et le résultat devient incohérent. Pour palier à ce problème on va considérer que notre roue dentée est une succession de couches, comme lors d'une impression 3D. De ce fait on peut calculer l'angle entre 2 couches et par une règle de 3 on obtient le twist total.
- */
- h = 0.01; //couches fines
- gamma = 2*asin(h * tan(beta) / (z*ma));
- angle = epaisseur*gamma/h;
- linear_extrude(height = epaisseur, twist = angle)
- {roue_dentee_2D(z, ma, alpha_a, deport, evider);}
- }
- module roue_dentee_helicoidale_globoide(z = 40, m = 1, alpha = 20, beta = 60, epaisseur = 10, deport = 0, evider = false)
- {
- //CALCUL DES PARAMETRES APPARENTS
- ma = m/cos(beta);
- d = ma*z;
- da = d + 2*ma;
- difference()
- {
- roue_dentee_helicoidale(z, m, alpha, beta, epaisseur, deport, evider);
- rayon = epaisseur / (2*sin(2*atan2(epaisseur, (da-d))));
- translate([0, 0, epaisseur/2])
- {
- rotate_extrude()
- {
- translate([d/2 + rayon, 0, 0])
- {circle(rayon);}
- }
- }
- }
- }
- module roue_dentee_helicoidale_globoide_vis(z = 40, m = 1, alpha = 20, beta = 60, vis_diam = 10, deport = 0, evider = false)
- {
- //CALCUL DES PARAMETRES APPARENTS
- ma = m/cos(beta);
- d = ma*z;
- da = d + 2*ma;
- epaisseur = 2*sqrt( pow(vis_diam/2, 2) - pow(vis_diam/2 - ma, 2));
- difference()
- {
- roue_dentee_helicoidale(z, m, alpha, beta, epaisseur, deport, evider);
- translate([0, 0, epaisseur/2])
- {
- rotate_extrude()
- {
- #translate([ d/2 + vis_diam/2, 0, 0])
- {circle(r=vis_diam/2);}
- }
- }
- }
- }
- module roue_dentee_chevron(z = 40, m = 1, alpha = 20, beta = 60, epaisseur = 10, deport = 0, evider = false)
- {
- //CALCUL DES PARAMETRES APPARENTS
- ma = m/cos(beta);
- //CALCUL DU TWIST
- h = 0.1; //couches fines
- gamma = 2*asin(h * tan(beta) / (z*ma));
- angle = epaisseur*gamma/h;
- roue_dentee_helicoidale(z, m, alpha, beta, epaisseur/2, deport, evider);
- translate([0, 0, epaisseur/2])
- {
- rotate([0, 0, -angle/2])
- {roue_dentee_helicoidale(z, m, alpha, -beta, epaisseur/2, deport, evider);}
- }
- }
- module roue_dentee_couronne_2D(z = 10, m = 1, alpha = 20, deport = 0, marge = 10)
- {
- d = m * z;
- ha = m + deport;
- da = d + 2*ha;
- difference()
- {
- circle(d = da + marge);
- roue_dentee_2D(z, m, alpha, deport);
- }
- echo("diamètre de la couronne = ", da + marge);
- }
- /**************ENGRENAGE PLANÉTAIRE**************/
- function rayon_satellites(m, zp, zs) = m*(zp + zs)/2;
- function nbr_max_satellites(R, da) = floor(180/asin(da/(2*R)));
- function nbr_satellites_equilibre(zp, zs, nbr) = ceil((zp + zs)/nbr) == (zp + zs)/nbr ? nbr : nbr_satellites_equilibre(zp, zs, nbr - 1);
- module planetaire_2D(zp = 33, zs = 27, m = 1, alpha = 26, deport = 0, marge = 10)
- {
- /*DÉFINITIONS :
- Planétaires : roue dentée tournant autour d'un axe fixe
- Satellites : roue dentée tournant autour d'un axe mobile
- La roue dentée centrale est appelée : planétaire
- La roue dentée extérieure est appelée : couronne
- Ce module génère un engrenage planétaire (de type 1) à partir du nombre de dent du planétaire et des satellites,
- respectivement zp et zs
- Comme pour tous engrenages, les différentes roues engrènent au niveau de leurs cercles primitifs d.
- En ce plaçant dans le cas d'un engrenage planétaire composé d'un planétaire, de 2 satellites et
- d'une couronne, on comprend que le diamètre de la couronne est égale au diamètre du planétaire (dp)
- plus 2 fois le diamètres d'un satellite (ds).
- dc = dp + 2*ds
- Pour que les roues engrènent il est nécessaire qu'elles aient le même module, la formule générale qui lie
- le diamètre et le nombre de dent est :
- d = m*z
- On en déduit :
- dc = dp + 2*ds
- <=> m*zc = m*zp + 2*m*zs
- <=> m*zc = m*(zp + 2*zs)
- <=> zc = zp + 2*zs
- CONTRAINTES :
- 1)Pour maximiser le couple transmis, il faut maximiser le nombre de satellites. Cependant il existe une limite pour laquelle
- les satellites se chevaucheront. Pour touver le nombre de satellites maximum il faut comparer le diamètre de tête d'un satellite,
- avec la longueur du coté du polygone régulier crée par le centre des satellites.
- La longueur d'un coté du polygone est :
- l = 2*R*sin(180/n)
- avec R le rayon du cercle circonscrit
- n le nombre de cotés du polygone qui est égal à nbr_satellites
- Sachant que l > da on peut en déduire :
- <=> 2*R*sin(180/nbr_satellites) > da
- <=> sin(180/nbr_satellites) > da/(2*R)
- <=> 180/nbr_satellites > asin(da/(2*R))
- <=>180/asin(da/(2*R)) > nbr_satellites
- <=> nbr_satellites = floor(180/asin(da/(2*R)))
- On trouve ainsi le nombre maximum de satellites qui permet au train de continuer de fonctionner.
- 2)Connaitre le nombre maximum de satellites possible n'est pas suffisant, faut-il encore que l'engrenage soit équilibré.
- Pour se faire il faut respecter :
- (zp + zs)/nbr_satellites = k, avec k un nombre entier
- Cette condition permet de déterminer toutes les configurations possible.
- Exemple : zp = 20, zs = 20
- La condition nous indique la possibilité d'utiliser :
- 1, 2, 4, 5, 10 ou même 20 satellites.
- En combinant les 2 conditions on est capable de déterminer le nombre de satellites maximum pour générer un système équilibré.
- La formule de Willis permet de calculer le rapport de réduction, dans le cas d'un engrenage de type 1 :
- lambda = zs*zc/zs*zp = zc/zp
- */
- zc = zp + 2*zs;
- dp = m*zp;
- ds = m*zs;
- dc = m*zc;
- //calcul du rayon sur lequel circulent les satellites
- rayon = (dp + ds)/2;
- rapport1 = zc/zp + 1;
- rapport2 = zc/zs - 1;
- //on commence par placer le planétaire
- //les calculs qui suivent permettent d'orienter correctement la roue dentée
- l1 = pi*dp/(2*zp) + 2*deport*sin(alpha);
- la1 = 2*degre(l1/dp);
- db1 = dp * cos(alpha);
- Idp = intersect(db1, dp);
- angle1 = atan2( developpante_y(db1/2,Idp), developpante_x(db1/2,Idp));
- angle_base1 = la1 + 2*angle1;
- rotate([0, 0, 360*(rapport1)*$t - angle_base1/2.0 + la1 + 180*(zs/zp + 2)])
- {
- roue_dentee_2D(z = zp, m = m, alpha = alpha, deport = deport);
- }
- //puis les satellites
- //pareil ici
- l2 = pi*ds/(2*zs) + 2*deport*sin(alpha);
- la2 = 2*degre(l2/ds);
- db2 = ds * cos(alpha);
- Ids = intersect(db2, ds);
- angle2 = atan2( developpante_y(db2/2,Ids), developpante_x(db2/2,Ids) );
- angle_base2 = la2 + 2*angle2;
- nbr_satellites = nbr_satellites_equilibre(zp, zs, nbr_max_satellites(rayon_satellites(m, zp, zs), m*zs+2*(m+deport)));
- if( ceil((zp + zs)/nbr_satellites) == (zp + zs)/nbr_satellites)
- {
- for(i=[1:nbr_satellites])
- {
- translate([ rayon*cos(360*$t + 360*i/nbr_satellites), rayon*sin(360*$t + 360*i/nbr_satellites), 0])
- {
- rotate([0, 0, -360*rapport2*$t - angle_base2/2 - 360*i/nbr_satellites * rapport2])
- {roue_dentee_2D(z = zs, m = m, alpha = alpha, deport = deport);}
- }
- }
- }
- //et enfin on place la couronne
- //et pareil là
- lc = pi*dc/(2*zc) + 2*deport*sin(alpha);
- lac = 2*degre(lc/dc);
- dbc = dc * cos(alpha);
- Idc = intersect(dbc, dc);
- anglec = atan2( developpante_y(dbc/2,Idc), developpante_x(dbc/2,Idc) );
- angle_basec = lac + 2*anglec;
- rotate([0, 0, -angle_basec/2])
- {roue_dentee_couronne_2D(z = zc, m = m, alpha = alpha, deport = deport, marge = marge);}
- echo("nombre de dent de la couronne = ", zc);
- echo("rapport = ", zc/zp);
- echo(nbr_satellites = nbr_satellites);
- }
|