fabrication d’une fraiseuse cnc home made

[Cadrature]

Hypnos a écrit:

Mais peut-être que le Raspberry ne connait pas la programmation structurée.

Un RaspberryPi est un ordinateur avec processeur AMD qui tourne sous Linux.

À peu près tous les langages structurés récents peuvent tourner sur un RaspberryPi.
Donc on peut aujourd’hui oublier GOTO, JMP, JNE, JE, etc. de nos jeunesses.

@Vir
Désolé…

[Hypnos]

Cadrature a écrit:

À peu près tous les langages structurés récents peuvent tourner sur un RaspberryPi.
Donc on peut aujourd’hui oublier GOTO, JMP, JNE, JE, etc. de nos jeunesses..

Je m’en doutais un peu mais comme j’ai terminé ma carrière en enseignant avec des PC …
Dans ma vie d’ingénieur, avant d’enseigner, j’ai connu à peu près tous les modes d’interaction avec les machines: ruban perforé, programmation aux clés sur un calculateur embarqué, cartes perforées, bandes, disquettes etc sur plein des vieux langages (assembleur, Cobol, Basic, Fortran, Pascal, C, C++, Python à la fin…)

[Vir]

Pas de problème Cadrature,
C’est très intéressant ! Et de toutes façons je vais certainement faire comme JC acheter tout ça !
D’ailleurs, si JC pouvait me dire ou il a acheté l’ensemble ce serait cool. (merci d’avance)
Quand la machine sera à nouveau fonctionnelle, ce sera la prochaine étape pour moi

Je sens que je vais me faire avoir

Vir

[Cadrature]

Ce sera quoi votre installation ?

– Machine: Uno + CNC Shield – RGBL, autre ?
– Pilote: RaspberryPi + écan tactile + USB, SD, Web – bCNC, CNCJs, autre ?

Cadrature

[Torzio]

Vir a écrit:

Pas de problème Cadrature,
C’est très intéressant ! Et de toutes façons je vais certainement faire comme JC acheter tout ça !
D’ailleurs, si JC pouvait me dire ou il a acheté l’ensemble ce serait cool. (merci d’avance)
Quand la machine sera à nouveau fonctionnelle, ce sera la prochaine étape pour moi

Je sens que je vais me faire avoir

Vir

@Vir,

Dans un premier temps, ma méthode ne vous sera pas d’une grande utilité. Il vaudrait la piloter en GCODE et Arduino va très bien pour ça.

Si après vous décidez de l’équiper d’un diviseur, en vue de tailler des engrenages, là, mon système serait, à mon avis idéal.
On pourra alors discuter pour optimiser la réalisation d’un diviseur à partir d’un tour Lorch, c’est à mon avis le plus simple, le plus économique et le plus fiable. Je vous donnerai alors mon programme en Basic (plein de GOTO), mais qui fonctionne parfaitement depuis plus de 20 ans. Je ne suis pas ingénieur, mais simplement ingénieux. Mais il vous faudra un vieux PC avec un port série pour piloter le diviseur avec Basic. A moins que d’ici là, j’ai eu l’opportunité de traduire ou de faire traduire, comme je l’entends, mon programme Basic en Python. Dans ce cas, le Raspberry conviendra. Vous pourrez alors aussi bien piloter votre CNC en GCODE pour de l’usinage 3D ou, avec mon principe, tailler des engrenages.

J’ai commandé le Raspberry PI 400 ici et l’écran 7 pouces non tactile ici. Cet accessoire peut être très utile.

Je reste à votre entière disposition pour partager mon expérience dans le taillage des engrenages.

@+
JC

[Cadrature]

Mais JC, j’admire votre diviseur basé sur un Lorch, et votre expérience horlogère en taillage d’engrenages et autres.
Mais de grâce ne restez pas bloqué sur votre programme en Basic !

Si vous y tenez, voici votre programme Basic écrit en Python
qui fait les fichiers Dxx.txt de 1 à 99 qui sont inutiles:

Code:

for i in range(1, 99):
  with open(f"D{i}.txt", "w") as f:
  steps_per_tooth = 37800 / i
  acc = 0
  for j in range(i):
  acc += steps_per_tooth
  steps = int(acc)
  acc -= steps
  if steps > 0:
  f.write(f"{steps}\n")

Lancez ceci ça va créer vos fichiers D1.txt, D2.txt, … D99.txt dans le dossier courant. What else ?

[Torzio]

Merci Cadrature,

Dommage que cela ne soit pas en français. Je vais essayer d’essayer ça ce we. Mais je n’en ai pas vraiment besoin, puisque mes fichiers.dat existent, je l’ai ai déjà fait en Basic, il y a très longtemps. Mais ce sera pour le fun. Il faut que je remette mon Raspberry, qui prend la poussière, en route, cela me permettra de lui donner du « grain à moudre » ! En attendant le PI400 intégré dans un clavier AZERTY et l’écran 7 pouces.

Ce qui m’intéresserai, ce serai d’avoir un programme Python, uniquement pour faire tourner la broche, pour la division. Soit avec ma méthode, en allant chercher les donner dans un fichier, soit avec la votre en calculant avec le programme.

Voici ce qu’envoie mon programme à l’interface à PIC 16F84, qui pilote les moteurs PAP, via le port série :

===================================

OPEN « COM2:2400,N,8,1,rs » FOR RANDOM AS #1

SENS = 2 ‘recul profondeur
NP = prof * 50
MOT = 1
PRINT #1, « X », SENS, NP, MOT
INPUT #1, R

FOR t = 1 TO d

SENS = 2 ‘diviseur
NP = V(t)
MOT = 3
PRINT #1, « X », SENS, NP, MOT

INPUT #1, R

SENS = 1 ‘avance profondeur
NP = prof * 50
MOT = 1
PRINT #1, « X », SENS, NP, MOT
INPUT #1, R

SENS = 1 ‘avance avance
NP = av * 50
MOT = 2
PRINT #1, « X », SENS, NP, MOT
INPUT #1, R

SENS = 2 ‘recul profondeur
NP = prof * 50
MOT = 1
PRINT #1, « X », SENS, NP, MOT
INPUT #1, R

SENS = 2 ‘recul avance
NP = av * 50
MOT = 2
PRINT #1, « X », SENS, NP, MOT
INPUT #1, R

PRINT « taille dent « ; t;  » terminee sur « ; d

NEXT t
=============================
R = acquittement de l’interface.

@+
JC

[Cadrature]

Mais vous disiez vouloir traduire votre programme Basic en Python… Je ne comprends plus rien.

[Torzio]

Cadrature a écrit:

Mais vous disiez vouloir traduire votre programme Basic en Python… Je ne comprends plus rien.

Pas pour la création de fichiers .dat ! Mais pour piloter les moteurs PAP, à partir des données contenues dans les fichiers .dat.
Afin de commander ma machine à tailler avec Raspberry.
Dans mon message précédent, je vous ai envoyé la routine qui envoie les infos à la machine à tailler, issus de mon programme en Basic, pour piloter les moteurs PAP.

@+
JC

[Cadrature]

OK, je comprends mieux.

Le système qui est branché à votre PC par le port série a certainement été programmé dans le microcontoleur PIC par votre ami et attend des commandes du type
X 2 100 1
…
Il envoie des signaux d’acquittement (des nombres ?).

Finalement vous avez fait un système très proche d’un système qui lit du G-Code !

J’imagine que c’est ce PIC qui fonctionne bien et que vous ne voulez pas retoucher. Je comprends.
Si je sais précisément les commandes qu’il attend, je peux faire le programme en Python.
Il me manque des éléments. Par exemple le contenu du tableau V (j’imagine que c’est le tableau contenu dans Dxx.dat) ou ce que désigne MOT.

Cadrature

[Torzio]

Cadrature a écrit:

OK, je comprends mieux.

Le système qui est branché à votre PC par le port série a certainement été programmé dans le microcontoleur PIC par votre ami et attend des commandes du type
X 2 100 1
X ce doit être un protocole pour la liaison série. Il faudrait que je me remette dans le bain, cela fait plus de 20 ans que j’ai écrit ce programme ! SENS, NP, MOT = SENS (avant ou arrière), NP = nombre de pas, MOT = moteur X, Y ou Z , je crois que c’est 1, 2 et 3, il faut que je regarde. C’est moi qui ai programmé le microcontrôleur, toujours en Basic mais compilé.

…
Il envoie des signaux d’acquittement (des nombres ?).

Normalement, lorsque le PIC a terminé sa mission et que la dent est taillée, il envoie un signal au PC, pour recevoir les infos pour la dent suivante.
Il faut que je retrouve le programme que j’ai mis dans le PIC, pour plus de précision. Mais avec le Raspberry, plus besoin d’interface à PIC.

Finalement vous avez fait un système très proche d’un système qui lit du G-Code !

Possible, je ne connais pas le GCODE. On dit que les grands esprits se rencontrent !

J’imagine que c’est ce PIC qui fonctionne bien et que vous ne voulez pas retoucher. Je comprends.
Si je sais précisément les commandes qu’il attend, je peux faire le programme en Python.
Il me manque des éléments. Par exemple le contenu du tableau V (j’imagine que c’est le tableau contenu dans Dxx.dat) ou ce que désigne MOT.

Concernant V(t) c’est la valeur indexée contenue dans le fichier et qui devient NP (nombre de pas).
L’interface à PIC fonctionne parfaitement bien, mais je peux la modifier sans problème, si besoin. Toutefois, avec le Raspberry, on n’en a plus besoin ! Vu le nombre de PINs GPIO disponibles, on connecte directement les drivers au GPIO, plus besoin de liaison série !
Ce qui serait bien, ce serait de nous concocter, dans un premier temps, un code Python, pour un seul axe : la rotation de la broche du diviseur. Cela nous permettrait de mettre doucement « les mains dans le cambouis » et de mieux comprendre les choses !
Il faudrait qu’une fois le nombre de pas effectué, le programme attende l’appui sur une touche, pour faire la division suivante.

Il y a peut-être quelques erreurs, je cite de mémoire, cela fait 20 ans que j’ai pondu ça en autodidacte, certaines choses demandent peut-être à être vérifiées, mais dans le principe c’est bon.

@+
JC

Citation :

Cadrature

[Cadrature]

Bien qu’il existe pléthore de GPIO sur la carte RaspberryPi, il est paradoxalement plus simple de faire le contrôleur avec un Arduino comme vous aviez fait avec le PIC.
Il y a deux raisons à cela:

a) Premièrement la programmation des moteurs est plus compliquée sous Python que sous C++ en absence de bibliothèques dédiées.
Les bibliothèques Arduino sont beaucoup plus souples. Par exemple il est possible de programmer
les accélérations des moteurs ou des remises à zéro par touches rapides et lentes.

b) Deuxièmement, les trains d’impulsions envoyés aux moteurs pas-à-pas doivent être à fréquence élevée sans interruption. Un RaspberryPi qui fait tourner un système d’exploitation Linux va avoir du mal à gérer ces trains d’impulsions en temps réel. Vos moteurs vont vibrer, stopper, sauter.

Je vous recommande donc de conserver deux systèmes:

– PIC ou remplacer par Arduino avec un CNC Shield pour vous mettre à la page (quelques euros sans compter l’alimentation 12V)
– RaspberryPi avec clavier et écran pour le contrôle

Je peux vous faire le code pour ces deux systèmes avec un seul axe et vous montrer les branchements, c’est très simple.
Vous voulez ?

[Torzio]

Cadrature a écrit:

Bien qu’il existe pléthore de GPIO sur la carte RaspberryPi, il est paradoxalement plus simple de faire le contrôleur avec un Arduino comme vous aviez fait avec le PIC.

Désolé, je ne partage pas cet avis. Il me semble que les PIN GPIO sont parfaitement identifiés.

Il y a deux raisons à cela:

a) Premièrement la programmation des moteurs est plus compliquée sous Python que sous C++ en absence de bibliothèques dédiées.
Les bibliothèques Arduino sont beaucoup plus souples. Par exemple il est possible de programmer
les accélérations des moteurs ou des remises à zéro par touches rapides et lentes.

b) Deuxièmement, les trains d’impulsions envoyés aux moteurs pas-à-pas doivent être à fréquence élevée sans interruption. Un RaspberryPi qui fait tourner un système d’exploitation Linux va avoir du mal à gérer ces trains d’impulsions en temps réel. Vos moteurs vont vibrer, stopper, sauter.

Cela me fait penser à une phrase de Mark Twain : « Ils ne savaient pas que c’était impossible, alors ils l’ont fait. ». Issu d’un milieu très modeste, je n’ai pas eu le privilège d’être poursuivi par les études, j’ai donc appris seul. J’ai commencé à bidouiller avec les moteurs PAP, les PIC et les EEPROM, dans les années 1990; J’ai même réalisé un automate piloté par des moteurs PAP et une EEPROM, qui montrait un clown dresseur de papillon. J’en ai fait cadeau à un ami. Il faut que je retrouve la vidéo. J’ai envoyé la vidéo à Reuge à Saint Croix, en Suisse et j’ai été invité à le présenter pour le bicentenaire de la boîte à musique. Comme je n’étais pas sûr du fonctionnement de mon automate sur la durée, j’ai décidé d’en faire en second :

Fort de ces expériences réussies, j’ai décidé de me lancer dans la fabrication d’une machine à tailler.

Citation :

Je vous recommande donc de conserver deux systèmes:

– PIC ou remplacer par Arduino avec un CNC Shield pour vous mettre à la page (quelques euros sans compter l’alimentation 12V)
– RaspberryPi avec clavier et écran pour le contrôle

Pour utiliser au maximum le potentiel de Raspberry et pour simplifier, comme le disait Léonard de Vinci, « la simplicité est la sophistication suprême », je préfère connecter directement les drivers sur le GPIO.

Je peux vous faire le code pour ces deux systèmes avec un seul axe et vous montrer les branchements, c’est très simple.
Vous voulez ?

Oui, mais il n’y a pas urgence, en ce qui me concerne. il faut que je trouve le temps de remettre mon Raspberry en marche. Mais je vais toutefois, de ce pas, demander à l’IA de m’écrire un code, ça prends moins de temps.

Citation :

@+
JC

Edit, voici le code de Qwen :

Voici un programme Python conçu pour fonctionner sur un **Raspberry Pi 4**, qui :

1. Lit un fichier nommé `D11` contenant des **nombres de pas** (sous forme de texte, un par ligne),
2. Convertit ces valeurs en entiers,
3. Envoie ces valeurs à un **driver de moteur pas à pas** (comme un A4988, DRV8825, etc.) via des GPIO,
4. Utilise la bibliothèque `RPi.GPIO` pour contrôler le moteur.

—

### ️ Matériel requis :
– Raspberry Pi 4
– Moteur pas à pas (ex : NEMA 17)
– Driver de moteur pas à pas (ex : A4988 ou DRV8825)
– Alimentation adaptée
– Câblage :
– Broche `STEP` du driver → GPIO 18 (BCM)
– Broche `DIR` du driver → GPIO 17 (BCM)
(Tu peux modifier les broches selon ton montage)

—

### Programme Python

« `python
#!/usr/bin/env python3

import RPi.GPIO as GPIO
import time
import os

# Configuration
FICHIER_D11 = « D11 » # Nom du fichier contenant les pas
STEP_PIN = 18 # GPIO pour la broche STEP
DIR_PIN = 17 # GPIO pour la broche DIR
DELAY = 0.001 # Délai entre chaque pas (ajuster selon moteur)

# — Initialisation GPIO —
GPIO.setmode(GPIO.BCM)
GPIO.setup(STEP_PIN, GPIO.OUT)
GPIO.setup(DIR_PIN, GPIO.OUT)

def tourner_moteur(direction, steps):
«  » »
Fonction pour faire tourner le moteur.
direction: True = horaire, False = anti-horaire
steps: nombre de pas à effectuer
«  » »
GPIO.output(DIR_PIN, GPIO.HIGH if direction else GPIO.LOW)
print(f »Rotation {‘horaire’ if direction else ‘anti-horaire’}, {steps} pas »)

for _ in range(steps):
GPIO.output(STEP_PIN, GPIO.HIGH)
time.sleep(DELAY)
GPIO.output(STEP_PIN, GPIO.LOW)
time.sleep(DELAY)

def lire_fichier_d11():
«  » »
Lit le fichier D11 et retourne une liste d’entiers (nombre de pas).
Une ligne = un nombre de pas.
Exemple :
200
-100
50
Les nombres négatifs indiquent une rotation inverse.
«  » »
if not os.path.exists(FICHIER_D11):
print(f »Erreur : Le fichier {FICHIER_D11} n’existe pas. »)
return []

steps_list = []
with open(FICHIER_D11, ‘r’) as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line or line.startswith(‘#’): # ignore lignes vides ou commentées
continue
try:
pas = int(line)
steps_list.append(pas)
except ValueError:
print(f »Ligne {line_num} ignorée : ‘{line}’ n’est pas un nombre valide. »)
return steps_list

def main():
print(« Lecture du fichier D11… »)
ordres = lire_fichier_d11()

if not ordres:
print(« Aucune commande valide trouvée dans D11. »)
return

print(f »{len(ordres)} commande(s) trouvée(s). Exécution… »)

for pas in ordres:
if pas > 0:
tourner_moteur(direction=True, steps=pas)
elif pas < 0:
tourner_moteur(direction=False, steps=abs(pas))
else:
print(« 0 pas – rien à faire. »)
time.sleep(0.5) # pause entre les mouvements

print(« Exécution terminée. »)

# — Point d’entrée —
if __name__ == « __main__ »:
try:
main()
except KeyboardInterrupt:
print(« \nArrêt par utilisateur. »)
except Exception as e:
print(f »Erreur : {e} »)
finally:
GPIO.cleanup() # Libère les GPIO
« `

—

### Exemple de contenu du fichier `D11` :

« `text
# Fichier D11 – ordres de mouvement
200 # avance de 200 pas
-100 # recule de 100 pas
50 # avance de 50 pas
« `

—

### Installation et exécution

1. **Installe RPi.GPIO** (normalement déjà présent) :
« `bash
sudo apt update
sudo apt install python3-rpi.gpio
« `

2. **Crée le fichier D11** dans le même répertoire que le script :
« `bash
echo -e « 200\n-100\n50 » > D11
« `

3. **Lance le script** :
« `bash
python3 moteur_pas_a_pas.py
« `

—

### Permissions
Assure-toi d’exécuter le script avec les droits nécessaires (souvent `sudo` si tu as des erreurs GPIO).

—

### Personnalisation possible
– Changer `DELAY` pour régler la vitesse.
– Ajouter des microsteps via les broches `MS1`, `MS2`, `MS3` du driver.
– Ajouter une broche `ENABLE` si nécessaire.

—

Souhaites-tu que j’ajoute la gestion des **microsteps**, un bouton d’arrêt d’urgence, ou une interface web ?

[Torzio]

J’ai amélioré le prompt et ici vous pourrez télécharger le nouveau code.

C’est fabuleux, comme avec l’IA on devient intelligent face à un analphabète numérique !

Toutefois, il faut maintenant passer à la pratique et ça, l’IA ne sait pas encore faire !

@+
JC

[Cadrature]

Remarquez que je ne donne pas d’avis, mais que j’essaie de justifier ma méthode.
Je n’ai pas dit que les GPIO n’étaient pas identifiés; j’ai donné deux points qui
posent problème:
– synchronisation de l’horloge
– absence de bibliothèque pour améliorer la commande moteur (par exemple pour remise à zéro ou accélérations)

Il est possible de faire comme vous dites. Je n’ai pas essayé, il faudrait faire l’essai.
Peut-être en baissant la fréquence, quitte à faire un système bruyant (il me semble que vous êtes à 500Hz avec votre code).
Explication:
time.sleep(DELAY) n’est pas précis sous RaspberryPi, il dépendra de la charge du système d’exploitation.
Il faut plutôt utiliser un train d’impulsions généré par une horloge interne.
Le mieux pour faire comme vous faites, est d’utiliser l’hardware PWM de RaspberryPy.
Voyez ce lien : PWM périodique

L’IA nous aide considérablement, mais il faut la diriger et surtout l’exploiter avec une certaine critique.

@Hypnos
Ce que j’observe avec les étudiants, c’est que l’usage de l’IA creuse les différences. Il y a ceux qui utilisent l’IA pour
faire leur travail à leur place, et ceux qui exploitent l’IA pour s’améliorer encore.
Nous accompagnons aujourd’hui les étudiants face à l’usage de cet outil, mais ce n’est pas gagné.

Cadrature

[Auteur]

Messages