Moteur pas à pas et pont tournant

Répondre
Avatar du membre
likikiFrance
Site Admin
Site Admin
Messages : 6655
Enregistré le : 27 févr. 2021, 16:11
Prénom : Christian
LOCALISATION : Ile de France
Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
Echelle pratiquée : H0
Âge : 56
Pays :
France (fr)
France
avr. 2021 21 18:04

Moteur pas à pas et pont tournant

Message par likikiFrance

Bonjour

Voici le premier des articles au sujet des moteurs pas-à-pas pour motoriser un pont tournant. Cet aticle est également disponible sur mon blog : http://modelleisenbahn.triskell.org/spip.php?article68

Cet article fait suite à mes premiers essais de pilotage des moteurs pas-à-pas pour construire un point tournant qui n'avaient pas été couronnés de succès.

Pour rappel, l'objectif est de mettre en œuvre la motorisation d'un pont tournant avec un moteur pas-à-pas bipolaire {{sans réduction mécanique}}. On trouve dans le commerce des moteurs pas-à-pas à 200 pas ou 400 pas par tour. Vous trouverez les informations de base dans l'article Wikipédia mais surtout dans cet excellent article de Nicolas Marchildon- que je trouve particulièrement didactique. le pilotage de tels moteurs n'est pas compliqué à condition de disposer d'un carte à microcontrôleur. En effet, passer d'un pas au suivant est réaliser en envoyant une séquence de tensions sur les deux bobines du moteur. Plus les séquences sont rapides et plus le moteur tourne vite.

Dans « Moteur pas-à-pas et pont tournant », j'avais essayé de piloter le moteur par micro-pas en pilotant chaque bobine par une PWM à 20KHz, dont la rapport cyclique évoluait en sinus, les deux PWM étant décalées de ∏/2. L'expérience avait eu un succès mitigé. En effet, les micro-pas sont définis par le courant dans chaque bobine du moteur pas-à-pas et en pilotant via une PWM, on pilote le courant en aveugle sans aucune garantie que lui même évolue en sinus.

Or, des circuits intégrés qui pilotent directement le courant, en le mesurant et en le régulant afin de permettre un mouvement par micro-pas précis, existent. L'un des spécialistes est Allegro Microsystems qui propose toute une gamme de circuits dédiés au moteurs pas-à-pas bipolaires avec un nombre de micro-pas pouvant aller jusqu'à 16. Un deuxième acteur majeur est Texas Instruments avec la gamme de circuits DRV88xx avec un nombre de micro-pas pouvant aller jusqu'à 32. Enfin, Toshiba propose également des composants dans la série TD65xx dont certains montent à 32 micro-pas.

Présentation de l'EasyDriver v4.4

L'EasyDriver v4.4 est une breakboard en OpenHardware conçue en coopération entre SparkFun et Brian Schmalz. Une breakboard est une carte minimaliste dont le but est de faciliter l'intégration d'un composant : alimentation, résistances, condensateurs indispensables au fonctionnement et boches au pas de 2,54mm pour pouvoir la mettre en œuvre sur une breadboard. Elle est donc peu chère, une dizaine d'Euros en France.

Le composant central est un Allegro A3967, dont voici la datasheet, qui permet 8 micro-pas. Ce n'est pas ce qui se fait de mieux et les essais montreront si, oui ou non, 8 micro-pas suffisent. Deux choses qu'il faut savoir:
  • Lorsque l'ensemble est sous tension, le moteur est alimenté et sa position est fermement tenue;
  • Il ne faut en aucun cas débrancher le moteur en laissant l'EasyDriver sous tension, il pourrait en résulter la destruction de l'Allegro.
La carte mesure 49 mm sur 21 mm et se présente comme ceci:

Image
  • Le régulateur 5V fournit le 5V à la logique de l'Allegro à partir de la tension d'alimentation du moteur;
  • Le potentiomètre permet de régler le courant maximum. Plus le courant est élevé et plus le moteur a de couple mais moins le mouvement d'un micro-pas au suivant sera doux ;
  • Pour connaître la valeur de ce courant, il suffit de mesurer la tension de référence Vref au point de mesure d'une part, et la résistance de capture de courant Rs d'autre part. Le courant maximum Imax est donné par la formule : Imax = Vref/8Rs ;
  • Enfin la carte est munie d'un condensateur de filtrage de 47µF qui protège l'Allegro des transitoires lors de la mise sous tension.
La carte est prévue pour s'enficher sur une carte mère où sur une breadboard. Elle possède 17 connexions dont le rôle est donné à la figure ci-dessous.

Image
  • Le moteur pas-à-pas est connecté via les 4 broches en haut à gauche;
  • L'alimentation du moteur est connectée sur les deux broches en haut à droite (entre 7V et 30V). Il est possible d'alimenter le moteur avec une tension plus élevée que celle qu'il supporte à condition de régler le courant à une valeur inférieure ou égale au courant supporté par le moteur;
  • Les différentes masses sont reliées entre elles et l'une au moins devra être connectée à la masse de la carte microcontrôleur employée (Arduino ou autre);
  • RESET, ENABLE et SLP (pour SLEEP) permettent respectivement de faire une réinitialisation de l'Allegro, de l'activer ou de le mettre en veille;
    • RESET doit être amené à 0 puis à 1 pour réinitialiser l'Allegro. Les deux bobines sont alimentées à 70,71% et le rotor se place sur un demi-pas. L'EasyDriver tire le RESET à 5V via une résistance de 10kΩ. On peut donc laisser cette broche en l'air sans soucis;
    • ENABLE doit être constamment à l'état 0 (bas) pour que l'Allegro pilote les bobines du moteur. L'EasyDriver tire ENABLE à 0V via une résistance de 10kΩ. On peut donc aussi laisser cette broche en l'air sans soucis;
    • Enfin SLP peut être mise à l'état bas pour désactiver la majeure partie de la circuiterie interne de l'Allegro. Ici encore, l'EasyDriver tire SLP à 5V via une résistance de 10kΩ. On peut également laisser cette broche en l'air sans soucis.
  • MS1 et MS2 permettent de fixer le nombre de micro-pas entre 2 pas selon la table suivante. Ici aussi l'EasyDriver tire MS1 et MS2 à 5V par l'intermédiaire de réistances de 10kΩ. Par conséquent, en laissant ces broches en l'air, la résolution de 8 micro-pas par pas est sélectionnée;

    Image
  • PFD règle la vitesse à laquelle le courant est réduit. Par défaut cette réduction est lente (slow decay). À priori ce réglage convient aux vitesses lentes et d'après le schéma du EasyDriver, il n'est nécessaire de s'en occuper que pour augmenter les performances dans le cas d'une vitesse de rotation élevée;
  • DIR fixe le sens de rotation du moteur. Nous allons donc piloter cette broche pour notre application;
  • STEP permet de faire avancer le moteur au micro-pas suivant. Une transition de 0 à 1 provoque cette avance. Cette broche sera également pilotée.
Équipons l'engin

L'EasyDriver arrive nu, il faut donc le munir de connecteurs pour l'utiliser. J'ai choisi des connecteurs avec détrompeurs et verrouillage pour le moteur et l'alimentation du moteur et des barrettes de broches pour les autres. Le tout au pas de 2,54mm. Utiliser un connecteur digne de ce nom pour la connexion vers le moteur garantit qu'il n'y aura pas de déconnexion intempestive par arrachage de fil et donc pas de destruction de l'Allegro.

Image

Image

Image

Il reste maintenant à connecter tout cela à un moteur et à un Arduino pour faire quelques essais.

Ne vous précipitez pas à acheter cette carte, il n'est pas dit qu'elle sera retenue pour la suite

___________________________________________________________________________________________

Quelques éléments de réponse. Une plaque tournante de 15cm de diamètre en N (correspondant à une plaque de 24m) et 200 pas/tour, ça donne des sauts de 2,4mm en bout de pont d'un pas à l'autre. Ça se voit aussi surement que tu vois l'aiguille des secondes sauter sur une horloge.

Il n'y a pas plus de complication avec un shield capable de faire du micro-stepping qu'en pilotant directement le moteur par pas entier. On a deux signaux : 1 pour le sens de rotation, l'autre pour égrener les pas. le programme est très simple.
___________________________________________________________________________________________

Mise en œuvre de l’EasyDriver v4.4 pour un pont tournant

Cet article est également disponible sur mon blog : http://modelleisenbahn.triskell.org/spip.php?article69

Voici le compte rendu de quelques essais de mise en œuvre avec l'objectif de motoriser un pont tournant.

Le matériel

Afin d'avoir la meilleure résolution possible, le moteur pas-à-pas bipolaire choisi est un moteur 400 pas par tour vendu par Selectronic. Il s'agit de ce modèle.

Ce moteur est prévu pour être alimenté en 12V. Les bobines ont une résistance de 40Ω et par conséquent chaque bobine consomme 300mA. Le couple de maintient est de 3,5 kg/cm.

J'ai fixé sur l'arbre une latte en bois de 40 cm de longueur et donc un rayon de 20cm. Cette longueur est de 30% supérieure à la longueur d'un pont tournant en H0 et plus de 2 fois plus long qu'un pont tournant en N. Cela permet de visualiser la rotation et plus particulièrement les défauts.

Image

En combinant les 400 pas par tour du moteur et les 8 µpas de l'EasyDriver, on arrive à 3200 positions sur le cercle. Avec un diamètre de 30cm, typiquement un pont tournant en H0, cela nous donne un pas d'environ 0,3mm en bout de pont. Avec un rayon de 15cm qui correspond au pont tournant PECO en N, cela nous donne un pas de 0,15mm en bout de pont.

La connexion de l'Arduino à l'EasyDriver est particulièrement simple. Comme on la vu dans « L’Easydriver v4.4 », la plupart des broches de l'EasyDriver ont la configuration adéquate quand on les laisse tout simplement non connectées.

Image

Les sorties numériques 2 et 3 de l'Arduino sont employées pour piloter le moteur. On garde les alimentations séparées. L'EasyDriver est alimenté en 12V continu et, pour les essais, l'Arduino reste alimenté via l'USB.

Image

Influence de la limitation de courant

Plus le courant maximum Imax, c'est à dire le courant correspondant à 100% d'alimentation d'une bobine, est élevé et plus le passage d'un µPas au suivant est rapide et franc. Comme on veut le passage le plus doux possible, il faut régler le courant maximum à la valeur la plus basse possible.
Les indications de sens de rotation du potentiomètre sur l'EasyDriver 4.4 sont fausses. La valeur minimum correspond en fait à une rotation dans le sens trigonométrique (à gauche) et la valeur maximum à une rotation dans le sens horaire (à droite).
D'après la schématique, le Imax minimum possible est de 166mA pour Vref = 1V, ce qui correspond à la valeur minimum que l'on trouve dans la documentation de l'Allegro A3967. En réalité, le Vref minimum mesuré est de 1,59V au lieu des 1V annoncés. Par ailleurs, j'ai mesuré une valeur de 1,2Ω pour les résistances de capture de courant au lieu des 0,75Ω annoncés dans la schématique. Le rapport Vref/ Rs est quasiment le même et le Imax pour Vref = 1,59V est donc bien de 166mA.

Voici une vidéo montrant l'influence de la limitation de courant sur la fluidité de la rotation pour les valeurs suivantes de Imax : 280mA (Vref = 2,69V), 224mA (Vref = 2,15V) et 166mA (Vref = 1,59V). La vitesse de rotation est de 1 tour en 2 minutes.

[youtube]ZFFToe1mCec[/youtube]

On voit effectivement que le réglage Imax au minimum donne le meilleur résultat en terme de fluidité de mouvement même si la vidéo gomme les petites vibrations qui sont observables à des Imax plus élevés. Le couple reste largement suffisant.

Le logiciel

La pilotage du moteur pas-à-pas est très facile. La broche 2 de l'Arduino connectée à l'entrée DIR de l'EasyDriver permet de fixer le sens de rotation et la broche 3 connectée à l'entrée STEP de l'EasyDriver permet d'avancer d'un µPas. Ces deux broches sont donc mises en sortie dans setup() comme ceci.

Code : Tout sélectionner

const int pinSens = 2;
const int pinMicroPas = 3;
 
void setup() 
{
    pinMode(pinSens, OUTPUT);
    pinMode(pinMicroPas, OUTPUT);
}
Le jeu consiste ensuite à choisir un sens de rotation en mettant pinSens à HIGH ou LOW puis à enchaîner à une certaine cadence des HIGH et des LOW sur pinMicroPas.

La cadence est déterminée par le délai d'attente entre deux bagottages sur pinMicroPas. Par exemple, si l'on veut que le pont accomplisse un tour complet en 2 minutes, soit 120s, on calcule ce temps d'attente de la manière suivante: 3200 µPas en 120s donne un délai de 120/3200 = 37,5ms ≃ 37ms.

Ainsi le programme le plus simple possible consiste à faire tourner le moteur en permanence dans loop().

Code : Tout sélectionner

void loop()
{
    digitalWrite(pinMicroPas, LOW);
    digitalWrite(pinMicroPas, HIGH);
    delay(37);
}
Voici une vidéo qui montre l'exécution d'une séquence de déplacement : positionnement en 100, puis 300, puis 200, puis 800, puis 1600, puis 1000 et enfin 2400. Dans la première partie, un délai de 36ms entre deux µPas est utilisé. Les µPas ne sont pas visibles. Dans la seconde on passe à un délai de 99ms, les µPas deviennent visibles. Enfin dans la 3e partie, le mouvement d'une position à l'autre a une phase d'accélération pendant 0,5s en passant d'un délai de 78ms à 36ms par décrément de 3ms et une phase de décélération pendant 0,75s en passant d'un délai de 36ms à 99ms par incrément de 3. Les phases d'accélération et de décélération sont légèrement hachées.

[youtube]XXFy7AJD_TA[/youtube]

L'EasyDriver remplit son office mais montre quelques limites pour les très faibles vitesses qui sont utilisées dans les phases d'accélération et de décélération. D'autres breakout boards existent et la prochaine fois, nous verrons celle développée par Pololu qui utilise un Texas Instruments DRV8824 permettant 32µPas.

L'article est également disponible sur mon blog : http://modelleisenbahn.triskell.org/spip.php?article71

Les essais avec l'EasyDriver v4.4 n'ont pas donné entière satisfaction. En effet, 8 micros-pas par pas ne semblent pas suffisants pour un mouvement fluide à très faible vitesse. Nous examinons aujourd'hui une seconde breakout board qui donnera peut-être de meilleurs résultats.

Présentation de la DRV8824 de Pololu

La DRV8824 de Pololu est une autre candidate pour le pilotage des moteurs pas-à-pas par micro-pas. Cette Breakout Board intègre un circuit intégré Texas Instruments DRV8824 ainsi que les composants permettant de le mettre en œuvre. Voici la datasheet du DRV8824. Cette Breakout Board porte donc le même nom que le composant qu'elle intègre ce qui ne va pas me faciliter la description. Dans la suite je vais donc utiliser DRV8824 quand il s'agit de la  Breakout Board et Ti DRV8824 quand il s'agit du composant de Texas Instruments

Le Ti DRV8824 permet 32 µPas au maximum là [où l'Allegro A3967 n'en permettait que 8. Cette meilleure résolution devrait permettre une plus grande fluidité de mouvement. Comme on va le voir le principe d'utilisation est quasiment identique entre les deux circuits.

Pololu recommande également de ne jamais débrancher le moteur en laissant la DRV8824 sous tension, il pourrait en résulter la destruction du Ti DRV8824.

La DRV8824 est une carte beaucoup plus petite que l'EasyDriver. Elle ne mesure que 20,5mm sur 15,5mm. On peut la voir comme un composant 16 broches avec deux lignes de 8 broches au pas de 2,54mm écartées de 12,7mm. On la trouve pour une douzaine d'Euros. Elle se présente comme ceci:

Image

Le Ti DRV8824 est aussi plus petit avec des broches au pas de 0,65mm. Contrairement à l'EasyDriver, il n'y a pas de régulateur de tension car il est inutile. En effet, le Ti DRV8824 intègre son propre régulateur de tension pour générer le 3,3V nécessaire à partir de la tension du moteur.

Il n'y a pas non plus de condensateur chimique de filtrage. Par conséquent, il est nécessaire d'en prévoir un en externe sur l'alimentation du moteur. Ce condensateur dont la valeur doit être au moins de 47µF est indispensable pour filtrer les transitoires à l'allumage qui risqueraient d'endommager le Ti DRV8824. Pololu met en garde à ce sujet.

Comme sur l'EasyDriver, nous retrouvons un potentiomètre de réglage du courant maximum. La valeur de ce courant est également fixée par la tension de référence Vref au point de mesure et la résistance de capture de courant Rs. Le courant maximum Imax est donné par la formule : Imax = Vref/5Rs. Contrairement à l'EasyDriver la valeur minimum de Vref n'est pas de 1V mais de 0V, ce qui théoriquement permet de descendre plus bas. En pratique, la documentation du Ti DRV8824 indique que les performances sont moindres si  Vref est en dessous de 1V.

Le rôle des 16 broches est indiqué au verso de la carte.

Image
  • Le moteur pas-à-pas est connecté via les A1 et A2 pour la première bobine et B1 et B2 pour la seconde ;
  • L'alimentation du moteur est connectée sur les deux broches VMOT et GND (entre 8,2V et 45V). Il est également possible d'alimenter le moteur avec une tension plus élevée que celle qu'il supporte à condition de régler le courant à une valeur inférieure ou égale au courant supporté par le moteur;
  • Les deux masses sont reliées entre elles et l'une au moins devra être connectée à la masse de la carte microcontrôleur employée (Arduino ou autre);
  • RESET, ENABLE et SLP (pour SLEEP) permettent respectivement de faire une réinitialisation du Ti DRV8824, de l'activer ou de le mettre en veille;
    • RESET doit être amené à 0 puis à 1 pour réinitialiser le Ti DRV8829. Les deux bobines sont alimentées à 70,71% et le rotor se place sur un demi-pas. Le Ti DRV8824 tire RESET à 0 via une résistance interne de 100kΩ. Il est donc nécessaire de connecter RESET au 5V pour que que le RESET ne soit pas actif.
    • ENABLE doit être constamment à l'état 0 (bas) pour que le Ti DRV8824 pilote les bobines du moteur et que ça logique soit opérationnelle. Cette entrée est tirée à  0V via une résistance interne de 100kΩ. On peut laisser cette broche;
    • Enfin SLP peut être mise à l'état bas pour mettre le Ti DRV8824 en veille. Cette entrée est tirée à 0V via une résistance interne de 1MΩ. Il faut donc raccorder cette broche au 5V pour que le pilote reste actif.
  • M0, M1 et M2 permettent de fixer le nombre de micro-pas entre 2 pas selon la table suivante. Le Ti DRV8824 tire ces broches 0V via des résistances internes de 100kΩ avec pour conséquence un mouvement par pas entiers si ces elles sont laissées en l'air. Il est donc nécessaire de les relier conformément à la table;

    Image
  • DIR fixe le sens de rotation du moteur;
  • STEP permet de faire avancer le moteur au micro-pas suivant. Une transition de 0 à 1 provoque cette avance.
  • Enfin le Ti DRV8824 met FAULT à 0 si un courant excessif ou une température trop élevée est détectée.
Par rapport à l'EasyDriver, la broche permettant de sélectionner la manière dont le courant décroît est manquante. Elle est bien présente sur le Ti DRV8824, il s'agit de la broche 19: DECAY, mais n'est pas disponible sur le DRV8824 et est laissée en l'air. Cette configuration fixe la décroissance du courant à mixed.

Soudage des broches et carte de montage

Le DRV8824 est livré avec une barrette à broches que j'ai soudée sous la carte. Il n'y a absolument pas la place de l'équiper des mêmes connecteurs que ceux que j'ai utilisés pour l'EasyDriver.

Image

Afin de pouvoir réutiliser ma connectique, j'ai bricolé une petite carte accueillant le DRV8824 et mon connecteur pour le moteur et s'enfichant dans la breadboard.

Image

Image

Le connecteur d'alimentation sera planté séparément sur la breadboard pour pouvoir ajouter le condensateur de filtrage préconisé par Pololu.

Quelques nouvelles des essais.

J'ai mis en œuvre le module Pololu

Nette amélioration par rapport à l'EasyDriver. Les 32 µPas lissent très bien le passage des micro-pas. J'ai pu descendre la vitesse à 1 tour en 3 minutes et les phases d'accélération et de décélération se passent bien.

Il restait malgré tout une très légère vibration à vide qui devenait un peu plus visible quand le pont était chargé  :?

2 pistes d'amélioration possible :

1 - la broche DECAY est en l'air. Donc la décroissance de courant est fixée à mixed. Je voulais essayer en slow decay car cela avait amélioré les choses avec l'EasyDriver. Donc mettre DECAY à 0V

2 - remplacer les résistances de mesure de courant par des 2,2Ω (au lieu de 0,33) de manière à avoir un Vref max qui fixe le courant à 300mA (max admissible par mon moteur) et qui permettent donc d'avoir un Vref > 1V comme le recommande la datasheet. En effet, avec des résistances de 0,33Ω, il faut que je mettre un Vref vers 0,44V. Mais c'est une opération délicate.

J'ai donc d'abord essayé le 1. J'ai mis un fil à la masse et touché la broche DECAY. C'était moins bien, passage carrément irrégulier des pas. qu'à cela ne tienne essayons avec DECAY à 3,3V...

Et là impeccable ! mouvement très fluide même pont chargé !

La très bonne nouvelle est que pour mettre DECAY à 0V, il aurait fallu que je soude un fil sur la broche pour aller chercher la masse 5mm plus loin (je rappelle que les broches sont au pas de 0,65mm, c'est minuscule). Pour mettre DECAY à 3,3V, c'est très facile, la broche FAULT qui est voisine est elle-même à  3,3V. Il suffit donc de poser une goutte de soudure entre ces deux broches et l'affaire est bouclée  8)

L'article complet sur les essais et des vidéos dès que je peux ;)

Voici la suite. L'article est également disponible sur mon blog avec les vidéo que je n'arrive toujours pas à insérer ici.

http://modelleisenbahn.triskell.org/spip.php?article72

Pour les essais de la DRV8824, le moteur reste le même que celui employé dans « Mise en œuvre de l’EasyDriver v4.4 pour un pont tournant » avec 400 pas par tour. La latte de bois a été remplacée par un tasseau d'un longueur un peu plus faible dans le but de pouvoir charger le pont avec une masse équivalente à celle d'une locomotive en H0 (Certes, je construis un réseau à l'échelle N mais je pense aussi à mes petits camarades H0istes) afin d'observer le comportement en charge.

Les possibilités offertes par la DRV8824

En combinant les 400 pas par tour du moteur et les 32µPas du Ti DRV8824, on arrive à 12800 µPas par tour ce qui est considérable. Pour un pont tournant à l'échelle H0, disons de 30cm de diamètre, cela donne un déplacement de moins de 0,075mm par µPas en bout de pont. Avec un pont à l'échelle N on tombe à 0,037mm en bout de pont. Un déplacement de moins d'1/10e de millimètre est imperceptible.

La connexion de la DRV8824 est presque aussi simple que celle de l'EasyDriver, il y a juste quelques broches supplémentaires à connecter à la masse ou au +5V car l'état par défaut qu'elles adoptent lorsqu'elles sont en l'air ne convient pas.

Il faut donc connecter  les broches DIR et STEP comme pour l'EasyDriver mais en plus connecter la broche SLEEP à 5V, la broche ENABLE à 0V et les broches M0, M1 et M2 à 5V pour disposer de 32 µPas. J'ai choisi de piloter la broche RESET avec la broche 4 de l'Arduino. En effet, à l'allumage du système, les entrées/sorties numériques de l'Arduino étant en entrée, RESET est en l'air et, par conséquent, le Ti DRV8824 est maintenu dans l'état RESET. Cela évite de faire faire au moteur des mouvements involontaires dus aux transitoires sur les entrées DIR et STEP. Lorsque le programme démarre, la broche 4 est mise en sortie et RESET est mis à l'état haut après que les états de DIR et STEP aient été fixés. De cette manière le moteur ne bronche pas à la mise sous tension.

Un autre point important est le condensateur chimique qui permet d'absorber les transitoires de la mise sous tension. Transitoires qui pourraient détruire le composant. J'ai donc implanté sur la breadboard un condensateur de 470µF 35V.

Image

La tension moteur est fixée à 12V. Les alimentations sont séparées comme pour le montage de l'EasyDriver.

Image

Réglages de la DRV8824

Le potentiomètre de montage sur la DRV8824 permet de régler la tension Vref qui fixe le courant maximum. Comme Vref = Imax ×5Rs, avec Rs = 0,33Ω, un Imax ≤ 300mA donne un Vref  ≤ 0,5V. En tâtonnant, une valeur de 0,47V donne le meilleur comportement (Lorsque le Mixed Decay est sélectionné).

Le résultat obtenu avec ce réglage est sur la première vidéo :

[youtube]opi2D4BsxPo[/youtube]

La plus haute résolution du Ti DRV8824 par rapport à l'Allegro A3967 qui équipe l'EasyDriver donne un bien meilleur résultat mais ce n'est pas encore parfait.

Deux pistes d'amélioration existent. La première concerne le Vref. En effet, la valeur de Vref nécessaire pour le moteur choisi est en deçà de ce qui est préconisé par Texas Instruments mais augmenter Vref demanderait de remplacer les résistance de capture de courant de 0,33Ω pas des résistances de 2,2Ω. De cette manière le Vref maximum de 3,3V correspondrait à un courant maximum de 300mA.

Se lancer dans cette modification un peu risqué et une autre piste a été privilégiée: le changement du DECAY car comme on avait pu le voir dans « Mise en œuvre de l’EasyDriver v4.4 pour un pont tournant », son influence est importante. Malheureusement, comme on l'a vu dans «La DRV8824 de Pololu », le DECAY n'est pas disponible sur les broches de la DRV8824. Il faut aller le chercher sur la broche 19 du Ti DRV8824. En mettant cette broche à la GND, on sélectionne le Slow Decay et en la mettant à +5V, on sélectionne le Fast Decay.

En Slow Decay le comportement est moins bon avec un net pompage qui apparaît.

En Fast Decay le comportement est bien meilleur. La vibration, présente quand le pont est chargé, disparaît.

Il se trouve que la broche 19 voisine avec la broche 18, FAULT, qui a l'énorme avantage d'être à l'état haut en temps normal (Si FAULT passe à l'état bas, le composant est en erreur et la valeur à laquelle DECAY est mis n'a pas d'importance). Il suffit donc de déposer une goutte de soudure pour réunir ces deux broches et sélectionne le Fast Decay. Relier DECAY à GND aurait été beaucoup plus sportif car il aurait fallu souder un fil volant entre DECAY et le GND qui se trouve à une dizaine de mm de là.

Image

Il reste malgré tout un très léger pompage qui est résolu par la diminution du Vref de manière à obtenir un courant entre 200mA (pont chargé en H0)  et 150mA (pont lège en N). Le résultat est excellent, même dans les phases d'accélération et de décélération, comme en atteste la seconde vidéo

[youtube]Qi1aWqdYrn8[/youtube]

Le logiciel

La commande de la DRV8824 étant identique à celle de l'EasyDriver le logiciel reste, dans les grandes lignes, identique à celui décrit dans « Mise en œuvre de l’EasyDriver v4.4 pour un pont tournant ». Evidemment, comme il y a 4 fois plus de micro-pas il faut diminuer le délai entre le passage de 2 micro-pas. Sur l'EasyDriver, le délai avait été fixé à 37ms. Ici il est fixé à 16ms. Un tour est donc accompli en 12800 × 16ms = 3 minutes et 25 secondes environ, ce qui est conforme à la réalité.

Durée du STEP

Le Ti DRV8824 est moins tolérant que l'Allegro A3967. STEP} doit resté au même état au moins 1,9µs alors que sur le {A3967} nous avions 1µs. Si comme précédemment, on écrit:

void loop()
{
    digitalWrite(pinMicroPas, LOW);
    digitalWrite(pinMicroPas, HIGH);
    delay(16);
}


On risque de na pas satisfaire cette condition entre les deux digitalWrite(...). Les 16ms sont donc répartis comme ceci:

void loop()
{
    digitalWrite(pinMicroPas, LOW);
    delay(8);
    digitalWrite(pinMicroPas, HIGH);
    delay(8);
}


Conclusion

La DRV8824 de Pololu est donc retenue pour la mise en œuvre du pont tournant. Le prochain article portera sur la détection du 0 du pont.

Bonjour,

J'ai mis en œuvre la détection du zéro avec un capteur optique comme celui-ci :

http://www.tme.eu/en/details/tcst2103/p ... rs/vishay/#

Ça se passe sans difficulté particulière.

Mais je ne suis pas très content de la procédure de recherche du 0. Je trouve embêtant d'avoir cette recherche qui se fait à chaque mise sous tension des équipements.

Je compte donc essayer une autre méthode permettant d'avoir la position absolue du pont. Il s'agit d'utiliser une roue codeuse absolue à 100 positions comme ceci :

Image

où la position absolue est codée en binaire au moyen du blanc et du noir. Cette roue serait solidaire de l'axe du moteur et placée sous la table. Elle serait lue au moyen de 7 capteurs infrarouge par reflexion. Celui-ci, qui est assez petit pour avoir une roue de diamètre raisonnable (11cm) http://www.tme.eu/en/details/ktir0711s/ ... lectronic/#

Pololu fabrique des barrettes de capteurs (8) qui semblent utiliser le même composant mais le pas des capteurs est trop important et engendrerait une roue de diamètre trop important (http://www.pololu.com/product/961)

Pourquoi 100 positions et pas 400 ? (notez qu'avec 400 je serais bien embêté pour réaliser la roue, les zones blanches ou noir feraient moins d'1mm d'épaisseur avec une roue de 11cm de diamètre). Parce que le cycle d'alimentation des bobines d'un moteur pas à pas se répète tous les 4 pas entiers. Autrement dit, on peut voir un tour moteur comme 100 groupes de 4 pas. Quand on allume le DRV8824, il se positionne est un point particulier du  groupe de 4 pas (le home state) de sa position initiale mais on ne sait pas dans quel groupe. Il suffirait donc de lire le numéro du groupe sur la roue.

Comme je pense mettre les capteurs assez proches l'un de l'autre, le pas est de 3,81mm (150 mils), il existe peut-être un risque qu'un capteur bave sur son voisin. Je les allumerai donc en deux fois. Un coup avec les capteurs impairs et un coup avec les capteur pairs, pour faire une lecture. De cette manière il y aura 7,62mm entre deux capteurs actifs et pas de risque que l'un bave sur l'autre.

Bonsoir,

Un petit schéma d'organisation de l'électronique et de la motorisation sous le pont tournant. Il s'agit d'un pont PECO N que je n'ai pas encore (il est en route, je l'attends)

Image

Les critiques sont bienvenues :)

Bonjour et bonne année 2014 !

L'article est également disponible sur mon blog : http://modelleisenbahn.triskell.org/spip.php?article74

Algorithme de rotation du pont

Après avoir présenté le matériel nécessaire au pilotage du moteur pas-à-pas par µPas et le choix de la DRV8824 de Pololu pour sa meilleure résolution et la fluidité de mouvement qui en résulte, il est temps de se pencher sur l'algorithme qui permet de décider du sens de rotation et de la décomposition du mouvement en phase d'accélération, en régime permanent et en phase de décélération.

Calcul du sens de rotation pour le plus court chemin

Le pont est bien évidemment orienté. C'est à dire que les positions p et p+180° sont différentes. Avec la DRV8824, nous avons 12800 positions possibles que nous allons numéroter de 0 à 12799. Partant de la position courante, le pont devant aller dans une nouvelle position, il faut décider dans quel sens tourner pour minimiser la distance parcourue. C'est à dire que partant de la position courante 12799 et allant à la position 0, il n'y a qu'un µPas à effectuer et non 12799.

On va distinguer deux cas:
1 - La position à atteindre à un numéro > à la position courante;
2 - La position à atteindre à un numéro < à la position courante.

Par convention, on va également décider qu'un déplacement positif se fait dans le sens horaire et un déplacement négatif dans le sens trigonométrique.

La position à atteindre à un numéro supérieur à la position courante

Ce cas correspond à la figure ci-dessous:

Image

chemin 1 se calcule en soustrayant la position courante à la position destination : chemin 1 = position destinationpositition courante.
Il est bien positif, la rotation pour parcourir chemin 1 se fait dans le sens horaire.

chemin 2 doit être négatif puisque la rotation de fait dans le sens trigonométrique et il se décompose en deux: d'une part la portion entre la position courante et 0 et d'autre part la portion entre 12800 et la position destination.
On a donc chemin 2 = — (positition courante + 12800 — position destination)

La position à atteindre à un numéro inférieur à la position courante

Ce cas correspond à la figure ci-dessous:

Image

chemin 1 se calcule également en soustrayant la position courante à la position destination : chemin 1 = position destinationpositition courante.
Comme la position courante est plus grande que la position destination, il est bien négatif, la rotation pour parcourir chemin 1 se fait dans le sens trigonométrique.

chemin 2 doit être positif et se décompose en deux : d'une part la portion entre la position courante et 12800 et d'autre part la portion entre 0 et la position destination.
On a donc chemin 2 = 12800 — positition courante + position destination.

Pour choisir le chemin, il suffit de comparer les valeurs absolues de chemin 1 et chemin 2 et de choisir le chemin ayant la plus petite. Le signe du chemin donne le sens de rotation.

Le code correspondant est le suivant:

    int chemin1 = positionDestination - positionCourante;
    int chemin2;
    if (positionDestination > positionCourante)
      chemin2 = - (positionCourante + 12800 - positionDestination);
    else
      chemin2 = 12800 - positionCourante + positionDestination;
     
    int chemin;
    int dir;
    if (abs(chemin1) > abs(chemin2))
      chemin = chemin2;
    else
      chemin = chemin1;
    
    /* Si chemin < 0, la direction est mise à 1 */
    if (chemin < 0)
      dir = HIGH;
    else
      dir = LOW;


Le nombre de µPas à parcourir sera mis dans une variable distance calculée comme suit : distance = abs(chemin);.

Vitesse de rotation, accélération et décélération

La vitesse de rotation d'un pont tournant est assez faible. On peut par exemple voir dans cette vidéo qu'il faut environ 2 minutes (entre 45" et 2'45") pour que la 141TD~740 fasse son demi-tour, ce qui donne 4 minutes pour un tour.

[youtube]CYeE9b1WWqw[/youtube]

Dans notre cas, il faut donc passer 12800 µPas en 4 minutes soit 240s, ce qui donne un délai de 18 à 19ms entre deux µPas. Pour clarifier le code, ce délai va être mis dans une variable delaiInterMicropas, ce qui permettra aussi de changer la vitesse de rotation sans avoir à modifier le code.

Si on ne se soucie pas d'avoir des phases d'accélération et de décélération, le code est très simple:

Code : Tout sélectionner

for (microPas = 0; microPas < distance; microPas++)
{
  digitalWrite(stepPin, LOW);
  delay(1);
  digitalWrite(stepPin, HIGH);
  delay(delaiInterMicroPas - 1);
}


Mais le mouvement a une allure artificielle. Il est donc préférable de simuler une petite phase d'accélération et de décélération.

Les phases d'accélération vont être réglées en nombre de µPas passés à accélérer et à décélérer. On va donc avoir 2 variables microPasAcceleration et microPasDeceleration pour régler ces phases.

Un mouvement d'une position courante à une position de destination consiste donc à parcourir microPasAcceleration µPas avec un délai variable et décroissant puis à parcourir distance - microPasAcceleration - microPasDeceleration µPas avec un délai delaiInterMicropas et enfin parcourir microPasDeceleration µPas avec un délai variable croissant.

Bien entendu, il ne faut pas que microPasAcceleration + microPasDeceleration soit supérieur à distance. En pratique les phases d'accélération et de décélération seront courte et la distance est supérieur à l'écartement de la voie utilisée. Par exemple pour un pont en N de 150mm de diamètre, les 9mm d'écartement correspondent à 245 µPas.

Le délai initial de la phase d'accélération est calculé est ajoutant  microPasAcceleration à delaiInterMicropas. On va ensuite boucler microPasAcceleration fois en diminuant le délai de 1 à chaque tour pour donc terminer sur un délai égal à delaiInterMicropas. Comme ceci:

      int delai = delaiInterMicroPas - 1 + microPasAcceleration;
      for (microPas = 0; microPas < microPasAcceleration; microPas++) {
        digitalWrite(stepPin, LOW);
        delay(1);
        digitalWrite(stepPin, HIGH);
        delay(delai);
        delai-- ;
      }


Le mouvement a vitesse maximum est accompli par la boucle suivante:

      for (microPas = 0;
           microPas < (distance - microPasAcceleration - microPasDeceleration);
           microPas++)
      {
        digitalWrite(stepPin, LOW);
        delay(1);
        digitalWrite(stepPin, HIGH);
        delay(delaiInterMicroPas - 1);
      }


Enfin, la phase de décélération consiste à boucler microPasDeceleration fois en augmentant le délai de 1 à chaque tour, delai est initialisé à la valeur delaiInterMicropas. Comme ceci:

      for (microPas = 0; microPas < microPasDeceleration; microPas++) {
        digitalWrite(stepPin, LOW);
        delay(1);
        digitalWrite(stepPin, HIGH);
        delay(delai);
        delai ++;
      }


Tout cela est mis dans une fonction allerAPosition(...).

Sketch de démonstration

Voici le câblage :

Image

Et le sketch de l'application de démonstration. Il contient la fonction allerAPosition(...) et l'exécution d'un scénario de mouvement.

Image
Sketch de démonstration du pont tournant

La suite. L'article est également disponible sur mon blog http://modelleisenbahn.triskell.org/spip.php?article73

Détection du zéro du pont tournant

Un moteur pas-à-pas employé seul ne permet pas de connaître sa position à la mise sous tension du système. Nous allons examiner les solutions qui s'offrent à nous pour connaître la position du pont. Dans ce qui suit, le Z est le zéro du pont, ceci afin de ne pas la confondre avec la valeur 0.

Quelques remarques préliminaires sur les moteurs pas-à-pas

Un moteur pas à pas bipolaire, si on le pilote par pas entiers, accomplit sa rotation via l'application sur ses bobines d'un courant positif ou négatif selon la séquence suivante (mode deux phases à la fois) :

Image

Une fois à l'étape 3, on recommence à l'étape 0. Pour inverser le sens de rotation, on inverse la séquence. Au lieu de faire 0, 1, 2, 3, on fait 3, 2, 1, 0. À chaque étape correspond le franchissement d'un pas.

À l'allumage du système, on doit décider quelle est l'étape initiale. Par exemple l'étape 0. Par conséquent, bien que ne connaissant pas la position du moteur en général, on connaît sa position au sein d'un groupe de 4 pas.

Ceci reste vrai avec un fonctionnement par µPas. Que ce soit l'EasyDriver ou la DRV8824, à l'allumage et après un RESET, le courant dans les bobines est fixé à +70,71%, état appelé le Home State et cet état se retrouve bien entendu après avoir franchi 4 pas entiers ou 32µPas pour l'EasyDriver et 128 µPas pour la DRV8824.

Donc, avec un moteur 400 pas par tour, il suffit d'être capable de détecter 100 positions ou bien d'en détecter 1 sur 100 pour savoir où est le moteur.

Cette caractéristique facilite énormément la détection du 0 du pont. En effet, dans le cas de la DRV8824,  si il avait fallu détecter la position au µPas près, il aurait fallu disposer d'un capteur capable de distinguer deux positions séparées de 0,028125°, soit de 0,037mm en bout de pont pour un pont de 150mm de diamètre, ce qui n'est pas une mince affaire. En réalité le capteur doit être capable de distinguer deux positions séparées de 128µPas, c'est à dire 4,71mm en bout de pont, ce qui est très facile à réaliser.

La solution sans capteur

Voici une première solution qui m'a été suggérée par Pierre59.

Il s'agit de faire le Z à la main une première fois. On allume l'électronique de commande et le pont est positionné, au moyen de poussoirs ou un autre moyen d'interaction avec l'électronique, sur un Z arbitraire qui correspond à une des voies de sortie. Le µPas à l'intérieur du bloc de 128 où se trouve le Z est mémorisé dans l'EEPROM du micro-contrôleur (ce qui revient à ne garder que les 7 bits de poids faible) sachant que la valeur 0 correspond au Home State.

À chaque mouvement ultérieur du pont, le numéro de bloc de 4 pas courant est également mémorisé en EEPROM afin de conserver de manière non volatile la position courante du pont quand on arrête le système.

En cas de coupure brutale de l'alimentation, il est nécessaire de garantir que le pont est dans un bloc de 4 pas connu. En effet si la coupure d'alimentation intervient à l'instant de passage d'un bloc au suivant, il se peut que le programme estime être dans le bloc suivant alors que l'arrêt effectif s'est produit dans le bloc courant. L'inverse est aussi possible d'ailleurs. De plus l'écriture en EEPROM alors que l'alimentation du micro-contrôleur se coupe peut être incertaine.

Il est donc nécessaire de disposer d'une petite réserve d'énergie et d'une détection de la coupure d'alimentation afin d'effectuer les opérations ultimes assurant que l'état est stable au moment de l'extinction.

Avantage pas de capteur.

Inconvénients procédure manuelle pour faire le Z, matériel de gestion de la coupure d'alimentation, pas de possibilité de détecter un mouvement manuel du pont lorsque le système est éteint.

Solution avec un capteur de position Zéro

La seconde solution consiste à assujettir à l'axe du moteur un ergot dont on sera capable de  détecter la position en utilisant, par exemple, un capteur optique. Ce type de capteur est constitué d'une fourche entre les branches de laquelle un faisceau infrarouge est établi. Il s'agit donc de détecter la coupure du faisceau par l'ergot.

Image

Comme expliqué à la fin du paragraphe sur les moteurs pas-à-pas, la précision n'a pas à être extraordinaire. En plaçant l'ergot à 40mm de l'axe du moteur, deux blocs successifs de 128µPas sont distants de 2,5mm.

Afin d'expérimenter cette solution, j'ai ajouté à mon banc d'essai un plateau sur lequel est fixé le moteur et le capteur.

Image

La recherche du Z n'est pas très compliquée. Il suffit de faire tourner le moteur dans un sens quelconque jusqu'à ce que l'ergot soit détecté. Dans cette phase, il n'est pas nécessaire de respecter une vitesse de rotation réaliste. L'important est que le temps de recherche du zéro soit le plus court possible sans risquer de faire valdinguer une éventuelle locomotive stationnée sur le pont. Il faut aussi se prémunir d'un dysfonctionnement éventuel du capteur et n'effectuer qu'un tour complet.

Il vient donc la fonction suivante:

boolean chercheZero()
{
  int microPas;
  int blocPas;
  boolean zTrouve = false;
  
  /* Allume la LED indiquant que la recherche est en cours */
  digitalWrite(ledPin, LOW);
  
  /*
   * Boucle de recherche. On effectue un tour complet
   * (parcours de 100 blocs de 4 pas. Un bloc est constitué de
   * 128 micropas). Pour chaque bloc, on parcoure 128 micro-pas
   * à raison de 1,1ms par micro-pas. Soit 14s pour le tour
   * complet
   *
   * zTrouve permet de savoir si on est sortit de la boucle en
   * trouvant Z ou non.
   */
  for (blocPas = 0; blocPas < 100; blocPas++) {    

    if (digitalRead(sensorPin) == 0) {
      /* Z est trouvé */
      zTrouve = true;
      break;
    }
    
    /* Avance de 128 micro-pas */
    for (microPas = 0; microPas < 128; microPas++) {
      digitalWrite(stepPin, LOW);
      delayMicroseconds(100);
      digitalWrite(stepPin, HIGH);
      delay(1);
    }
  }
  
  /* Signale le fait que Z a été trouvé ou non */
  if (zTrouve) {
    /* Eteint la LED de recherche */
    digitalWrite(ledPin,HIGH);
  }
  else {
    /* problème, fait clignoter rapidement la LED */
    int i;
    for (i = 0; i < 20; i++) {
      digitalWrite(ledPin,HIGH);
      delay(50);
      digitalWrite(ledPin,LOW);
      delay(50);
    }
  }
  
  /*
   * Si on a trouvé Z, on met à 0 la position actuelle
   */
  positionCourante = 0;

  /* retourne true si on a trouvé Z */
  return zTrouve;  
}


Cette solution peut être améliorée en stockant la position atteinte en EEPROM. En cas de coupure intempestive de l'alimentation, il sera nécessaire de refaire le Z. Ceci peut être détecté automatiquement sans ajouter de matériel. En effet, il suffit à chaque mouvement du pont, de mettre un octet de l'EEPROM à 0 au début puis de le mettre à 1 à la fin. Si au démarrage du système cet octet est trouvé à 0, cela signifie que l'alimentation a été coupée alors que le pont était en mouvement et que le logiciel n'avait pas encore écrit sa nouvelle position en EEPROM. Il n'y a par contre pas de moyen de détecter une rotation manuelle du pont alors que le systèmes est éteint.

Avantage Procédure automatique pour trouver Z.

Inconvénient Procédure disgracieuse pour trouvez Z.

Solution avec un codeur absolu

Cette dernière solution consiste à mettre en œuvre un codeur absolu. Il s'agit d'une roue codeuse divisée en autant de secteurs qu'il y a de positions. Sur chaque secteur, on dispose radialement des zones noires ou blanches. Une zone code un 0 ou un 1 binaire. Les N zones disposées sur un secteur codent donc un nombre sur N bits.

Dans notre cas, nous avons 100 positions pour le moteur et il faut donc 100 secteurs. Le nombre N de bits est de 7 car ils faut être capables de coder au moins 100 valeurs différentes. Or 2^7 = 128. La roue codeuse a donc cet aspect :

Image

Cette roue est assujettie à l'axe du moteur pas-à-pas et 7 capteurs IR réflectifs sont employés pour lire les 7 bits codant la position du moteur.

Il faut que le capteur soit relativement petit pour que la roue codeuse tienne facilement sous un pont tournant à l'échelle N. Mes investigations m'ont conduit à examiner deux capteurs IR réflectifs : le KTIR0711S de Kingbright  et l'EE-SY193 d'Omron. Dans les deux cas il s'agit de composants montés en surface d'une dimension de 3,3mm sur 2,7mm. Après discussion avec mes camarades, mon choix s'est porté sur le capteur d'Omron car il semble plus précis.

Avantage Position du pont connue à l'allumage sans procédure y compris en cas de rotation manuelle.

Inconvénients Capteurs plus compliqués à mettre en œuvre.

Cette solution a ma préférence car elle évite toute procédure de détection du Z, qu'elle soit automatique ou manuelle.

Bonsoir,

(également su mon blog à http://modelleisenbahn.triskell.org/spip.php?article76)

J'ai reçu 16 capteurs EE-SY193 la semaine dernière et, bien entendu, la première chose que j'ai faite ce week-end est d'en monter un sur une breakout board de ma fabrication pour examiner son fonctionnement. Le composant est petit mais pas au point de poser des problèmes de soudage.

Ce capteur et 6 de ses semblables doit trouver sa place sur la carte de commande du pont tournant. Il permettra de lire une roue codeuse absolue afin de connaître la position absolue du pont comme expliqué dans « Détection du zéro du pont tournant ».

Image

Le montage est classique pour ce type de composant. La LED IR est alimentée via une résistance de 180Ω afin de limiter le courant à 20mA. Le collecteur du photo-transistor IR est tirer à 5V via une résistance de 3,3kΩ et son émetteur est à la masse.

Image

Avec ces valeurs résistances, une surface noire disposée à 1mm de distance du capteur engendre une tension de 4,5V au point de mesure et une surface blanche une tension de 0,5V.

Ok :)

Bonjour,

J'ai reçu mon matériel (composants, visserie, Arduino Nano). La suite donc (l'article est également disponible sur mon blog : http://modelleisenbahn.triskell.org/spip.php?article77)

Une carte Arduino pour le pilotage du pont tournant

Comme le prototypage pour le pilotage du pont tournant a été fait avec un Arduino, j'ai décidé de faire 2 cartes de pilotage. Une première intégrant un Arduino Nano (L'Arduino Uno est trop grand pour se loger sous un pont tournant en N à côté du moteur pas-à-pas. L'Arduino Nano choisi est fabriqué par Funduino, (voir le produit sur dx.com). La version officielle de Gravitech est hors de prix.) et une DRV8824 et une seconde intégrant un PIC 18F26K80 et la même DRV8824. La première carte servira de carte de développement des algorithmes et de matériel pédagogique pour les Arduino. Elle sera commandée via des poussoirs. Quand elle me sera devenue inutile, il est possible que je la vende. La seconde sera intégrée sur mon réseau, permettant ainsi de piloter le pont via le bus CAN des accessoires.

Image

La carte est tirée et il me reste à percer les trous pour placer et souder les composants. J'ai eu un petit soucis de gravure, j'utilise deux transparents superposés qui malheureusement se sont mal superposés sur cette insolation (Il est préférable d'utiliser des transparents polyester qui ne se déforment pas à la chaleur de l'imprimante laser), mais j'ai pu récupérer les pistes collées avec un couteau de modéliste. Ce n'est pas très joli mais l'isolation électrique est bonne.

Un article de description de cette carte suivra, bien entendu.

Bonsoir,

Quelques photos du travail de cet après-midi.

Image

Image

Image

Il n'y a plus qu'à tester, notamment les capteurs  :?

Arduino a écrit :A combien tu estimes le prix de revient pour le faire faire dans le commerce, pour ceux qui ne savent pas faire un CI ?


Ça dépend de la quantité. Le CI fait 132 x 80mm. Chez Eurocircuits :

1 ex : 69€
2 ex : 98€ (49€ l'ex)
5 ex : 131€ (26€ l'ex)
10 ex : 184€ (18€ l'ex)
20 ex : 242€ (12€ l'ex)
30 ex : 300€ (10€ l'ex)
40 ex : 354€ (9€ l'ex)

Disons qu'à partir de 20 ça devient intéressant.

Note qu'alors, il serait intéressant de redessiner la carte en double face pour gagner de la surface et des sous :)

Bonsoir,

Un rapide compte rendu des essais de la journée.

Premier point positif, pour la partie que j'ai testée, la carte fonctionne. La DRV8824 pilote le moteur pas-à-pas, les capteurs captent, les relais relayent.

Pour l'instant j'ai raccordé mon Uno au support prévu pour le Nano avec des fils.

La roue codeuse est en place.

Second point satisfaisant : le moteur ne rayonne pas sur l'électronique. J'avais peur qu'il perturbe les composants mais ce n'est pas le cas.

Au début les valeurs lues était quelque peu aberrantes. L'un des capteurs avait une broche mal soudée et la roue était trop éloignée car les vis de fixation du moteur pas-à-pas ont une hauteur de 2,6mm, 1,25mm de trop si je veux que les capteurs soient à 0,75mm de la roue (distance optimale d'après la datasheet). En les remplaçant par des vis à tête fraisées, j'ai pu descendre la roue à distance optimale.

Après réglage du 0, j'ai chargé un programme test qui avance de 128µPas, lit la valeur sur la roue, compare avec la valeur attendue, etc. Le programme a tourné pendant 4h.

- J'ai une erreur systématique sur le 0 qui est dû à une erreur de conception de la roue. En effet, le centre optique des capteurs n'est pas sur l'axe du composant. Par conséquent sur l'anneau interne des poids fort, c'est limite. Il faut que je modifie mon programme de génération de roue pour décaler les zones et les aligner avec le centre optique.

- Le toner de mon imprimante est faiblard et les noirs ne sont pas très noir :/

- Le zéro, quand le capteur est au-dessus d'une zone blanche, n'est pas très bon. Visiblement je me suis planté dans mon calcul de résistance de tirage. Plutôt que de changer les 7 résistances, je vais envoyer des impulsions de 40mA au lieu de 20 dans les LED IR (1 seule résistance à changer). La marge de bruit est donc faible.

Sinon, pendant les 4h de fonctionnement, à part mon 0 qui donne 64 (poids fort lu à 1), je n'ai eu que deux erreurs. Ce sont deux de trop que je vais m'employer à corriger en réalisant une seconde roue codeuse correctement faite.

___________________________________________________________________________________________

Cliquez ici pour aller a la page d'origine.
:kingmoi:

ImageImageImage


Les dates des bourses d'échange mis a jour ==> ICI <==
Avatar du membre
likikiFrance
Site Admin
Site Admin
Messages : 6655
Enregistré le : 27 févr. 2021, 16:11
Prénom : Christian
LOCALISATION : Ile de France
Centres d'intérêts : Le train miniature (H0 3R), l'impression 3D
Echelle pratiquée : H0
Âge : 56
Pays :
France (fr)
France
avr. 2021 21 18:20

Re: Moteur pas à pas et pont tournant

Message par likikiFrance

Bonjour
jlb a écrit :- Le zéro, quand le capteur est au-dessus d'une zone blanche, n'est pas très bon. Visiblement je me suis planté dans mon calcul de résistance de tirage. Plutôt que de changer les 7 résistances, je vais envoyer des impulsions de 40mA au lieu de 20 dans les LED IR (1 seule résistance à changer). La marge de bruit est donc faible.
Rectification. Je me suis planté mais pas dans les résistances de tirage mais bien dans la résistance de limitation de courant. J'avais bêtement négligé une chute de tension de 1V dans la diode de protection de l'alimentation et calculé la résistance pour 12V. Du coup, je n'ai que 14mA dans les LED IR au lieu de 20. Je vais carrément mettre une résistance de 90Ω au lieu de 180Ω pour avoir un bon 25mA.

L'article est également disponible sur mon blog : http://modelleisenbahn.triskell.org/spip.php?article78

La carte de commande de pont tournant version Arduino

Comme indiqué dans « Une carte Arduino pour le pilotage du pont tournant », j'ai conçu deux cartes de pilotage du pont tournant. La première, qui est décrite ici, intègre un Arduino Nano et une DRV8824 et est destiné à une commande manuelle. Par manuelle, j'entends que l'utilisateur, après avoir programmé quelles sont les positions correspondant à une voie, utilise des poussoirs pour demander l'alignement avec la voie correspondante.

L'alimentation

La carte est alimentée en 12V continu. Le courant nécessaire ne dépasse pas les 500mA. On trouve facilement de petites alimentations industrielles à découpage pour une quinzaine d'Euros.

Cette tension passe par une diode de protection. Cette diode, une 1N4007, évite de détruire l'électronique par un branchement inversé de l'alimentation.

On trouve ensuite le schéma classique des composants autour du régulateur 7805 : deux condensateurs, un électrochimique de 470µF destiner à filtrer les basses fréquences et notamment le pic de la mise sous tension et un polyester de 100nF destiné à filtrer les hautes fréquences. Le 7805 lui même qui, à partir du 12V rectifié, fabrique le 5V d'alimentation de l'Arduino Nano et des LED témoin. Enfin, deux condensateurs en sortie, un électrochimique de 47µF pour le filtrage basse fréquence du 5V et l'autre de 100nF pour le filtrage haute fréquence.

On peut noter que sur le schéma, le boîtier du moteur pas-à-pas qui est fixé à la carte est relié à la masse pour constituer une cage de Faraday et limiter l'émission de rayonnement électromagnétique issu du moteur.

Image

La tension de 12V, rectifiée par la diode et appelée VMOT, sert directement pour l'alimentation moteur de la DRV8824, pour l'alimentation des bobines de 2 relais donc la fonction est décrite plus loin et pour l'alimentation des diodes IR des capteurs. Cette diode engendre une chute de tension de 1V. VMOT est donc de 11V et il faut en tenir compte. Ce n'est pas un problème pour les relais qui collent à partir de 9,6V maximum ou pour le moteur pas-à-pas car avec les courants employés, environ la moitié de ce que consomme le moteur sous 12V, il y a de la marge. Par contre, le calcul du courant dans les diodes IR doit être effectivement fait avec une alimentation de 11V.

L'intégration de la DRV8824

Le montage est repris de l'expérimentation sur {breadboard}. Les broches qui nous intéressent sont le RST (reset) qui permet d'initialiser la DRV8824 par programme, DIR qui permet de fixer la direction de rotation, STEP qui permet de franchir un micropas à chaque transition de l'état bas à l'état haut et FAULT qui permettra au programme de diagnostiquer un problème sur la DRV8824. SLP est fixé à 5V pour que la DRV8824 ne soit jamais endormie, EN est laissé en l'air pour la même raison. Les broches M0, M1 et M2 sont reliées à 5V via un DIP-switch. Ceci n'est pas très utile car le mode 32µPas sera toujours sélectionné mais j'avais des DIP-switch 3 interrupteurs en stock. Le rôle de chacune de ces broches est décrit plus précisément dans l'article sur de la DRV8824.

Image

L'intégration de l'Arduino Nano v3.0

L'Arduino Nano v3.0 est une des incarnations de la famille Arduino. Il est équipé du micro-contrôleur AT-Mega 328. Il s'agit en fait d'une breakout board de 30 broches permettant le montage sur une breadboard mais aussi sur un support. C'est donc un bon choix pour intégrer un Arduino sur une carte de votre conception. Le Nano dispose de 14 entrées/sorties numériques et de 8 entrées analogiques dont 6 peuvent être aussi utilisées en entrées/sorties numériques. Il dispose également d'une prise mini-USB pour le téléversement et la console. Il peut être alimenté via l'USB, via son entrée VIN et son régulateur intégré ou via l'entrée 5V (qui peut être une sortie si VIN est utilisé). J'ai choisi de l'alimenter via le 5V et de laisser VIN en l'air.

Image

TON et REVERSE sont les commandes des relais, STEP et DIR permettent de piloter le moteur pas-à-pas, RESET_DRV permet de faire une remise à 0 du DRV8824, FAULT permet de détecter d'éventuelles erreurs sur ce même DRV8824, ENABLE_C active les capteurs de positions, enfin, b0 à b6 sont les 6 bits lus des capteurs de position.

Les capteurs de position

Il s'agit du capteur OMRON EE-SY193 déjà présenté. Les LED IR des capteurs sont placés en série. La tension de seuil typique avec un courant de 25mA est d'environ 1,25V. 7 capteurs en série donne donc une tension de seuil totale de 8,75V. Par conséquent, sous 11V, la résistance de limitation du courant doit avoir une valeur de (11 - 8,75V) / 25mA = 90Ω.

Les LED IR des capteurs ne sont pas alimentées en permanence mais mises sous tension par programme. Ceci permet d'augmenter la durée de vie du capteur qui n'est utilisé que rarement (Si on considère qu'il faut moins d'une milliseconde pour lire les capteurs, que le temps minimum entre deux lectures est le temps nécessaire pour avancer de 128µPas, soit plus de 2,3s, les capteurs ne sont utilisés que 1/2300e du temps). À cet effet, un transistor NPN est mis en série avec les LED IR et sa base est attaquée par la sortie D8 de l'Arduino au travers d'un résistance de 10kΩ.

Les phototransistors sont montés en émetteur commun. L'émetteur est à la masse et le collecteur est tiré à 5V par une résistance de 3,3kΩ établissant un niveau haut au niveau du collecteur lorsque la surface en vis-à-vis du capteur est noire. Lorsque le phototransistor est passant de par la présence d'une surface blanche, le collecteur est au niveau bas.

Image

Les relais d'alimentation traction et d'inversion de marche

On se place dans le cas d'un réseau analogique. Par sécurité, on peut souhaiter couper l'alimentation traction lorsque le pont n'est pas aligné sur une des voies de sortie. À cet effet, un relai DPDT est intercalé entre l'alimentation du pont et l'alimentation traction. D'autre part, le pont peut aussi opérer une inversion de marche lors du passage d'une position à une autre. Un second relai DPDT permet de décider du sens de marche. Une inversion de marche mécanique est prévue sur le pont PECO NB-55 mais peut s'avérer peu pratique.

Image

La commande de ces relais est classique. Un transistor permet de commander le relai et une diode roue libre absorbe le courant résiduel de la bobine du relai. Les résistances 47kΩ assurent que le transistor reste bloqué à la mise sous tension alors que le micro-contrôleur  ne pilote pas encore les bases des transistors.

Bonjour,

Bilan du week-end :

- dessin d'une roue prenant en compte le décalage du centre optique du composant
- impression sur une imprimante qui a du toner
- changement de la résistance de 190Ω qui limite le courant dans les LED IR par une de 100Ω

Le programme de test fait une lecture de position initiale qu'il stocke dans une variable positionAttendue. Ensuite, il effectue une avance de 128µPas incrémente positionAttendue modulo 100, lit la position et la compare à positionAttendue. Si elles diffèrent, c'est une erreur.

Une petite vidéo :

https://dl.dropboxusercontent.com/u/677 ... odeuse.m4v

Test samedi en fin de journée, c'était ok. Je suis allé me couché avec ~500 lectures sans erreur.

Test longue durée pendant la nuit de samedi à dimanche. Au matin, 2 positions était systématiquement en erreur. Et pour cause, le papier s'était décollé sur 2 positions adjacentes et 3 bits et le papier avait frotté sur les broches des composants côté soudure au point d'arracher le noir. Les emplacements correspondaient aux bits en erreur. Je n'ai jamais eu d'erreur transitoire depuis que la résistance de 100Ω a remplacé la 180Ω.

Restauration de la roue, collage + acrylique blanche et noir et test longue durée la nuit de dimanche à lundi. Après ~135 rotations complète et ~13500 lecture de la valeur codée par la roue, aucune erreur.   :heart: 

En fonctionnement, le DRV8824 est froid ; ce qui diffère de l'EasyDriver qui devenait très chaud, au point que j'avais un petit radiateur en stock au cas où. Le moteur est tiède, je dirais dans les 40°C.

Donc le système est validé, je vais pouvoir monter tout ça sur le pont  8)

La carte de commande de pont tournant version Arduino (2)

Implantation de la carte

Le montage de la motorisation sous le pont est atypique. En effet, au lieu de séparer la partie mécanique de la partie électronique, j’ai choisi d’utiliser la carte électronique comme support du moteur. Une plaque époxy de 1,6mm d’épaisseur a une rigidité suffisante pour supporter le poids du moteur et comme on le verra dans l’article suivant, la hauteur du pont est réglable.

La carte doit s’inscrire dans le cercle du pont tournant PECO NB-55. Le diamètre externe de la fosse est de 154mm. La dimension choisie est de 132mm x 80mm, ce qui correspond à une diagonale de 154mm en limant un peu les coins. Ces dimensions permettent de placer un Arduino Nano entre le petit côté et le moteur pas-à-pas ou bien, pour la version PIC + CAN pour mon réseau, un PIC en boîtier DIP 28 broches comme le 18F26K80 et le transcepteur CAN. Elle permet aussi d’utiliser une roue codeuse de grand diamètre sans placer les capteurs sur une diagonale.

[center]Image
Implantation des composants[/center]

Vu côté composants, avec l’alimentation et la DRV8824 en haut et l’Arduino Nano en bas, la partie commande et l’alimentation sont placées à gauche, la partie relais pour l’alimentation traction et les capteurs de position sont placés à droite.
[center]Image
Carte vue côté composants et Arduino[/center]

Lors du montage du prototype, il est apparu que le connecteur d’alimentation de la DRV8824, en haut à gauche sur la photo, était mal placé. En effet, la prise qui vient se brancher dans le connecteur dépasse un peu côté cuivre et gêne le mouvement de la roue. Une pièce d’époxy de 1mm d’épaisseur vient donc s’insérer sous le connecteur sur la carte prototype. Dans la version définitive, le connecteur sera déplacé sur le petit côté de manière à ne pas gêner la rotation de la roue codeuse.

Supports de la DRV8824 et de l’Arduino Nano

Les deux modules sont montés sur des barrettes à broche femelle. L’espacement entre la carte et les modules est assez important, presque 10mm, et permet de monter des composants sous les modules. Cette caractéristique est assez peu exploitée sur la carte prototype mais pourrait permettre une conception plus compacte en implantant les transistors de commande des relais et des capteurs ainsi que les résistances sous l’Arduino Nano.
[center]Image
Carte vue côté composants et DRV8824[/center]

Les capteurs sont les OMRON EE-SY193 déjà présentés. Ces capteurs sont en boîtier CMS et soudés côté cuivre. Contrairement à des composants ordinaires qui peuvent être soudés un peu n’importe comment pourvu qu’électriquement tout soit correct, ces capteurs doivent être soudés à leur emplacement précis afin d’être bien alignés au centre des zones noires et blanches de la roue codeuse.
[center]Image
Carte vue côté cuivre[/center]

La technique pour souder correctement et rapidement ces composants consiste à les coller à la colle en bombe sur une barre de largeur équivalente à celle du EE-SY193. En l’occurrence, une barre en laiton 3mm x 2mm a été utilisée. L’empreinte des composant est imprimée sur une feuille et collée sur la barre. La barre est ensuite passée à la colle en bombe puis les composants sont disposés à la brucelle.
[center]Image
Positionnement des capteurs sur leurs empreintes[/center]

Il suffit ensuite de retourner et positionner l’ensemble sur la carte et de le maintenir avec une pince. Les deux mains restent libres pour les soudures.
[center]Image
Positionnement de l’ensemble sur la carte en vue du soudage[/center]

[center]Image
Soudage des capteurs[/center]

Les premier essais ont montré un fonctionnement tout à fait satisfaisant de la commande du moteur. Notamment, le moteur ne rayonne pas au point de perturber l’électronique. La résistance en série avec les LED IR des capteurs ayant été mal calculée (180Ω au lieu des 90Ω indiqués dans « La carte de commande de pont tournant version Arduino (1) »), le niveau bas, obtenu pour les zones blanches, était insuffisant car le faisceau IR incident était trop faible et engendrait parfois des lectures erronées. La qualité de réalisation de la première roue codeuse était également insuffisante [1]. Le remplacement de la résistance de 180Ω en série avec les LED IR par une résistance de 100Ω a résolu les problèmes de niveau bas.

Le prochain article traitera du montage de la motorisation sous le pont tournant.

Vers la page original
:kingmoi:

ImageImageImage


Les dates des bourses d'échange mis a jour ==> ICI <==
Avatar du membre
herwatFrance
2000 posts et +
2000 posts et +
Messages : 4870
Enregistré le : 11 mars 2021, 16:14
Prénom : Hervé
LOCALISATION : Creuse
Centres d'intérêts : Modélisme ferroviaire
Impression 3D
Arduino
Echelle pratiquée : H0
Âge : 76
Pays :
France (fr)
France
avr. 2021 21 19:07

Re: Moteur pas à pas et pont tournant

Message par herwatFrance

Bouhhh ! Intéressant, mais va falloir digérer tout ça ! :oops:
Répondre