Diviseur numérique

[Cadrature]

Torzio a écrit:

Bonsoir Cadrature,
Merci pour votre intérêt au projet.
Cahier des charges : un écran, un clavier, une unité centrale avec une mémoire morte pour stocker les paramètres des différents nombres de dents, 3 drivers pour les moteurs PAP. Jpbbricole, qui est un spécialiste de l’Arduino m’a fait un sketch qui fonctionne bien, mais qui n’est pas aussi performant que mon systéme sur Windows XP, qui fonctionne en Basic.
Ce que je souhaite c’est reproduire la même chose qu’avec mon PC mais en moins encombrant.
Dans un premier temps, j’aurais besoin de quelques lignes de code pour lire des données dans un fichier (nombre de pas) et de faire tourner un moteur PAP de ce nombre de pas.
Merci d’avance.
JC

Bonjour

Je ne comprends pas en quoi la programmation de l’Arduino n’est pas aussi performante que le système sous PC.
On peut programmer un « sketch » (qui est un bout de code C++) qui fait largement ce que fait un programme écrit en Basic.
C’est même plutôt simple car on utilise des bibliothèques non disponibles en Basic.

Vous pouvez m’envoyer le code Basic (ou un fichier contenant la description du projet) ? Ça me permettra d’y voir plus clair et de voir pourquoi votre programme sur PC est plus performant que le « sketch ».

J’avais bien dans mes cartons l’idée de faire un tel projet (avec un Lorch 6mm de récupération). La partie gestion de projet,
électronique et informatique ne me posent pas de problème. Bizarement, c’est plutôt la partie mécanique qui me semble compliquée.

Pour respecter le cahier des charges, j’imagine assez bien un boitier autonome (sans liaison PC autre qu’au moment de son flash) qui enferme les éléments électroniques:

– Ecran LCD
– Clavier numérique (pour sélectionner rapidement)
– Encodeur rotatif (pour programmer rapidement un nombre)
– Arduino
– Alimentation, interrupteurs et LEDs
– Fiches pour USB, Alimentation, moteurs pap et éventuellement interrupteurs de fin de course

La programmation de l’ensemble des éléments (y compris la vitesse des moteurs, leur sens de rotation, la durée des pause, etc.) se ferait alors directement à partir du clavier numérique ou de l’encodeur rotatif.

Exemple (ce n’est qu’un exemple rapidement imaginé) pour la taille d’un pinion:
– Choisir un programme fraisage pinion par exemple « A1 » après avoir positionné le chariot croisé XYZ dans sa position initiale à la main (pas de couple sur les pap) (XY étant un chariot croisé, Z étant un chariot vertical portant un module de fraisage par exemple), enregistrer
– Positionner le chariot dans sa position finale de fraisage (X), enregistrer

– Positionner le chariot dans sa position de changement de pas (Z), enregistrer
– Positionner sur un point intermédiaire avant remise à zéro (X, Z), enregistrer
– Programmer le pas en nombre de dents, enregistrer
– Programmer la vitesse d’avance de fraisage, enregistrer
– Programmer la vitesse d’avance retour au point initial, enregistrer
– Programmer la vitesse d’avance rotation, enregistrer

A1 fera une série de séquences
– Avance lente X
– Recul rapide Z
– Avance rapide Rotation
– Recul rapide X
– Avance rapide Z

Et ainsi programmer quelques « programmes » (A, B, C…), et pour chacun des séquences spécifiques.

L’idée est de ne pas faire un truc aussi universel qu’un interpréteur de code G mais de faire beaucoup plus simple que
la liaison série depuis votre PC.
L’interprétation de code G par l’Arduino est une alternative, mais plus lourde du point de vue de cet interpréteur et du programme qui produit le code G sur le PC.

Bien évidemment on peut faire la même chose avec un RaspberryPi ou un Odroid et la puissance permettrait de programmer
un plus grand nombre de programmes (la place EPROM d’un microcontroleur de type ATMega328P est très limitée).

Cadrature

[Torzio]

Bonjour Cadrature,

Ici mon diviseur avec Arduino. Sketch conçu par Jpbbricole : ICI
Je m’en sers pour fabriquer les alliances diamants.

Pour plusieurs raisons je suis arrivé à la conclusion qu’il est préférable d’avoir des fichiers correspondants aux roues à tailler, plutôt que de les calculer à chaque fois. Cela est préférable dans le cas du taillage d’une roue de compte, par exemple ou d’un limaçon. Cela fait 20 ans que je fonctionne ainsi et je n’ai pas à m’en plaindre. Le seul problème est que mon vieux PC me prends de la place.

Je vais essayer de mettre aujourd’hui en ligne mon fichier Basic.

@+
JC

[Cadrature]

Torzio a écrit:

Bonjour Cadrature,

Ici mon diviseur avec Arduino. Sketch conçu par Jpbbricole : ICI
Je m’en sers pour fabriquer les alliances diamants.

Pour plusieurs raisons je suis arrivé à la conclusion qu’il est préférable d’avoir des fichiers correspondants aux roues à tailler, plutôt que de les calculer à chaque fois. Cela est préférable dans le cas du taillage d’une roue de compte, par exemple ou d’un limaçon. Cela fait 20 ans que je fonctionne ainsi et je n’ai pas à m’en plaindre. Le seul problème est que mon vieux PC me prends de la place.

Je vais essayer de mettre aujourd’hui en ligne mon fichier Basic.

@+
JC

Merci pour le lien que je vais lire.

Je vois que vous êtes aussi bijoutier ! Vous avez de nombreuses cordes à votre arc !

Si c’est une question de place, en effet, une solution mobile de type RaspberryPi ou Odriod est éventuellement pertinente.
Mais je reste interrogatif car le PC peut être délocalisé (via clé USB par exemple)

J’ai lu le programme Basic sur le document « /flycutters.pdf ». Il me reste à voir le programme qui lit les fichiers dXXXX,
et surtout le programme qui prévoit la programmation des chaperons.
Le programme qui déchiffre dXXXX lit chaque ligne et lance autant de pas qu’indique le nombre j’imagine. C’est ça ?

Tout cela est falicement réalisable en continuant de fonctionner avec des fichiers (mais plutot de code G) produit par
un programme et à charger sur la machine, un peu comme on fait classiquement avec les imprimantes 3D ou en CNC:

Coté PC on utilise un logiciel de conception qui produit finalement du codeG
Coté microcontrôleur on utilise un interpréteur de code G (GRBL) pour driver les contrôleurs pap

– Sur PC délocalisé: un programme qui produit un fichier codeG en fonction des paramètres donnés. On copie le fichier sur une clé USB
– Sur la machine: un programme qui interprète le code G sur la clé USB pour driver les controleurs pap

Ce n’est pas une méthode qui pourrait vous convenir ?

Cadrature

ps
Gardez votre PC, un musée va finir par vous en faire une offre intéressante 😉

[Torzio]

Code:

‘=================================================
‘================= RCOMPTE.BAS ====================
‘======= commande de la machine … tailler ========
‘============== Sulka 26 mai 2005 ================
CLS
 
 
  PRINT

  CHDIR "\QB45\taillage"

  FILES
 

  PRINT : PRINT : PRINT

  PRINT " Taillage ROUE DE COMPTE"

debut:

  PRINT : PRINT

  INPUT "profondeur en 1/10 Š de mm ", prof
  INPUT "Avance en 1/10Š de mm ", av

fichier:

  CLS : PRINT : PRINT : PRINT : PRINT
  PRINT "Roue de Compte "
  PRINT " Profondeur = "; prof / 10; " mm"
  PRINT " Avance = "; av / 10; "mm"
  PRINT
  INPUT "On continue O/N "; R$
  IF R$ = "o" THEN GOTO suite
  IF R$ = "O" THEN GOTO suite
  RUN
suite:
 
  CHDIR "\QB45\TAILLAGE"
  DIM R(400)
  OPEN "i", 1, "RCOMPTE.DAT"
  d = 0

lecture:
  d = d + 1
  INPUT #1, R(d)
  IF EOF(1) = 0 THEN GOTO lecture
  FOR t = 1 TO d
  PRINT R(t); t,
  NEXT t
  PRINT
  PRINT "Nombre de dents "; d
  PRINT " Profondeur = "; prof / 10; " mm"
  PRINT " Avance = "; av / 10; "mm"
  CLOSE

  PRINT : PRINT
  COLOR 2

  PRINT " METTRE LA FRAISE EN MARCHE"
  PRINT : PRINT

  INPUT "On continue O/N "; R$
  IF R$ = "o" THEN GOTO taille
  IF R$ = "O" THEN GOTO taille
  RUN
 
taille:

  OPEN "COM1:2400,N,8,1" FOR RANDOM AS #1

  FOR t = 1 TO d

  SENS = 1 ‘avance profondeur
  NP = prof * 200
  MOT = 1
  PRINT #1, "X", SENS, NP, MOT

 
  INPUT #1, R
  PRINT "phase 1"

  SENS = 1 ‘avance avance
  NP = av * 200
  MOT = 2
  PRINT #1, "X", SENS, NP, MOT

  INPUT #1, R
  PRINT "phase 2"

 
  SENS = 2 ‘recul profondeur
  NP = prof * 200
  MOT = 1
  PRINT #1, "X", SENS, NP, MOT
  INPUT #1, R
  PRINT "phase 3"

  SENS = 2 ‘recul avance
  NP = av * 200
  MOT = 2
  PRINT #1, "X", SENS, NP, MOT
  INPUT #1, R
  PRINT "phase 4"

  SENS = 1 ‘diviseur
  NP = R(t)
  MOT = 3
 
  PRINT #1, "X", SENS, NP, MOT

  INPUT #1, R
  PRINT "taille dent "; t; " termin‚e"

  NEXT t

  PRINT "taillage "; d; " / "; nd; " dents termin‚"

  PRINT "ParamŠtres : ": PRINT
  PRINT "Nombre de dents", nd
  PRINT "profondeur = ", prof / 10; " mm"
  PRINT "Avance = ", av / 10; "mm"

  END

Voici le code Basic qui réside sur mon vieux PC pour le taillage des chaperons comme ICI. Il envoie des infos, via le port série, à une interface que j’ai réalisée avec un PIC 16F84, toujours programmé en Basic. Celle-ci va piloter les moteurs PAP. Lorsque le travail est fini, l’interface va envoyer un acquittement au PC qui va alors envoyer les infos suivantes.

Mon système est très rustique, mais je l’ai conçu moi-même avec les outils que je maîtrisais. A ma connaissance il n’existe pas de machine similaire à portée de ma bourse.

Je fabrique aussi des bijoux en impression 3D, mais pas besoin de « mettre les mains dans le cambouis », j’ai payé mon imprimante 200 € !
Si quelqu’un peut faire un système de division numérique plus « moderne », je suis preneur. La partie mécanique est aussi de ma conception.
ICI ma première machine à tailler, réalisée il y a une vingtaine d’année.

@+
JC

[Cadrature]

OK, je crois comprendre. Mais c’est violent, la dernière fois que j’ai lu du Basic, c’était il y a 40 ans…
Alors ma lecture est imparfaite.
Il y a une passe de lecture du fichier RCOMPTE.DAT l’on trouve certainement les écartements du chaperon, et une phase de taille qui produit des lignes de triplets « SENS, NP, MOT » vers le port série c’est bien ça ?
Je n’ai pas compris la lecture depuis ce port série… l’attente d’un retour de fin de travail ???
La programmation du PIC a dû être assez sportive.

Citation :

Mon système est très rustique, mais je l’ai conçu moi-même avec les outils que je maîtrisais. A ma connaissance il n’existe pas de machine similaire à portée de ma bourse.

Si, il me semble qu’il est plus simple et pas plus couteux de faire la même chose à partir d’un programme écrit dans un langage de programmation générique. Les amis ont dit Python, pourquoi pas ? Tout est bon: C, Java, Python et même Basic !
Le programme produit à peu près la même chose, mais par exemple en GCode (qui remplace favorablement les
triplets maison envoyés au PIC).
Si vous voulez garder vos vieilles habitudes de goto, utilisez C, il admet aussi les goto et vous serez peu dépaysé.

Une méthode bien plus simple:

On fait le fichier GCode avec un bête programme sur le PC qui se trouve dans le salon. On l’enregistre dans une carte SD branchée sur une petite prise USB par exemple.

De l’autre coté, dans l’atelier, une machine de moins de 100€ avec Arduino, lecteur de carte SD, drivers de pap qui lit ce fichier et conduit les moteurs.

Vous avez toujours un fichier par travail et plus le gros PC en liaison série avec la machine.

L’idée de garder le « PC » en liaison série avec la machine, mais de le remplacer par un RaspberryPi, me semble moins évidente et plus couteuse.

Cadrature

PS
Mais je répète que l’ensemble est réalisable maintenant dans un seul appareil, sous un même « sketch » sans PC et avec un bête Arduino. C’est encore plus simple et pas beaucoup plus couteux.
Par exemple l’utilisation d’un écran tactile LCD TFT de quelques pouces qui permet de programmer le chaperon confortablement, ou les autre programmes de taille prévus.
Il serait bien-sûr possible de sauvegarder et de retrouver les différents fichiers dans une carte mémoire et même de les copier vers un PC.

En général ce n’est pas l’option choisie par les concepteurs CNC car les logiciels de conception qui produisent le GCode sont sophistiqués et doivent être utilisés sur des PC.
C’est l’option luxe que j’évoquais (un logiciel à découper les chaperons tout bien beau qui produit un fichier gcode 😉

[Torzio]

En fait, pour des tailles spéciales je donne un nombre plutôt qu’un nom, dans le cas de la roue de compte je l’ai appelé 999, comme j’ai peu de xchance d’avoir une roue de 999 dents à tailler.

« SENS, NP, MOT » = SENS sens de rotation (1 ou 2). NP = nombre de pas que doit exécuter le moteur et MOT = moteur qui doit exécuter l’action ( dans mon cas c’est 1, 2 ou 3.

J’aurais puy utiliser le port imprimante et adresser directement les drivers moteur, mais c’était beaucoup trop compliqué pour moi.

Concernant le PIC 16F84, je l’ai programmé avec Pic Basic Compiler en Basic, simplement.

Dès que j’ai maitrisé les moteurs PAP, à la fin du siècle dernier, j’ai eu l’idée de fabriquer une machine à tailler. Une de mes élucubrations :

L’avantage avec l’Arduino ou la Raspberry,, c’est qu’il n’a a plus besoin d’interface, on peut adresser directement les drivers. La Raspberry a aussi l’avantage d’avoir un port HDMI, pour connecter un écran et un lecteur de carte mémoire.

Ce que je cherche, c’est simplement un bout de code qui aille lire des données dans un fichier de la carte SD, les mémorise puis envoie des impulsions sur le port GPIO afin de piloter un moteur PAP. Après je devrais me débrouiller, mais si on est plusieurs, ce serait plus rigolo !

@+
JC

[Cadrature]

Citation :

L’avantage avec l’Arduino ou la Raspberry,, c’est qu’il n’a a plus besoin d’interface, on peut adresser directement les drivers. La Raspberry a aussi l’avantage d’avoir un port HDMI, pour connecter un écran et un lecteur de carte mémoire.

Ce que je cherche, c’est simplement un bout de code qui aille lire des données dans un fichier de la carte SD, les mémorise puis envoie des impulsions sur le port GPIO afin de piloter un moteur PAP. Après je devrais me débrouiller, mais si on est plusieurs, ce serait plus rigolo !

@+
JC

Très amusant le machin qui tricote 🙂

La situation avec le PIC16F84 était exactement la même que celle avec Arduino (un Arduino n’est qu’un microcontrôleur
ATMega328p avec des trucs pour l’alimenter simplement et un port USB pour interfacer facilement UART).
Bref, une sortie état haut vers un driver de PAP, c’est en rien différent de ce que vous aviez fait.
L’intérêt de l’Arduino, c’est la facilité de programmation. Pour RaspberryPi, on n’a pas un microcontroleur,
mais un vrai processeur et un système d’exploitation et donc la possibilité d’avoir des logiciels, des accès mémoire
plus conséquents et un écran. Mais encore faut-il programmer ce qu’on voit à l’écran…

Pour le bout de code, je ne dois toujours pas comprendre le besoin. Je dois être un peu bouché…

Cadrature

[Torzio]

Cadrature a écrit:

Cadrature

Toutes mes excuses, il semble que je me sois mal expliqué.

Mes souhaits : remplacer mon système PC interface à PIC par une Raspberry et trouver un génie bienfaiteur qui fera le code qui va bien.

En attendant, si quelqu’un pouvait me faire un petit bout de code pour m’aider à « mettre le pieds à l’étrier ».
Ce code, en Python, devrait lire les valeurs dans un fichier situé sur la carte SD. Par exemple 1, 4, 2, 5, mémoriser, faire clignoter une LED de la première valeur, puis de la deuxième après appui sur une touche, etc.
Cela me permettrait de mieux comprendre le fonctionnement de la Raspberry et de Python. A partir de là je devrait pouvoir adapter à mes besoins.

Je maîtrise assez bien l’environnement Arduino ci-dessous une bobineuse que j’ai fabriquée :

Un autre projet de pendule en attente, avec un ATtiny 85 (mini Arduino):

Ici un période mètre pour balancier :

[Cadrature]

Bonjour,

No problem.

A mon avis vous en savez largement assez pour ce que vous voulez faire.
Vous avez fait bien plus compiqué avec Arduino, en électronique et même en programmation
(C++, vous pouvez oublier Basic ;-).

Si vous maintenez l’usage du RaspberryPi ; vous pouvez suivre cette vidéo:
https://www.youtube.com/watch?v=4hWG9X6kstY&t=638s

Il a un RaspberryPi installé avec Linux et fait clignoter une LED depuis GPIO.
Que du bonheur, d’autant qu’il donne le code Python ! 🙂

Il s’en sert avec une connexion ssh (c’est le plus simple car on n’a besoin que de connecter la RaspberryPi
avec un câble RJ45 à son ordinateur ou à sa box, ou directement en wifi si on possède une antenne).
Il faut installer un serveur ssh (sudo apt install open-sshserver; sudo systemctl enable ssh), configurer
une clé publique, l’exporter, etc.
La documentation est faite pour ça, mais à mon avis c’est plus sur ces problèmes de configuration
et d’installation que vous allez galérer, pas sur l’installation d’une résistance pullup sur un bouton
ou une capacité de découplage sur un driver pap. C’est plutôt ces problèmes qui se posent aux autres
et que vous savez faire, en plus de votre maîtrise en horlogerie bien-sûr.
Donc partager avec qqun qui fait déjà des montages I/O sur son RaspberryPi me semble une bonne solution.
Dommage que je sois si loin et pas à la retraite 🙂

Mais je répète (je suis très têtu, désolé) : ce qu’il fait avec le GPIO d’un RaspberryPi de plus de 100€
pour contrôler des moteurs ou faire clignoter des leds peut être fait exactement de la même manière (en plus simple)
avec un microcontôrleur monté sur un Arduino de 15€.
Le seul intérêt du RaspberryPi serait dans le logiciel dont vous n’avez pas parlé (celui qui permet de programmer
plein de divisions avec une belle interface).

Bonne journée
Cadrature

[Torzio]

Bonjour Cadrature,

Mon système de diviseur est extrêmement simple. Il faut exactement 28800 pas moteur (de mémoire) que l’on va nommer NPM, pour faire un tour exact de broche.

Donc, pour tailler une roue de 33 dents on va diviser 28800 par 33, ce qui fait 872,7272727272727. Problème, on a besoin de nombres entiers. Un petit programme va intercaler de temps en temps 1 pas supplémentaire pour arriver à une suite de nombres entiers pour arriver à exactement un tour complet. L’erreur sera minime et largement acceptable mécaniquement. Pour s’en assurer il suffit de diviser le périmètre de la roue par le NPM pour 1 tour exact.
Cette suite de nombres correspondant au nombre de pas pour la division de chaque dent. Dans le cas présent, 872 ou quelque fois 873 pas vont faire tourner la roue à tailler d’1/33 de tour. Ces suites de nombres sont contenu dans des fichiers textes. 33 dents, va avoir pour nom de fichier 33.TXT.
Au lancement, le Raspberry va demander le nombre de dents, On va renseigner 33, il va alors ouvrir le fichier 33.TXT et mémoriser les valeurs qu’il contient. Ensuite, avec notre accord (je passe quelques autres infos) il va commencer à tailler les dents en schématisant.

Là ou je bute, c’est pour l’écriture du code pour transposer mon principe écrit en Basic sur PC sur Raspberry avec Python.

@+
JC.

[Cadrature]

Torzio a écrit:

Bonjour Cadrature,

Mon système de diviseur est extrêmement simple. Il faut exactement 28800 pas moteur (de mémoire) que l’on va nommer NPM, pour faire un tour exact de broche.

Donc, pour tailler une roue de 33 dents on va diviser 28800 par 33, ce qui fait 872,7272727272727. Problème, on a besoin de nombres entiers. Un petit programme va intercaler de temps en temps 1 pas supplémentaire pour arriver à une suite de nombres entiers pour arriver à exactement un tour complet. L’erreur sera minime et largement acceptable mécaniquement. Pour s’en assurer il suffit de diviser le périmètre de la roue par le NPM pour 1 tour exact.
Cette suite de nombres correspondant au nombre de pas pour la division de chaque dent. Dans le cas présent, 872 ou quelque fois 873 pas vont faire tourner la roue à tailler d’1/33 de tour. Ces suites de nombres sont contenu dans des fichiers textes. 33 dents, va avoir pour nom de fichier 33.TXT.
Au lancement, le Raspberry va demander le nombre de dents, On va renseigner 33, il va alors ouvrir le fichier 33.TXT et mémoriser les valeurs qu’il contient. Ensuite, avec notre accord (je passe quelques autres infos) il va commencer à tailler les dents en schématisant.

Là ou je bute, c’est pour l’écriture du code pour transposer mon principe écrit en Basic sur PC sur Raspberry avec Python.

@+
JC.

Bonjour

Voici un petit problème de maths amusante.

C’est mieux à mon avis de faire le calcul des pas dans le programme principal en Python
et demander de divider 33 dents. Un seul programme très simple peut tout faire assez simplement.

C’est idiot, ce matin j’ai fait tout un petit montage avec un Raspberry Pi pour montrer
comment lire un fichier sur un clé USB, envoyer les ordres de ce fichier au moteur pas-à-pas.
J’ai donc configuré la Raspberry Pi et écrit un petit programme Python.
Je reviendrai sur ton problème précis mais voici ce que ça donne pour ceux que ça intéresse:

Désolé, c’est un peu long et finalement ça ne répond pas vraiment à ton besoin précis (que je n’avais
pas vraiment bien saisi)…

#######
# Petit Tuto
#######

Montage:
#######
– Vieux RaspberryPi (un collector !) branché à un écran et un clavier de récup’
– A4988 (contrôleur de pas à pas)
– Moteur pas-à-pas
– Capacité 100uF 40V
– Alimentation 12V
– Quelques LED et des résistances 1kohm sur on veut s’assurer de l’alimention

On branche de 2 à 6 PINs depuis le Raspberry vers le A4988 (moi je n’ai branché que deux)

– Step (sert à faire un pas)
– Dir (indique la direction)

Et éventuellement (je le l’ai pas fait ce matin)
– Enable (indique de relâcher le couple, pour bouger le moteur à la main)
– MS1, MS2, MS3 (ces trois trucs servent à contrôler le micro-stepping. On ne branche rien pour un pas normal de 18° (400 pas pour un tour sur un Nema 17 standard), mais si on branche, on peut diviser l’angle de quelques valeurs)

Sur le A4988:On fait un pont entre Sleep et Reset
On alimente 5Vcc sur Vdd
On alimente 12Vcc sur VMOT en y mettant une capacité de découplage entre VMOT et GND au plus près du contrôleur
On met la masse à GND (deux fois)
On branche les 4 fils au moteur pas-à-pas

Sur le Raspberry Pi:
On branche 5v sur 5v de A4988
Ground à GND de A4988
14 à Step de A4988
15 à Dir de A4988

Ça donne ceci:

Programmation
###########
Nous voici à devoir maintenant programmer.
Je passe à Python (c’est pas ma tasse de thé, mais JC préfère)

Voici un exemple qui « analyse » un fichier input.dat et fait ce qu’il y a dedans sur ce moteur.
C’est un exemple.
On écrit ce programme tranquillement sur son PC avec un bon IDE (par exemple Visual Studio Code)
On enregistre sur une clé USB

programme.py

Code:

 »’
  Petit script Python pour faire tourner un moteur pas-à-pas branché
  sur les pins GPIO (General Purpose Input/Output) d’un Raspberry Pi
 
  Le programme lit un fichier "input.dat" et exécute les ordres qui s’y trouvent

  Cadrature 2023/01/22
 »’

# Importer cette bibliothèque qui permet de configurer les ports GPIO de la Raspberry Pi
import gpiod
# Importer cette bibliothèque qui permet de faire des pauses
import time

 »’
  Je définis deux fonctions qui arrêtent le processus
  usleep(x) arrête x micro-secondes
  msleep(x) arrête x milisecondes
 »’
usleep = lambda x : time.sleep(x/1000000.0)
msleep = lambda x : time.sleep(x/1000.0)

# définition du temps en micro-secondes entre deux états du moteur pas-à-pas (dépend des moteurs, 2us convient pour moi)
pulseWidthMicros = 2.0
# définition du temps en milli-secondes entre deux pas du moteur pas-à-pas (dépend des moteurs, 1ms convient pour moi)
millisBtwnSteps = 1.0

# chip du port GPIO (généralement "gpiochip0" sur Raspberry Pi)
chip = gpiod.chip("gpiochip0")

# On branche sur le PIN 14 step et sur le PIN 15 dir. On peut faire autrement et surtout brancher d’autres choses
step_line = chip.get_line(14)
dir_line = chip.get_line(15)

# configuration de la communication
config = gpiod.line_request()
config.consumer = "pap"
config.request_type = gpiod.line_request.DIRECTION_OUTPUT

step_line.request(config)
dir_line.request(config)

# Petite routine qui fait tourner le moteur:
# direction (0 ou 1)
# steps (nombre de pas)
# speed (coefficient de vitesse)
def motor(direction, steps, speed):
  dir_line.set_value(direction)
  for i in range(steps):
  step_line.set_value(1)
  usleep(pulseWidthMicros)
  step_line.set_value(0)
  msleep(millisBtwnSteps * speed)

# On ouvre le fichier "input.dat" pour le mettre dans une liste de lignes
with open("input.dat", "r") as file:
  lines = file.readlines()

# Pour chacune de ces lignes, on décompose les éléments séparés par des espaces
# une ligne se présente sous forme "code value1 value2 value3… valuek"
# selon le code, on fait une action avec value1 value2 value3… valuek comme paramètres
for line in lines:
  values = line.split()
  code = values[0]
  # le code "clockwise" demande un nombre de pas et une vitesse. Le moteur tourne en sens horaire
  if code == "clockwise":
  motor(1, int(values[1]), int(values[2]))
 
  # le code "counterclockwise" demande un nombre de pas et une vitesse. Le moteur tourne en sens anti-horaire
  elif code == "counterclockwise":
  motor(0, int(values[1]), int(values[2]))
 
  # le code "sleep" demande une durée en milisecondes et attend
  elif code == "sleep":
  msleep(int(values[1]))

  # etc… (on peut ajouter des codes comme on veut)
 

# On relâche les deux lignes
step_line.release()
dir_line.release()

Configuration du RaspberryPi
##############

Moi je n’avais qu’un système Linux lite faute de place sur ma carte SD

Installation bibliothèque giopd (ce qui va permettre de faire l’import)
sudo apt install gpiod libgpiod-dev

D’autres bibliothèques sont disponibles, celle-ci est puissante et complète.

Pour le montage de la clé USB et la lecture du fichier qui s’y trouve (je branche une clé USB Windows dessus)
Attention c’est éventuellement différent chez vous, il faut comprendre ce qu’on fait
sudo mkdir /mnt/USB
sudo mount /dev/sda1 /mnt/USB

pour démonter (avant de débrancher la clé):
sudo umount /mnt/USB

Faire tourner le code
##############

taper
cd /mnt/USB
python programme.py

exemple de fichier input.dat qui fait faire un tour lentement, attend 1 seconde et refait le tour dans l’autre sens rapidement:

Citation :

counterclockwise 400 5
sleep 1000
clockwise 400 1

Voici
Si ça peut aider quelqu’un c’est parfait.

Bon dimanche
Cadrature

[Cadrature]

Voici un petit problème de maths amusante.

NPM = 28800
Nombre de dents = 33

Notre bon ami Euclide nous rappelle dans « Elements » que tout nombre s’écrit a=bq+r, avec r plus petit que q

28800 = 33 * 872 + 24

Il faut donc ajouter 24 pas aux 33 espaces de 872 pas pour se retrouver au même endroit.

Le problème revient donc à répartir 24 pas dans 33 espaces.

A- La méthode la plus idiote serait de mettre ces 24 pas dans le premier espace: 896 + 32*872

B- Une méthode éventuellement acceptable serait de mettre un pas dans les 24 premiers espaces puis rien sur les autres.
24 x 873 + 9 x 872
Etant donné ce que donne un pas comme imprécision, c’est éventuellement jouable et c’est le plus simple, mais c’est un chouilla
déséquilibré.

C- La méthode idéale serait de partager les 24 pas sur les 33 espaces. Vous avez trois heures

Cette petite procédure peut être avantageusement ajoutée dans un programme Python dans lequel on dit simplement
« Mon vieux, ma machine a diviser fait un tour de broche tous les 28800 pas, et j’ai bien envie de faire le fraisage
d’une roue de 33 dents. Alors tu fais comme tu veux, mais tu me sorts cette roue pendant que je vais me chercher
un sandwitch. »

Bon dimanche
Cadrature

[Hypnos]

Cadrature a écrit:

Voici un petit problème de maths amusante.

NPM = 28800
Nombre de dents = 33

Notre bon ami Euclide nous rappelle dans « Elements » que tout nombre s’écrit a=bq+r, avec r plus petit que q

28800 = 33 * 872 + 24

Il faut donc ajouter 24 pas aux 33 espaces de 872 pas pour se retrouver au même endroit.

Le problème revient donc à répartir 24 pas dans 33 espaces.

A- La méthode la plus idiote serait de mettre ces 24 pas dans le premier espace: 896 + 32*872

B- Une méthode éventuellement acceptable serait de mettre un pas dans les 24 premiers espaces puis rien sur les autres.
24 x 873 + 9 x 872
Etant donné ce que donne un pas comme imprécision, c’est éventuellement jouable et c’est le plus simple, mais c’est un chouilla
déséquilibré.

C- La méthode idéale serait de partager les 24 pas sur les 33 espaces. Vous avez trois heures

Cette petite procédure peut être avantageusement ajoutée dans un programme Python dans lequel on dit simplement
« Mon vieux, ma machine a diviser fait un tour de broche tous les 28800 pas, et j’ai bien envie de faire le fraisage
d’une roue de 33 dents. Alors tu fais comme tu veux, mais tu me sorts cette roue pendant que je vais me chercher
un sandwitch. »

Bon dimanche
Cadrature

Je me permets de proposer une solution de feignant (j’ai appliqué ça dans toute ma vie professionnelle, suite au conseil de notre prof de maths en prépa: « savoir calculer c’est savoir ne PAS calculer »).
Pour trouver l’entier le plus proche d’un nombre à virgule (finalement il s’agit de ça dans le diviseur) il suffit d’utiliser la fonction int() sur le nombre augmenté de 0.5 en ayant pris soin de travailler en nombres réels (à virgule)

NbPasMoteur = 28800
NbDents = 33
NumeroDent = 1

ListePas = [] # liste des pas moteurs où il faut tailler

# numéro du pas pour tailler la dent
# premier pas pour NumeroPas = 0 ou 1 selon les conventions qu’on souhaite

NumeroPas = 0 # ne sert à rien puisqu’on va le calculer à chaque dent

for NumeroDent in range(NbDents) # NumeroDent varie de 0 à NbDents – 1
NumeroPas = float(NbPasMoteur)/NbDents*NumeroDent
# après il faut arrondir le résultat à l’entier le plus proche

NumeroPas = int( NumeroPas + 0.5) # rajouter 1 si on commence à tailler au pas 1

ListePas.append(NumeroPas)

# ensuite il suffit de pêcher le numéro du pas dans la liste

for LendroitOuOnEst in range(NbPasMoteur)
if LendroitOuOnEst in ListePas # c’est le moment de tailler


# on taille
…..

…..
# la position du moteur est LendroitOuOnEst si on commence à 0
# LendroitOuOnEst+1 si on commence à 1

# on fait avancer le moteur d’un pas
…..
……

[fly back]

Ah la prise de tête…je suis pas prêt de changer de machines!! Une de mes 5 :

[Torzio]

@Cadrature,
Merci beaucoup pour le code. J’étudie ça et j’essaie de faire tourner un PAP. Je vous tiens au courant.

@Hypnos,
Merci pour l’idée. Voici comment j’ai résolu le problème, page 11. Le nombre de pas est différent, j’ai plusieurs diviseurs numériques.

@Fly Back,
Je me permets de te rappeler que chacun fait comme il veut. Si le fait de construire une machine qui travaille à ta place ne te plait pas, cela ne nous intéresse pas, passe ton chemin et laisse nous tranquille. Merci.. Ce n’est pas parce que tu n’aimes pas qu’il faut en dégouter les autres !
Cela me gonfle d’être esclave d’une machine et de tourner bêtement les manivelles. Je préfère en être le maître et le créateur. Je n’ai jamais aimé obéir aux ordres. Mais cela ne m’a pas empêché d’être Maréchal des Logis (sergent), dans un régiment de cavalerie. Classe 69 1A, pendant la durée légale de mon service militaire, obligatoire, à l’époque, je ne sais plus si c’était 12 ou 15 mois.

@+
JC

[Auteur]

Messages