Diviseur numérique

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

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

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
     .....
     ......

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

@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

Torzio a écrit:

@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.

Oui mais c'est une solution de courageux, compétent ...
Moi je suis de la catégorie des feignants, pas doués 

Bravo pour cette solution de fainéant astucieuse qui répond à la méthode C
Vive les fainéants ! (Et Euclide)

Le tableau est même inutile si l'on veut encore plus simple:
Bon JC, c'est à toi maintenant !

Cadrature

Code:

NbPasMoteur = 28800
NbDents = 33

k = 1
old = 0
for NumeroDent in range(NbDents):  # NumeroDent varie de 0 à NbDents - 1
    NumeroPas = float(NbPasMoteur) / NbDents * NumeroDent
    NumeroPas = int(NumeroPas + 0.5)  # rajouter 1 si on commence à tailler au pas 1
    print(f"Dent N°{k}: {NumeroPas - old} pas, tailler")
    k += 1
    old = NumeroPas

NumeroPas = float(NbPasMoteur)
NumeroPas = int(NumeroPas + 0.5)  # rajouter 1 si on commence à tailler au pas 1
    
print(f"retour à zéro: avancer de {NumeroPas - old} pas")

Torzio a écrit:

@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

@+
JC

Et oui, je fais donc du manuel ! Et ça marche bien.

Et puis j'ai des actions dans le projet qui remonte au temps du 1er groupe d'échange  " Yahoo groupe"! Puis horlogerie  suisse, puis forum usinage où j'ai  nullement suivi, vu la nullité de 90% des discussions. 


Demain je vais donc manipuler mes verniers mécaniques au 1/100,  durant quelques minutes, en attendant  d'avoir une machine moderne et révolutionnaire.  Mais  tu es tenace, tu vas réussir.

fly back a écrit:

Et oui, je fais donc du manuel ! Et ça marche bien.

Et puis j'ai des actions dans le projet qui remonte au temps du 1er groupe d'échange  " Yahoo groupe"! Puis horlogerie  suisse, puis forum usinage où j'ai  nullement suivi, vu la nullité de 90% des discussions. 


Demain je vais donc manipuler mes verniers mécaniques au 1/100,  durant quelques minutes, en attendant  d'avoir une machine moderne et révolutionnaire.  Mais  tu es tenace, tu vas réussir.

Bon tournage de manivelle ! Attention à ne pas donner un tour de trop !  Je te signale, pour info, que le sujet de cette discussion est :" Diviseur numérique".

@+
JC

Cadrature a écrit:

Le tableau est même inutile si l'on veut encore plus simple:
Bon JC, c'est à toi maintenant !

C'est l'habitude de séparer les tâches quand on fait du code propre.
La liste permet de faire les calculs des positions où il faut tailler (sans faire appel à un fichier, c'est toujours ch...)

Ensuite on peut avoir une routine (je n'en ai fait aucune en contradiction avec mes anciennes habitudes) qui retourne les-dites positions et s'occuper séparément de la gestion de moteur PAP et de la fraise.
L'impression des posisions c'est juste pour être sûr qu'on ne s'est pas planté.

Si on veut le nombre de pas dont il faut avancer entre chaque dent c'est trivial avec la liste ...