Roues dentées

De wiki jackbot
Aller à la navigation Aller à la recherche

Les roues dentées sont des systèmes mécaniques, elles sont utilisé dans des engrenages afin de créer des transmissions de puissance. Les différentes modélisations utilisées pour illustrer ont été faites avec le logiciel OpenSCAD

Paramètres

On va lister ici les paramètres qui vont permettre de définir une roue dentée. Il faut distinguer deux types de paramètres, les paramètres de bases, sans qui on ne peut rien faire et les paramètres que l'on va déduire des paramètres de bases.

Paramètres de base

Le module

Noté , il s'agit du paramètre centrale des transmission mécanique. Il représente la taille des dents. De ce fait on comprends assez facilement qu'il est nécessaire que les différents éléments qui vont devoir s'engrainer doivent avoir le même module.

L'angle de pression

Noté cet angle correspond à la partie bleue sur cette crémaillère

Cremaillere angle alpha.png

Le nombre de dents

Noté , je ne pense pas qu'il soit nécessaire de s'étendre sur ce paramètre.

Paramètres déduis

Une fois en possession de , et , nous avons toutes les informations nécessaire. Cependant afin de modéliser une roue dentée où une crémaillère, il va nous falloir quelques informations supplémentaires.

Le pas

Sur une crémaillère, le pas est la distance pour laquelle le motif se répète, on peut faire le parallèle avec les phénomène oscillant et ce qui est appelé longueur d'onde. On le note et il correspond à :

avec le module et la constante mathématique (3.1415...)

La hauteur de la dent

La hauteur, noté , d'une dent est en réalité composé de deux paramètres

  • la saillie noté
  • le creux noté

avec le module

Dans le cas où le module est inférieur à 1.25 on a :

Dans le cas contraire on a :

La hauteur totale de la dent étant définie par :

Le diamètre de la roue

Comme précédemment on va faire la distinction entre différents diamètres :

  • le diamètre de tête noté
  • le diamètre primitif noté
  • le diamètre de pied noté
  • le diamètre de base noté

Le diamètre primitif correspond à :

Il est à noter que sur le cercle primitif, la largeur d'une dent est d'un demi-pas.

Vu que l'on travaille sur des diamètres, pour trouver le diamètre de tête il est nécessaire d'ajouter deux fois la saillie de la dent.

Pour des raisons identiques on a pour le diamètre de pied :

le diamètre de base sert à générer la développante de cercle qui servira de profil pour les dents.

Récapitulatif

  • , le module, qui caractérise la largeur de la dent et ainsi la couple maximal transmissible
  • , l'ange de pression, qui joue sur l'inclinaison des dents
  • , le nombre de dents
  • , le pas définissant la distance de répétition
  • , la saillie de la dent. Partie qui sera au-dessus du cercle primitif
  • , le creux de la dent. Partie qui sera en-dessous du cercle primitif
    • si alors
    • si alors
  • , la hauteur de la dent
  • , le diamètre primitif de la roue
    • Sur le cercle de diamètre d (cercle primitif), la largeur d'une dent est de
  • , le diamètre de tête de la roue
  • , le diamètre de pied de la roue
  • , permet la génération de la développante de cercle d'équation :


La crémaillère

Maintenant que nous avons listé tous les paramètres, nous allons commencer avec l'exemple le plus simple : la crémaillère, une simple rangée de dents. Les connaissances de bases de la trigonométrie suffisent à calculer tous les points nécessaire à la modélisation d'une crémaillère.

Cremaillere.png

Sachant que sur le trait vert (), la dent à une largeur de , on peut déduire que la base de la dent a une largeur de :

Dans Openscad on peut donc écire :

function creux(m = 1) = m <= 1.25 ? 1.4*m : 1.25*m;

module dent_cremaillere_2D(m = 1, alpha = 20)
{
    //hauteurs
    hf = creux(m);
    ha = m;
    h = hf + ha;
    
    //pas
    p = m*PI;

    largeur_base = 2*hf*tan(alpha) + p/2;
    polygon([ [0, 0], [h*tan(alpha), h], [largeur_base - h*tan(alpha), h], [largeur_base, 0] ]);
}

Avec ce module on peut modéliser UNE dent de crémaillère. Pour modéliser une crémaillère entière, on va simplement appeler ce moduler autant de fois qu'on veut de dents.

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);}
        }
    }
}

Pour l'instant la modélisation est en 2D, pour obtenir un modèle 3D il suffit d'utiliser la fonction linear_extrude d'OpenSCAD.

module cremaillere_3D(z = 10, m = 1, alpha = 20, largeur = 10, epaisseur = 3)
{
    linear_extrude(epaisseur)
    {cremaillere_2D(z, m, alpha, largeur);}
}

Roue dentée

Profil d'une dent

Le profil d'une dent doit posséder une courbure bien particulière. Pour éviter les efforts sur l'axe de rotation, il faut que les normales restent tangentes à un cercle fixe. Une courbe possédant cette caractéristique est la développante de cercle, plus d'information ici. L'équation d'une telle courbe est :

Dans OpenSCAD on peut écrire les fonctions suivantes :

function developpante_x(r = 1, t = 0) = r*(cos(t)+rad(t)*sin(t));
function developpante_y(r = 1, t = 0) = r*(sin(t)-rad(t)*cos(t));

Intersection avec la développante de cercle

Maintenant que nous pouvons tracer une développante de cercle, il faut trouver quelle est la portion de cette courbe que l'on va utiliser pour générer la dent. Bien entendu on commencera à générer la dent pour , mais quelle est la valeur maximale de  ?

Première limite

La première limite très intuitive est que la dent ne doit pas dépasser le cercle de tête. Il faut donc dans un premier temps trouver la valeur de pour laquelle la développante de cercle intersecte le cercle de tête .

Intersection developpante.png

Le point appartenant à la développante ses coordonnées sont , or est le rayon du cercle de tête. En appliquant le théorème de Pythagore on obtient :

On peut maintenant écrire les différentes fonctions dans notre fichier OpenSCAD en n'oubliant pas que ce logiciel fonctionne avec des angle en degré, il ne faut donc pas oublier les fonctions de conversion :

//Fonctions de conversion
function rad(angle = 0) = PI * angle / 180;
function degre(angle = 0) = angle * 180 / PI;

function intersect_rad(r=1, R=2) = sqrt( (R*R)/(r*r) - 1);
function intersect(r=1, R=2) = degre(intersect_rad(r, R));

On peut donc calculer la limite de la dent avec :

Ida = intersect(db, da);

Deuxième limite

Un peu moins évident, dans certains cas il arrive que le point d'intersection calculé précédemment dépasse l'axe de symétrie de la dent. Cependant pour pouvoir établir cette deuxième limite il va nous falloir d'abord calculer l'angle formé par la base de la dent.

Angle à la base de la dent

On peut donc maintenant dessiner un bord d'une dent, pour dessiner la dent complète il faut connaître la largeur à la base de la dent. Pour y arriver il faut faire comme pour la crémaillère sauf que dans ce cas c'est avec des angles qu'il faudra travailler.

Angle base dent.png

Nous cherchons l'angle : Le point est le point d'intersection du cercle primitif avec la développante de cercle. La longueur de l'arc de cercle . Or si on considère l'angle en radian on peu écrire :

Pour l'angle , il faut en premier lieu calculer les coordonnées du point , chose que l'on peut obtenir facilement en utilisant la fonction écrite à l'étape précédente :

Id = intersect(db, d);

Idx = developpante_x(db/2,Id);
Idy = developpante_y(db/2,Id);

Avec un peu de trigonométrie on déduit que :

Et donc dans OpenSCAD :

angle = atan2(Idy, Idx);
angle_base = degre(p/d) + 2*angle;

Deuxième limite

Nous pouvons maintenant revenir sur notre deuxième limite. Mais avant de commencer faisons un petit schéma pour voir où nous en sommes :

Dent.png

Sur ce schéma cela devient évident, inutile de continuer la développante de cercle jusqu'au cercle de tête. Pour calculer l'intersection entre une développante de cercle et un cercle c'était relativement facile, théorème de Pythagore, quelques notions de trigonométrie et ça passe. Ici pour calculer l'intersection d'une droite avec la développante de cercle il va falloir ajouter quelques segments et ruser un peu.

Intersection symetrie.png

Le triangle en rouge va nous permettre de résoudre le problème. Faisons la liste de ses propriétés intéressantes :

  1. Le segment est le rayon du cercle de base
  2. La droite est tangente au cercle de base
  3. La longueur du segment est proportionnelle au paramètre de la développante de cercle :
  4. L'angle (en radian) est le paramètre de la développante de cercle
  5. L'angle est la moitié de l'angle de base de la dent

Commençons à faire quelque déductions de tout ceci :

  • d'après 2. et sont perpendiculaire et donc le triangle est rectangle en
  • Vu que le triangle est rectangle on peut écrire :
  • L'angle que nous devons trouver est : car


Construction de la dent

Le but de l'opération est de créer un polygone dont les cotés sont définies par la développante de cercle ainsi que les paramètres trouvés aux étapes précédentes. Pour ce faire nous utilisons une boucle for

A = [ for(i=[0: ceil(Ida)])[developpante_x(db/2,i), developpante_y(db/2,i)] ];

La boucle for s'arrête pour i = Ida, donc la variable A contient une série de points définie par la développante de cercle jusqu'au cercle de tête. Pour obtenir les points de l'autre coté, il faut dans un premier temps créer une matrice de rotation et parcourir les points dans l'autre sens :

Matrice_de_rotation = [ [cos(angle_base), -sin(angle_base)], [sin(angle_base), cos(angle_base)] ];

B = [ for(i=[floor(-Ida):0])Matrice_de_rotation*[developpante_x(db/2,i), developpante_y(db/2,i)] ];

Le polygone complet s'obtient en concaténant les deux ensembles de points

C = concat(A, B);