MPO n°117 : le problème du tourneur

[antoine]

Michel est tourneur P2 dans une petite entreprise d'usinage et réalise régulièrement des opérations de filetage au tour.
Le tour sur lequel il travaille est doté d'une lyre à quatre engrenages A, B, C, et D et d'une vis mère au pas de m.
Il doit choisir judicieusement les nombres de dents na, nb, nc, et nd des quatre engrenages pour usiner sa pièce au pas voulu.
Le pas obtenu avec une combinaison d'engrenages vaut p=(na/nb)*(nc/nd)*m.
Sachant que m=1.5mm, s'il installe des engrenages A:40dents, B:60dents, C:50dents, et D:40dents il obtiendra un pas p=1.25mm.
Michel possède un tableau qui répertorie les engrenages à utiliser en fonction du pas p souhaité.
Seul hic, le tableau ne comporte que des pas métriques. Or, aujourd'hui, Michel travaille pour un client britannique.
Ce dernier lui demande de réaliser des filets dont le pas est perfidement compté en "tpi", filets par pouce.
Ainsi il doit par exemple réaliser un pas de 48tpi, soit p=25.4/48mm=0.529mm.
Il a à sa disposition une collection d'engrenages dont les nombres de dents sont les suivants : 20, 20, 30, 35, 36, 40, 40, 40, 42, 45, 48, 50, 50, 54, 57, 60, 60, 70, 80, et 80.
Il souhaite donc sélectionner quatre engrenages parmi ceux-ci pour obtenir un pas le plus proche possible du pas recherché, en respectant une erreur maximale de 0.5%
A cela s'ajoute une complication : il faut que na+nb soit compris entre 75 et 160 et nc+nd entre 85 et 140, faute de quoi les engrenages ne se montent pas sur la lyre.
Michel possède une calculatrice programmable mais ne sait faire avec que de l'arithmétique et de la trigonométrie.
Il est donc bien embêté, d'autant plus que l'approche par tâtonnement s'avère laborieuse.
Sauriez-vous lui rédiger un petit programme qui lui demande d'entrer le pas souhaité en "tpi", et affiche ensuite toutes les combinaisons d'engrenages possibles, sans jamais présenter deux fois la même, avec pour chacune le pas effectivement obtenu et l'erreur par rapport au pas théorique?



Sommaire des MPO

[C.Ret]

Ah! Chouette un nouvel MPO !
Bien, celui-ci me parait idéal. Mais j'ai déjà la tête qui tourne...

... je sais même pas ce qu'est une lyre en mécanique. J'ai du boulot, pas gagné tout ça...



Je crois que je fais fausse route, mais le sujet m'intéresse


@Antoine, n'oublie pas de donner un lien vers le sommaire des MPOs dans le premier message.

[Schraf]

Question : le 48 tpi c'est juste un exemple ou pas ? Il existe une solution à moins de 0.5 % pour cette valeur ?

Je trouve x = 0.526 mm (pour une combinaison gardée secrète) au lieu de v = 0.529 mm soit une erreur relative de 0.54% = (x - v) / v

[antoine]

Bonjour,

Oui le 48tpi est un intéressant exemple pour lequel il existe huit solutions en-dessous de 0.5% d'erreur.
Mais le code devra être capable de calculer pour toute valeur...

Antoine

[Schraf]

OK c'est bon ! En fait j'ai copié-collé sans aucune modification ton MPO dans chatGPT qui m'a répondu au bout d'une seconde environ... avec un joli programme en Python correct à 99,99% !

Le truc c'est qu'il a confondu combinaisons et arrangements, si bien que son programme n'a testé que 4825 combinaisons (4 parmi 20 sans ordre) au lieu des 116 280 !

On trouve effectivement plusieurs solutions (4 si on ne distingue pas les engrenages de mêmes tailles) avec des erreurs de 0.26%, 0.34% et 0.45%.

Sur la dernière NUMWORKS (N120), il lui faut quasi 15 secondes pour trouver les solutions, autant dire que nos anciennes machines ont du souci à se faire si vos algorithmes utilisent la force brute !

Voir la NUMWORKS en pleine réflexion

[FLISZT]

… autant dire que nos anciennes machines ont du souci à se faire…

Voir la NUMWORKS en pleine réflexion

… les vieux neurones aussi !
Il n'y aurait pas, en plus d'une dose de probabilité, deux (gros) doigts de programmation-linéaire-méthode-du-pivot-toussa ?

[Schraf]

@FLISZT : Ah oui j'adore l'idée !

Je viens de faire une version 100% hasard pour TI-82/83 et finalement, malgré le nombre élevé d'arrangements et le peu de solutions pour la valeur 48, le simulateur trouve assez rapidement. Bien entendu ça ne permet pas d'avoir toutes les possibilités mais si le but est de créer la pièce, on a un résultat acceptable...

La TI-83 trouve une solution

TI83.png (5 Kio) Vu 2335 fois

[antoine]

Bonjour

Pour 48tpi voici :

Code : Tout sélectionner

A:20   B:60   C:57   D:54   p:0.528mm   e:0.26%   
A:30   B:48   C:45   D:80   p:0.527mm   e:0.34%   
A:30   B:80   C:45   D:48   p:0.527mm   e:0.34%   
A:42   B:80   C:54   D:80   p:0.532mm   e:0.45%   
A:45   B:48   C:30   D:80   p:0.527mm   e:0.34%   
A:45   B:80   C:50   D:80   p:0.527mm   e:0.34%   
A:50   B:80   C:45   D:80   p:0.527mm   e:0.34%   
A:54   B:80   C:42   D:80   p:0.532mm   e:0.45% 

Antoine

[Gilles59]

En newrpl et force brute et approche naïve c’est instantané sur PC et moins de 60 sec sur la HP50g ( pas mal pour une machine de 2006 et même d’avant pour la 49g+ 2003?) . En RPL c’est très facile à programmer avec la remarquable library ListExt ( qui contient la commande DOCOMB et DOPERM pour générer toutes les combinaisons/permutations de n éléments d’une liste, suppression des doublon etc ) mais c’est beaucoup (vraiment beaucoup!) trop lent.

Bref le challenge est comme souvent de trouver un algorithme plus malin!

[C.Ret]

Bon ,ne n'a pas était sans mal, mais j'ai réussit un peu à me documenter et j'ai découvert qu'une lyre est un dispositif mécanique qui permet l'accouplement d'engrenages de taille différentes mais dont les dents sont identiques (sinon ça coince et pas moyen de tourner).



Alors évidemment, les engrenages avec le plus de dents ont un diamètre supérieur à ceux ayant moins de dents. la lyre sert à maintenir les axes en place et à assurer les efforts de traction. Evidemment, pour creuser un filetage, il faut un peu appuyer sur la pièce à rainurer et donc il faut que la machine soit solide. Sinon, on fait n'importe quoi !

Bon, j'ai aussi trouvé un programme pour HP-41C qui permet de déterminer quels engrenages il faut utiliser:

Code : Tout sélectionner

00                                  37 LBL E                             75 LBL 01
01 LBL A                            38  FIX 3  FS?C 22  STO 05           76  RCL 05 1.5 / RCL 02 * RCL 03 / RCL 04 * RTN
02  FIX 0  RND  FS?C 22  STO 01     41  "P= "  ARCL 05  "~ mm"           86 LBL 02
06  "Na= "  ARCL 01  FIX 4  PROMPT  44  FIX 4  PROMPT                    87  1.5 RCL 05 / RCL 01 * RCL 03 / RCL 04 / RTN
10 LBL B                            46 LBL J                             97 LBL 03
11  FIX 0  RND  FS?C 22  STO 02     47  1E2  XEQ 05  RCL 05 - LASTX / *  98  RCL 05 1.5 / RCL 01 / RCL 02 * RCL 04 * RTN
15  "Nb= "  ARCL 02  FIX 4  PROMPT  54  FIX 2  "ERR= "  ARCL X  "~ %"   108 LBL 04
19 LBL C                            58  FIX 4  PROMPT                   109  1.5 RCL 05 / RCL 01 * RCL 02 / RCL 03 * RTN
20  FIX 0  RND  FS?C 22  STO 03     60 LBL e                            119 LBL 05   
24  "Nc= "  ARCL 03  FIX 4  PROMPT  61  FC? 22  RCL 05  FS? 22  XEQ 10  120  1.5 RCL 01 * RCL 02 / RCL 03 * RCL 04 / RTN
28 LBL D                            65  FS?C 22  STO 05  XEQ 10         130 LBL 10
29  FIX 0  RND  FS?C 22  STO 04     68  FIX 1  "P= "  ARCL X  "~ TPI"   131  25.4 X<>Y / .END.
33  "Nd= "  ARCL 04  FIX 4  PROMPT  72  FIX 4  PROMPT  GTO E

(P.S.: Il existe une version bien plus courte de ce programme utilisant le registre R00 et les Flags01~04 pour des adressages indirects. Cette version est à peine plus longue. Elle est publiée afin de rendre le principe de fonctionnement du code plus évident aux yeux du lecteurs. Par ailleurs, elle est plus facile à débugger et à compléter. Si l'un d'autre vous est intéressé, je lui transmettrait volontiers la version avec indexation. Il m'aidera à la débugger et à la corriger.)

Les labels A B C et D permettent de sélectionner le nombre de dents des engrenages A B C et D de la machine de Michel.
Les labels E et SHIFT-E permettent de sélectionner le pas du filetage respectivement exprimé en mm ou en tpi (turn per inch)

Comme il s'agit d'un MPO, cette version ne fait pas toutes les déterminations, ne prend pas en compte les pignons disponibles en doublon/triplets ou non, ni ne vérifie qu'ils peuvent s'insérer sur la lyre du tour de Michel (limites nA+nB et nC+nD non traitées).

Pour trouver une solution, le point clef et le plus astucieux de l'algorithme se trouve bien évidemment debout à coté de la machine le deux pied sur le sol et les doigts sur le clavier de la HP-41C, loin de toute pièce en mouvement afin, et c'est important, d'éviter tout pincement ou cisellement. En effet, les doigts ça ne repousse pas ! Ouille.

Résumé de l'utilisation du code:
Saisir le code et se mettre en mode USER.

Pour sélectionner un engrenage; saisir le nombre de dents et presser A B C ou D afin de l'affecter au pignon A, B,C ou D.
Pour vérifier la sélection d'un engrenage, il suffit de presser A, B, C ou D sans entrer de valeur, le nombre de dents et l'engrenage sélectionné seront affichés.
Pressez sur la touche R/S pour voir s'afficher l'engrenage ou l'information suivante.
Alternativement, on peut aussi utiliser les commandes RCL A, RCL B, RCL C ou RCL D pour avoir le nombre et faire un calcul.

Pour sélectionner un pas de filetage, saisir le pas en mm et presser E ou saisir le pas en Turn Per Inch et presser SHIFT-E.
Pour voir s'afficher l'erreur entre le dispositif et le pas sélectionné, presser J (touche TAN), l'erreur s'affiche en pourcentage.
Presser sur la touche R/S pour voir s'afficher le pas en mm, en TPI ou l'erreur en %.

Utiliser EXQ A, EXQ B, EXQ C ou EXQ D pour déterminer le nombre de dents à utiliser sur le pignon A, B, C ou D.
Utiliser EXQ E pour voir le pas en mm du dispositif sélectionné.
Utiliser EXQ J pour convertir des mm en TPI et vice-versa.


Petits exemples:
40 A 60 B 50 C 40 D 1.25 E R/S affiche ERR= 0.00 % car la disposition est effectivement exactement celle pour 1,25 mm.

1.375 E sélectionne un pas de 1.375 mm et EXQ C indique qu'il faut remplacer sur pignon C une roue de 55 dents (que Michel a visiblement égarée).
Comme Michel n'a pas d'engrange de 55 dents, il décide d'essayer son engrenage de 57 dents:
57 C J affiche une erreur de 3.64%, ce qui est trop important.
Il retrouve son engrenage de 54 dents: 54 C J réduit l'erreur à -1.82 % c'est mieux mais pas idéal.

Bon Jean-Lous doit certainement avoir un engrenage de 55 dents. Mais il ne pourra l'apporter à l'atelier que plus tôt lundi prochain.
En attendant, Michel décide d'avancer un peu son travail et finir une commande d'écrous de fixation M10 en souffrance.
Le pas de ces écrous et boulon doit être de 1.75 mm:
1.75 mm E affiche P= 1.75 mm. L'HP-41C contient toujours en mémoire la configuration du tour.
Michel trouve facilement quel pignon changer:
XEQ A et XEQ C affichent respectivement 56.0000 et 70.0000
XEQ B et XEQ D affichent 42.8571 respectivement et 28.5714

Michel monte sa roue de 70 dents sur l'axe C de son tour et va chercher les gougeons à usiner.
Avant de commencer son ouvrage, il vérifie : 70 C modifie la configuration mémorisé dans l'HP.
XEQ E affiche 1.7500 et J affiche ERR= 0.00 % c'est bien cela.
Comme Michel se méfie du programme écrit par C.Ret, il refait une dernière fois le calcul: 1.5 ENTER^ 6 / 7 * qui donne bien 1.75


42 A 80 B 54 C 80 D 48 SHIFT-E R/S affiche P= 0.529 mm puis R/S affiche ERR= 0.45 %
EXQ C affiche 53.7566 indiquant qu'il suffit de trouver un engrenage de 53.7566 dents pour que le filetage anglais soit parfait !

Conclusion

Franchement, je ne voit pas ce qu'il y a de compliqué en mécanique !!
Pas ma faute si Michel est mal équipé et que les britanniques ont un système impérial catastrophique.

Non mais! M'enfin!

Bon, pas mal ce MPO, plus compliqué qu'il n'y parait au premier abord.

[Schraf]

Voici mes 2 programmes hasardeux, ils ne donnent donc pas toutes les solutions mais seulement la première qu'ils trouvent en choisissant au hasard 4 engrenages parmi les 20.

Pour les TI-83 et autres TI-82 ayant la fonction randIntNoRep qui permet de tirer des nombres entiers au hasard sans répétition :

Code : Tout sélectionner

{20,20,30,35,36,40,40,40,42,45,48,50,50,54,57,60,60,70,80,80→L₁

Disp "PAS EN TPI ?"
Input N
25.4/N→V
0→T
While T=0
randIntNoRep(1,20→L₂		'Permettra de mélanger l'autre liste L₁
SortA(L₂,L₁			' On trie L₁ en utilisant l'ordre aléatoire de L₂
If L₁(1)+L₁(2)≥75 and L₁(1)+L₁(2)≤160 and L₁(3)+L₁(4)≥85 and L₁(3)+L₁(4)≤140
Then
L₁(1)/L₁(2)*L₁(3)/L₁(4)*1.5→P
abs(P-V)/V→E
If E<.005
Then
1→T
Disp P
Disp E
Disp seq(L₁(X),X,1,4
End:End:End

Et pour les HP-48/50 (Shuffle pour le mélange des 20 engrenages) :

Code : Tout sélectionner

« LIST→ →t
« t RAND * CEIL ROLL SWAP
t →LIST »
» 'SHUF STO

« INV 25.4 * 0 → a b c
« DO a SHUF DUP 'a' STO
1 4 SUB OBJ→ DROP	' Modif suite au prgm de @Gilles59
0 0 → d e f g h j
« IF d e + 75 ≥ d e + 160 ≤ AND
f g + 85 ≥ AND f g  + 140 ≤ AND
d e / f * g / 1.5 * DUP 'h' STO b - ABS b /
DUP 'j' STO .005 < AND
THEN
 1 'c' STO
 d e f g 4 →LIST
 h j
END »
UNTIL c 1 == END
» » 'M117 STO

{20 20 30 35 36 40 40 40 42 45 48 50 50 54 57 60 60 70 80 80}
48
VAR M117

Exemple de résultat

hp48MPO117.png (7.26 Kio) Vu 2221 fois

[Schraf]

Voici une version en Python pour les calculatrices récentes, contrairement à la version de chatGPT celle-ci est beaucoup plus rapide car elle ne mémorise pas au départ tous les arrangements possibles :

Code : Tout sélectionner

gears = [20,20,30,35,36,40,40,40,42,45,48,50,50,54,57,60,60,70,80,80]

def calculate_pitch(na, nb, nc, nd):
    p = na / nb * nc / nd * 1.5
    e = abs(p - target_pitch) / target_pitch
    return (p, e)

# Initialisation
target_tpi = float(input("tpi : "))
target_pitch = 25.4 / target_tpi
sol = []
t = len(gears)

# Possibilites pour le 1er engrenage
for a in range(t):
 # Engrenage du n°0 au dernier
 r = set(range(t))
 # On enleve "a"
 r.remove(a)
 # Valeur de l'engrenage
 na = gears[a]
 for b in r:
  # Nouvel ensemble sans "a" ni "b"
  s = set(r)
  s.remove(b)
  nb = gears[b]
  # Conditions sur les 2 premiers engrenages
  if (na + nb) >= 75 and (na + nb) <= 160:
   # Si ok on continue
   for c in s:
    nc = gears[c]
    # Nouvel ensemble sans "a, b" ni "c"
    u = set(s)
    u.remove(c)
    for d in u:
     # 4e engrenage
     nd = gears[d]
     if (nc + nd) >= 85 and (nc + nd) <= 140:
      pitch, error = calculate_pitch(na, nb, nc, nd)
      # Si la combinaison convient
      if error <= 0.005:
       v = (na,nb,nc,nd)
       # et que l'on ne l'avait pas encore
       if v not in sol:
        # On l'ajoute et on affiche infos
        sol.append(v)
        print("Engrenages : {}".format(v))
        print("Pas obtenu : {:.3f} mm".format(pitch))
        print("Erreur : {:.3f}%".format(error * 100))
        # Attente que l'utilisateur tape sur ENTER
        input()  

print("Nb solutions :", len(sol))

Voici ce que l'on obtient successivement à l'affichage :

Code : Tout sélectionner

Engrenages : (20, 60, 57, 54)
Pas obtenu : 0.528 mm
Erreur : 0.262%

Engrenages : (30, 48, 45, 80)
Pas obtenu : 0.527 mm
Erreur : 0.344%

Engrenages : (30, 80, 45, 48)
Pas obtenu : 0.527 mm
Erreur : 0.344%

Engrenages : (42, 80, 54, 80)
Pas obtenu : 0.532 mm
Erreur : 0.453%

Engrenages : (45, 48, 30, 80)
Pas obtenu : 0.527 mm
Erreur : 0.344%

Engrenages : (45, 80, 50, 80)
Pas obtenu : 0.527 mm
Erreur : 0.344%

Engrenages : (50, 80, 45, 80)
Pas obtenu : 0.527 mm
Erreur : 0.344%

Engrenages : (54, 80, 42, 80)
Pas obtenu : 0.532 mm
Erreur : 0.453%

Nb solutions : 8

Question subsidiaire : Quel est le pas (en "tpi") maximal et minimal qu'il est possible d'obtenir à 0% d'erreur avec les engrenages proposés ? Par exemple on aura 154.8190476 tpi avec la combinaison (20, 80, 35, 80) mais ce n'est pas la valeur maximale. De même on a 1.20952381 tpi avec (70, 20, 80, 20) mais il existe une valeur encore inférieure.

[Gilles59]

Ma version NewRPL "force brute" est quasi identique à celle d'Eric en Python. J'essaie d'optimiser 2 ou 3 choses avant de la soumettre. Ca trouve toutes les solutions en 0,2s sur PC et moins de 60s sur HP50g.

J'aime beaucoup la version ci-après "force brute" pour RPL qui utilise la magnifique library ListExt que je conseille vivement HP48->50g : https://www.hpcalc.org/details/7971
Malheureusement c'est bien lent (pas la library mais le RPL standard), les solutions s'affichent en temps réel puis à la fin (sans le % d'erreur). Comptez 20 mn sur l'émulateur PC et peut être 100 fois plus sur le hdw de la 50g (:O). Possible d'optimiser mais même si ça va deux fois plus vite ça restera très lent.

Code : Tout sélectionner

« 25.4 SWAP / -> Mm 
 «  {} @ Liste des solutions
    { 20 20 30 35 36 40 40 40 42 45 48 50 50 54 57 60 60 70 80 80 } 4 
     « DUP EVAL  -> Na Nb Nc Nd 
      «  IF '((Na+Nb)>75) AND ((Na+Nb)<160) AND ((Nc+Nd)>85) AND ((Nc+Nd)<140)' THEN
          IF 'ABS((Na/Nb*Nc/Nd*1.5-Mm)/Mm)>0.005' THEN DROP ELSE DUP 1 DISP ADD END
         ELSE DROP END 
       »
     »
     DOPERM @ Permute la liste par groupe de 4 items. Fonctionne comme DOSUB
     LDDUP @ Supprime les doublons (déduplique liste)
     DUP SIZE " solutions" + @ Affiche les solutions et leur nombre
 »
»

J'avais écrit un DOPERM en NewRPL mais ne remet plus la main dessus.

EDIT : je me demande pourquoi Antoine évoque les fonctions trigo ;D

[Gilles59]

*** doublon à supprimer

[Gilles59]

NewRpl, force brute :

LDROP @ Supprimer un élement d'une liste

Code : Tout sélectionner

«
 → L n
 «
   L 1 n 1 - SUB
   L n 1 + 20 SUB
   ADD 
 »
»

MPO117

Code : Tout sélectionner

« 25.4 SWAP / → Mm
 «
  {} 'Sol' LSTO @ Les solutions
  { 20 20 30 35 36 40 40 40 42 45 48 50 50 54 57 60 60 70 80 80 } 'N1' LSTO
 
  1 20 FOR a
    N1 a GET 'Na' LSTO
    N1 a LDROP 'N2' LSTO
    1 19 FOR b 
      N2 b GET 'Nb' LSTO
      Na Nb + DUP
      IF 75 > THEN
        IF 160 < THEN
          N2 b LDROP 'N3' LSTO
          1 18 FOR c
              N3 c GET 'Nc' LSTO
              N3 c LDROP 'N4' LSTO
              1 17 FOR d
                N4 d GET 'Nd' LSTO
                Nc Nd + DUP
                IF 84 > THEN
                  IF 140 < THEN 
                       Na Nb / Nc Nd / * 1.5 * 'r' LSTO
			r Mm - Mm / ABS '%Err' LSTO
                    IF  %Err 0.005 < THEN
                      Na Nb Nc Nd  r 1_mm * %Err 100 * 6 →LIST
		      IF Sol OVER POS NOT THEN 1 →LIST 'Sol' SADD ELSE DROP END
                    END
                  END
                ELSE
                  DROP
                END 
              NEXT
           NEXT
        END 
      ELSE
        DROP
      END
    NEXT
  NEXT
  Sol LIST→ " Solutions" + 
 » 
»

mpo117.png (13.19 Kio) Vu 2159 fois

Nota RPL vs NewRPL :
- LSTO est une nouvelle commande pour gérer simplement les varaiables locales
- pour les listes les commande + et ADD sont inversées ce qui est logique mais perd la compatibilité
- On peut utiliser NotePad++ ou autre pour écrire le programme
- La version PC NewRPL est une version compilée pas un émulateur
- Les échanges PC <-> HP50g se font facilement avec les commandes USBSEND
- C'est _infiniment_ plus rapide que le RPL HP