fabrication d’une fraiseuse cnc home made

[Cadrature]

Je ne valide pas du tout la réponse de Gemini.

Utiliser le code G pour programmer la boucle et le comptage des pas me semble maladroit, compliqué,
et pose une difficulté supplémentaire pour la machine à commander (il faudrait savoir développer un interpréteur).
De plus ce n’est pas dans les normes ISO de G-Code.
Non, il faut faire le comptage des pas et leur répartition équitable entre les dents dans le programme qui produit
le G-Code simplement. Un peu comme vous faites dans votre programme Basic.

G-Code n’est là que pour aider et simplifier, pas pour compliquer.

Cadrature

[Vir]

Bonjour à vous,
J’ai loupé une toute petite partie
Oui Cadrature le poste se rempli bien

Pour tout vous dire je suis d’accord avec un et l’autre.
Tout dépend de ce que l’on veut faire et je comprends JC actuellement, il doit juste entrer le nombre de dents et hop c’est parti.

Je comprends sa position et qu’il veuille faire évoluer la partie pilotage de sa machine tout en gardant la facilité car c’est très rapide et pas besoin de logiciel de Cao ni quoique ce soit et au revoir le gros PC qui prend trop de place.

Et je comprends Cadrature qui donne toutes ces bonnes informations adaptées à mon projet mais qui pourraient également être utiles pour une fraiseuse avec diviseur comme celle de JC.
Pour des simples déplacements d’un axe, je pense qu’on devrait pouvoir écrire le G code soit même avec le bloc note de Windows. Je ne le fait pas moi même mais avec un peu de pratique (ça reste une tâche pas cool pour celui qui n’aime pas coder comme moi )

Pour ma part, j’utilise Fusion car il génère le G code mais pas que, Il simule également le parcours de l’outil (outil par défaut ou personnalisé) ce qui permet de contrôler le bon déroulement des opérations avant usinage.
Une fois que tout est OK on génère le G code, on l’ importe dans le logiciel qui fonctionne sous Grbl « j’utilise cncjs »
Je pense qu’il est possible également comme vous le dites d’ajouter un diviseur.
Je crois que fusion peux également écrire le code d’un diviseur, à tester ! Mais on peux de toute façon l’utiliser pour piloter un tour numérique donc ça doit être faisable.

https://www.youtube.com/shorts/c8NvB5EWVg4?si=SFO3vMaYC4OP1kos

Avec fusion ce qui est bien c’est qu’on peut faire ce que l’on veut.
Ça va de la modélisation au produit fini.
On peut également (et ça c’est vraiment cool !) modéliser des engrenages très facilitement, faire une simulation de rotation des pignons.
Et ensuite les usiner !

https://youtu.be/XZP6enXPMiM?si=EJtS8pYadUNl1jjy

Je pense que quand le nouvelle version de ma fraiseuse sera opérationnelle, je ferai un test de petite roue peut-être pas de pignon mais déjà voir ce que cela donnerait.

Je continue la lecture du post
Merci à vous
A+
Vir

[Torzio]

J’espère que Vir va faire le choix du Paspberry. Cela me donnera alors le courage de reprendre mon projet de piloter ma machine à tailler par ce microcontrôleur, pour remplacer mon vieux PC encombrant.
Ceci aurait l’avantage, pour Vir, de pouvoir piloter sa machine avec GRBL ou avec ma méthode. Cela me stimulerait pour traduire mon programme Basic en Python, avec l’aide de l’IA.
Sauf si Vir a déjà un projet pour son diviseur, je pense que ma solution avec un tour Lorch permet d’avoir une très grande précision avec une simplicité de mise en œuvre. Je reste entièrement disponible pour partager une expérience réelle, qui ne demande qu’à être améliorée !
La fin justifie les moyens !

@+
JC

[Cadrature]

Bonjour

Comme je disais, ce qui semble difficile pour les uns et simple pour les autres et inversement.
Le programme Basic que vous proposez est très simple. Je n’avais pas touché à Basic depuis plus de 35 ans, mais
les souvenirs me reviennent 😉
On peut optimiser l’algo pour faire plus simple et développer en Python ou en C++ pour faire la même chose, c’est certain.

Si je trouve le temps je vous ferai ça.

On peut embarquer ce programme dans un RasbperryPy oui. Mais la motivation d’utiliser RaspberryPy ne doit pas être dictée par le choix du langage à mon avis, mais par le développement d’une interface plus évoluée. Par exemple une page web ou un programme Java sur le RaspberryPy qui permet de renseigner tous les paramètres de division. Si vous voulez vous débarrasser de l’ordi sur votre machine, c’est une bonne solution.

Plein de configurations sont possibles, il faut voir ce qui est le plus pratique et qui entre dans le budget.

Mais tout ceci est peut-être idiot si des logiciels comme Fusion 360 font déjà le job.
Est-ce que Fusion permet de lancer un fraisage pour tailler un engrenage avec un diviseur ?
Dans ce cas, la machine doit juste lire le G-Code comme je proposais.

Cadrature

[Torzio]

Cadrature a écrit:

Bonjour

Comme je disais, ce qui semble difficile pour les uns et simple pour les autres et inversement.
Le programme Basic que vous proposez est très simple. Je n’avais pas touché à Basic depuis plus de 35 ans 😉
Mais les souvenirs me reviennent. On peut optimiser l’algo pour faire plus simple et développer en Python ou en C++ pour faire la même chose.

Si je trouve le temps je vous ferai ça.

On peut embarquer ce programme dans un RasbperryPy oui. Mais la motivation d’utiliser RaspberryPy ne doit pas être dictée par le choix du langage à mon avis, mais par le développement d’une interface plus évoluée. Par exemple une page web ou un programme Java sur le RaspberryPy qui permet de renseigner tous les paramètres de division. Si vous voulez vous débarrasser de l’ordi sur votre machine, c’est une bonne solution.

Plein de configurations sont possibles, il faut voir ce qui est le plus pratique et qui entre dans le budget.

Cadrature

C’est pour cela qu’il est intéressant de partager ses connaissances avec des personnes ayant des compétences différentes, mais complémentaires. Seul, on va plus vite, mais à deux on va plus loin !
Je fais beaucoup de montages avec Arduino, toutefois, je n’ai pas (encore) trouvé le moyen de piloter ma machine à tailler avec, de façon satisfaisante. J’ai commencé à m’initier au Raspberry. Ici une solution très intéressante, le Raspberry est intégré dans le clavier : https://www.reichelt.com/fr/fr/shop/produit/kit_pi_400_raspberry_fr_4x_1_8ghz_4gb_ram_os-290324

Une photo de mon installation :

fraiseuse Proxxon customisée en CN 3 axes. Un diviseur, réalisé par un ami, est fixé sur la table croisée. En bas, à gauche, l’alimentation de l’interface et des PAP et celle de la broche. En haut à gauche un boitier gris, qui contient les drivers des 3 moteurs PAP, relié à mon PC via un port série.
Mon souhait est de remplacer l’unité centrale et le clavier par le clavier Raspberry cité plus haut. Un petit écran d’une quinzaine de pouces fera largement l’affaire.

Photo de mon écran actuel :

@+
JC

[Cadrature]

C’est très réalisable

Un RaspberryPy est un ordinateur comme un autre finalement.

La solution Raspberry demande d’écrire un peu de code pour faire l’interface
pour entrer nombre de dents, profondeur et avance.
Python va bien pour ça si vous ne voulez pas une interface plus complexe.
15 pouces c’est beaucoup. Un écran 7 pouces tactile suffira bien par exemple.

Les solutions modernes existent pour câbler les drivers directement à une carte CNC pour Raspberry. Dans votre cas, si vous ne voulez pas recommencer le montage, vous pouvez brancher la communication série du Raspberry aux drivers comme vous faites avec le PC. Il faut voir comment le montage est réalisé chez vous pour faire de même.

Cadrature

[Cadrature]

Sur mon heure de repas, j’ai fait un peu de code:

Voici du code Python pour faire du GCode à partir du nombre de dents à tailler et quelques paramètres, avance et vitesse de coupe.
Pour passer l’outil, je monte et descends en Z (z-safe pour passer en sécurité au dessus de la coupe, z_depth correspond à profondeur)
Je suis parti du principe que votre réduction était 1/189 avec un moteur nema 17.
Si vous souhaitez en C++, ou sans GCode, dites-le (mais que dois-je envoyer aux moteurs ?)

Il faut configurer le lecteur GCode pour que XZ soient en mm et A en pas.

Pour être transparent comme vous, je me suis fait aider de Copilote pour aller plus vite.

Code:

# Constantes de la machine
STEPS_PER_REV = 200 # nombre de pas du moteur par tour complet
GEAR_RATIO = 189 # rapport de réduction du système à vis sans fin
TOTAL_STEPS = STEPS_PER_REV * GEAR_RATIO # nombre total de pas pour un tour complet de la roue

def generate_gcode(num_teeth, x_advance=10, feed_rate=100, z_depth=20, z_safe=-5):
  """
  Génère le G-code pour tailler une roue dentée avec num_teeth dents
  – num_teeth : nombre de dents de la roue
  – x_advance : course linéaire sur l’axe X pour tailler une dent (mm)
  – feed_rate : vitesse d’avance pour le mouvement en X (mm/min)
  – z_depth : profondeur de coupe (mm)
  – z_safe : position de sécurité en Z (mm, au-dessus de la pièce)
  """
  steps_per_tooth = TOTAL_STEPS / num_teeth # nombre réel de pas pour chaque dent
  acc = 0 # accumulateur pour la partie fractionnaire des pas (algorithme de Bresenham)
  gcode = []

  for i in range(num_teeth):
  # Descente rapide de l’outil à la profondeur de coupe
  gcode.append(f"G0 Z{z_depth} ; Descendre rapidement en Z pour couper")

  # Avance de l’outil pour tailler la dent
  gcode.append(f"G1 X{x_advance} F{feed_rate} ; Avance X pour tailler la dent")

  # Remontée rapide en Z à la position de sécurité
  gcode.append(f"G0 Z{z_safe} ; Remontée rapide en Z")

  # Retour rapide sur X à la position initiale
  gcode.append(f"G0 X0 ; Retour rapide sur X")

  # Calcul du nombre de pas pour le diviseur (Bresenham-like)
  acc += steps_per_tooth
  steps = int(acc) # partie entière des pas à effectuer
  acc -= steps # partie fractionnaire restante pour la dent suivante

  if steps > 0:
  # Passage en mode incrémental pour l’axe A
  gcode.append("G91 ; Passage en mode incrémental pour l’axe A")
 
  # Rotation du diviseur de ‘steps’ pas
  gcode.append(f"G1 A{steps} ; Rotation de l’axe A du diviseur")

  # Retour en mode absolu pour les déplacements suivants
  gcode.append("G90 ; Retour en mode absolu")

  return "\n".join(gcode)

Un peu plus complet:

Code:

# Constantes de la machine
STEPS_PER_REV = 200 # nombre de pas du moteur par tour complet
GEAR_RATIO = 189 # rapport de réduction du système à vis sans fin
TOTAL_STEPS = STEPS_PER_REV * GEAR_RATIO # nombre total de pas pour un tour complet de la roue

def generate_gcode(num_teeth, x_advance=10, feed_rate=100, z_depth=-2, z_safe=5):
  """
  Génère le G-code pour tailler une roue dentée avec num_teeth dents
  – num_teeth : nombre de dents de la roue
  – x_advance : course linéaire sur l’axe X pour tailler une dent (mm)
  – feed_rate : vitesse d’avance pour le mouvement en X (mm/min)
  – z_depth : profondeur de coupe (mm, valeur négative si vers le bas)
  – z_safe : position de sécurité en Z (mm, au-dessus de la pièce)
  """
  steps_per_tooth = TOTAL_STEPS / num_teeth # nombre réel de pas pour chaque dent
  acc = 0 # accumulateur pour la partie fractionnaire des pas (Bresenham-like)
  gcode = []

  # ————————–
  # Séquence d’initialisation
  # ————————–
  gcode.append("; — Début du programme : calibration et mise en route —")
  gcode.append("G21 ; travailler en mm")
  gcode.append("G90 ; mode absolu")
  gcode.append("G28 X0 Z0 A0 ; homing des axes X, Z et A avec les fins de course")
  gcode.append("M17 ; activer les moteurs pas-à-pas")
  gcode.append("M3 S1000 ; démarrer le spindle à 1000 rpm (optionnel)")

  # ————————–
  # Usinage des dents
  # ————————–
  gcode.append("; — Usinage des dents —")
  for i in range(num_teeth):
  gcode.append(f"G0 Z{z_depth} ; descente rapide en Z pour couper")
  gcode.append(f"G1 X{x_advance} F{feed_rate} ; avance pour tailler la dent")
  gcode.append(f"G0 X0 ; retour rapide sur X")
  gcode.append(f"G0 Z{z_safe} ; remontée rapide en Z")

  # Calcul des pas pour l’axe A (Bresenham-like)
  acc += steps_per_tooth
  steps = int(acc)
  acc -= steps

  if steps > 0:
  gcode.append("G91 ; passage en mode incrémental pour l’axe A")
  gcode.append(f"G1 A{steps} ; rotation du diviseur")
  gcode.append("G90 ; retour en mode absolu")

  # ————————–
  # Séquence de fin
  # ————————–
  gcode.append("; — Fin du programme : arrêt du spindle et retour —")
  gcode.append(f"G0 Z{z_safe} ; remonter en Z à la position de sécurité")
  gcode.append("G28 X0 Z0 A0 ; retour à l’origine")
  gcode.append("M5 ; arrêter le spindle")
  gcode.append("M18 ; désactiver les moteurs pas-à-pas")

  return "\n".join(gcode)

Testé avec 11 dents:

Code:

G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3437 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3437 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3437 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3436 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu
G0 Z20 ; Descendre rapidement en Z pour couper
G1 X10 F100 ; Avance X pour tailler la dent
G0 Z-5 ; Remontée rapide en Z
G0 X0 ; Retour rapide sur X
G91 ; Passage en mode incrémental pour l’axe A
G1 A3437 ; Rotation de l’axe A du diviseur
G90 ; Retour en mode absolu

Version plus complète:

Code:

; — Début du programme : calibration et mise en route —
G21 ; travailler en mm
G90 ; mode absolu
G28 X0 Z0 A0 ; homing des axes X, Z et A avec les fins de course
M17 ; activer les moteurs pas-à-pas
M3 S1000 ; démarrer le spindle à 1000 rpm (optionnel)
; — Usinage des dents —
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3437 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3437 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3437 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3436 ; rotation du diviseur
G90 ; retour en mode absolu
G0 Z-2 ; descente rapide en Z pour couper
G1 X10 F100 ; avance pour tailler la dent
G0 X0 ; retour rapide sur X
G0 Z5 ; remontée rapide en Z
G91 ; passage en mode incrémental pour l’axe A
G1 A3437 ; rotation du diviseur
G90 ; retour en mode absolu
; — Fin du programme : arrêt du spindle et retour —
G0 Z5 ; remonter en Z à la position de sécurité
G28 X0 Z0 A0 ; retour à l’origine
M5 ; arrêter le spindle
M18 ; désactiver les moteurs pas-à-pas

Cadrature

[Torzio]

Waouh ! Ca bosse fort !

Ca va trop vite pour moi, mais je pense que ce sera très utile pour Vir.
J’ai trouvé un écran intéressant : écran tactile.

J’ai demandé à Qwen 2.5 de me transcrire mon programme en Python. Il faut que j’essai d’assimiler tout cela.

Dès que j’en trouve temps et le courage, je vais demander à l’IA des choses très simples en Python, pour bien maîtriser la commande des PAP, comme je l’avais fait avec Basic, avant d’aller plus loin. Comme ma machine fonctionne parfaitement bien, je n’ai pas d’urgence à la remplacer.
Si l’IA avait existé il y a 20 ans, j’aurais fait des choses extraordinaires.
J’espère que cette discussion va donner envie à des jeunes de se lancer dans cette aventure qui peut déboucher sur de la création horlogère, comme c’est le projet de Vir.

@+
JC

@+
JC

[Cadrature]

Torzio a écrit:

Waouh ! Ca bosse fort !

Ca va trop vite pour moi, mais je pense que ce sera très utile pour Vir.
J’ai trouvé un écran intéressant : écran tactile.

J’ai demandé à Qwen 2.5 de me transcrire mon programme en Python. Il faut que j’essai d’assimiler tout cela.

Dès que j’en trouve temps et le courage, je vais demander à l’IA des choses très simples en Python, pour bien maîtriser la commande des PAP, comme je l’avais fait avec Basic, avant d’aller plus loin. Comme ma machine fonctionne parfaitement bien, je n’ai pas d’urgence à la remplacer.
Si l’IA avait existé il y a 20 ans, j’aurais fait des choses extraordinaires.
J’espère que cette discussion va donner envie à des jeunes de se lancer dans cette aventure qui peut déboucher sur de la création horlogère, comme c’est le projet de Vir.

@+
JC

@+
JC

Ah oui, il est bien cet écran j’ai l’impression. Moi, j’avais vu un 7 pouces de moindre qualité qui irait bien aussi pour moins cher. A voir l’usage.

Je crois que Vir est parti sur une autre piste et se satisfera d’un système GRBL Arduino Uno minimaliste à ce que j’ai compris.

J’ai repris votre programme Basic en le simplifiant et en changeant l’algorithme.
Si vous deviez refaire ce système, à mon avis, il faut oublier votre programme original et ne pas tenter de le traduire en Python.
L’algorithme que vous avez écrit consistant à construire un tableau et à appliquer une division de l’écart final pour le corriger donnait
certes un résultat correct, mais c’est compliqué et imparfait.
L’usage de l’algorithme de Bresenham qui permet de projeter une droite sur un graphe d’entiers est plus propre. C’est ce que j’ai fait.

Si vous me dites comment vous voulez commander vos drivers pas-à-pas, je vous construis le programme sans G-code et avec le langage que vous souhaitez. Il faut juste ouvrir une communication UART vers vos drivers, et je ne sais pas ce que vous faites de ce côté (lecture des fichiers Dxx.txt)

Je vous ai dit, pour des jeunes ou moins jeunes comme moi, le plus difficile pour réaliser un diviseur est de trouver à réformer un
tour Lorch sans se ruiner et à le monter juste sans avoir ni jeu ni flexion.
Le reste, c’est 200 euros d’achat et quelques jours de programmation sans aucune peine.

Cadrature

[Torzio]

Avec tout ça, je viens de commander un clavier AZERTY avec un Raspberry incorporé, le Raspberry PI 400, J’ai commandé aussi un écran 7 pouce, non tactile, puisque j’ai un clavier. Le tout pour 110 € environ. J’en ai déjà des Raspberry normaux avec un écran ordinaire qui m’attendent, mais j’aime bien cette configuration.
Le code que vous avez ne me sert pas à tailler les roue, mais simplement à créé un fichier texte pour chaque nombre de dents, avec un nombre de pas entier, pour un total de 37800 pas. Je ne me souviens pas d’avoir publié le code pour le taillage 3 axes.
Le principe est d’avoir un dossier, dans lequel il y a le programme de commande de la machine à tailler et 99 fichiers .dat de 2 à 99 dents, c’est fichiers ont été généré avec le programme que vous avez (certainement ). Lorsque vous avez lancé le programme et renseigné le nombre de dents, il va chercher le fichier .dat correspondant et stock les données, pour les envoyer ensuite, une à une à l’interface qui gère les moteurs.
Dans un premier temps, je veux faire simple et m’occuper uniquement de la division, le reste se fera manuellement. J’ai deux diviseurs de la sorte, celui que j’ai fait avec un tour Lorch et un autre dont je me sers pour faire des alliances diamants : https://sulka.fr/albt/. Une fois que je maîtriserai bien, avec Raspberry, je passerai aux axes X et Y. Mais ce sera sûrement pas avant cet hiver.

Concernant la transformation d’un tour Lorch en diviseur, mon objectif était de rassembler des bonnes volontés et compétences afin de créer des plans et de trouver des sous-traitants pour usiner les pièces. Ainsi, on aurait alors un kit qu’il suffirait simplement d’assembler. Mais ce serait uniquement pour la division, le taillage d’engrenages. Cet ensemble pourrait alors être fixé sur une table croisée.

@+
JC

[Torzio]

@Cadrature,

J’ai demandé à une IA de me convertir mon programme de taillage, de Basic vers Python. Ici le résultat : http://sulka.fr/mat9/Prompt_MAT.odt Si vous avez du temps à perdre…
Je n’ai pas encore tout regardé, toutefois, il y a des erreurs que je ne comprends pas concernant les fichiers. Aurais-je dû les joindre ?
Je pense que, comme le Python est nouveau pour moi et que le neurone commence à être poussif je vais commencer doucement et demander à l’IA de faire tourner un seul moteur, dès que j’en trouve le temps
@+
JC

[Cadrature]

Je ne comprends pas la réponse de l’IA.

A mon avis, je répète qu’il faut oublier les fichiers Dxx.txt et ne pas hésiter à changer
de programme pour faire plus simple.

Comment conduisez-vous actuellement les moteurs pas-à-pas depuis votre PC ?
Quels sont vos drivers ?

Avec la réponse à cette question, je peux vous dire le programme à mettre dans votre RaspberryPi.

@Vir
Attention qu’un Uno avec un simple CNC Shield suffise dans l’avenir si vous deviez ajouter des options ou même un axe plus tard.
Moi j’ai utilisé Arduino Mega + Ramps 1.6 dans mes derniers projets. Ce n’est pas beaucoup plus cher et ça permet de commander plusieurs
accessoires DC PWM à 12v sans ajouter d’électronique (ventilation, pompe à lubrifiant, rampe de lumières)
et d’avoir encore de la place pour d’autres périphériques optionnels (leds, boutons, arrêt d’urgence, détecteurs de fin de course, détecteur de porte ouverte, etc)

Cadrature

[Torzio]

Cadrature a écrit:

Je ne comprends pas la réponse de l’IA.

A mon avis, je répète qu’il faut oublier les fichiers Dxx.txt et ne pas hésiter à changer
de programme pour faire plus simple.

Comment conduisez-vous actuellement les moteurs pas-à-pas depuis votre PC ?
Quels sont vos drivers ?

Avec la réponse à cette question, je peux vous dire le programme à mettre dans votre RaspberryPi.

@Vir
Attention qu’un Uno avec un simple CNC Shield suffise dans l’avenir si vous deviez ajouter des options ou même un axe plus tard.
Moi j’ai utilisé Arduino Mega + Ramps 1.6 dans mes derniers projets. Ce n’est pas beaucoup plus cher et ça permet de commander plusieurs
accessoires DC PWM à 12v sans ajouter d’électronique (ventilation, pompe à lubrifiant, rampe de lumières)
et d’avoir encore de la place pour d’autres périphériques optionnels (leds, boutons, arrêt d’urgence, détecteurs de fin de course, détecteur de porte ouverte, etc)

Cadrature

Je souhaite absolument garder mes fichiers data. Cela simplifie le programme, pour les nombres de dents qui n’auraient pas de résultats entiers. Ce ma permet aussi de dupliquer et modifier légèrement le programme, pour tailler une came, un limaçon ou un chaperon, avec le fichier data qui va bien, comme ici : https://famontres.com/forums/topic/fabrication-d-un-chaperon-sur-un-mouvement-de-cartel/
Je reste persuadé qu’avec le Raspberry on peut lire les variables contenues dans un fichier et de les mettre en mémoire, pour les utiliser ensuite une à une. J’avais commencé à le faire, mais je suis passé à autre chose, comme ma machine fonctionnait et fonctionne toujours parfaitement. Mais le projet de Vir me titille et me donne envie de reprendre ce projet avec Raspberry.

J’ai utilisé des cartes de puissance de l’époque : https://sulka.fr/mat9/Carte_de_puissance.pdf Mais n’importe quelle carte de puissance peut convenir, à mon avis, à condition qu’elle soit adaptée à la puissance du moteur. Aujourd’hui il existe un très grand choix de carte de puissance. Lorsque j’ai construit ma première machine à tailler, elles n’existaient pas à un prix abordable. J’ai dû les fabriquer : https://www.sulka.fr/mat4/

Pour info, le GPIO du Raspberry dispose de 40 broches, dont 16 disponibles !

Mon maître d’apprentissage me disait souvent : « un bon horloger doit savoir tout faire ».

@+
JC

[Cadrature]

Je ne vais pas vous faire changer d’avis JC 😉
Vous avez vu que mon programme gère correctement les nombres entiers de pas ?
Pour créer un chaperon ou un colimaçon, les choses ne me semblent pas beaucoup plus difficiles.

Je me demande si des gens de la communauté sont intéressés à réaliser un diviseur
avec le montage de JC et une petite électronique avec interface pour réaliser roues,
pignons, roues d’échappement (hors cylindre ;-), colimaçons, chaperons, cames (équation du temps) ?

Si oui, on peut se lancer dans un petit projet, c’est à étudier…

Concernant les cartes de puissance, il existe aujourd’hui des composants tout fait comme A4988, DRV8825, etc. Suffisants pour
Nema 17.
Ils se branchent directement sur des cartes CNC et vraiment il n’est plus besoin de savoir quoi que ce soit en électronique.
Pour l’informatique c’est pareil, on utilise des bibliothèques de logiciels qui savent gérer les moteurs pas-à-pas.
Ça simplifie la vie et c’est très économique.

Cadrature

[Hypnos]

Torzio a écrit:

@Cadrature,

J’ai demandé à une IA de me convertir mon programme de taillage, de Basic vers Python. Ici le résultat : http://sulka.fr/mat9/Prompt_MAT.odt
JC

Heureusement que mes étudiants programmaient plus proprement quand j’étais prof d’info. Mais peut-être que le Raspberry ne connait pas la programmation structurée. J’interdisais les sauts inconditionnels (GOTO …) qui rendent parfois les programmes cauchemardesques à maintenir et modifier.

Je me posais justement des questions, en ce jour de pré-rentrée des profs, pour savoir comment je ferais cours avec la présence toujours plus grande de l’IA. Au vu de la production de celle-ci je pense qu’il y a encore un peu de méthodologie à faire passer aux futurs ingénieurs …

[Auteur]

Messages