arpschuino

Piloter jusqu'à 8 moteurs pas à pas en DMX avec l'arpschuino.


moteur pas à pas et driver

Nouvelle mise à jour de notre tuto moteurs pas à pas (mai 2023), l'un des plus visité, avec l'arrivée du firmware 1.2 de l'arpschuino32.

Nous allons voir comment piloter des moteurs pas à pas de puissance, en DMX, avec arpschuino (2 ou 32) et différents types de drivers.


arpschuino, arpstepper et moteurs pas à pas


Matériel requis:

  • Un arpschuino² ou un arpschuino32.
  • Un moteur pas à pas (bipolaire ou unipolaire).
  • Un driver de moteur pas à pas, type Pololu ou TMC2208 pour les petits moteurs, ou comme ceci pour les moteurs de plus de 1,5A.
  • Une alimentation pour les moteurs (plus de choix et top qualité chez Meanweel*).
  • Un adaptateur arp>terminals² ou arpstepper.
  • Une nappe HE10.
  • Une alimentation pour l'arpschuino (entre 6V et 15V continu)*.
  • Option : des interrupteurs de fin de course*.
  • * Nous n'avons aucun lien avec les sociétés citées, les images et les liens sont fournis à titre d'exemple.


    Dans ce tutoriel, nous étudierons :

    1. Le choix du moteur.
    2. Le choix de l'alimentation.
    3. Configuration des drivers type Pololu.
    4. Configuration des drivers pour les moteurs de plus d'un ampère.
    5. Configuration pour les moteurs pas à pas unipolaires.
    6. Le câblage.
    7. Les switchs.
    8. Avec un arpschuino32 : configuration.
    9. Avec un arpschuino² : le code.

    Choix du moteur

    Il y a plusieurs facteurs à prendre en compte : le nombre de pas par tour, la vitesse maxi et surtout le couple maximum.

    Les moteurs bipolaires ont en général 200 pas par tour (soit 1,8° par pas), parfois 400 (0,9°), mais gardez à l'esprit que les drivers permettent les micro-pas, ce qui va nous permettre de multiplier ce nombre jusqu'à 16 fois (ou plus).

    Une donnée essentielle est la valeur du couple maxi. C'est la "force" du moteur. Elle peut s'exprimer dans différentes unités (convertisseur ici).

    Calculer le couple dont vous aurez besoin n'est pas chose facile, ce n'est pas forcément notre spécialité ! Vous trouverez des indications pour vous y aider sur ce site. N'oubliez pas que la valeur de couple d'un moteur dépend de la vitesse de rotation et de la tension d'alimentation (exemple). On vous conseille dans tous les cas de surdimensionner un peu pour ne pas avoir de mauvaise surprise.

    Moteurs pas à pas bipolaires

    Tenez compte du fait que l'utilisation de micro pas engendre une diminution du couple disponible, car dans ce cas, les courants sont inférieurs aux courants nominaux.

    Depuis le firmware 1.2, l'arpschuino32 permet l'utilisation de pas à pas unipolaire à commande directe comme les 28BYJ-48. Ce sont de petits moteurs bon marché, équipé de réducteurs, faciles à intégrer utile pour de nombreuses applications.

    Moteurs pas à pas unipolaires

    Notez aussi qu'il existe des moteurs à double arbre, à arbre hélicoïdaux, à réducteur... Mais là c'est à vous de voir en fonction de vos besoins.


    Choix de l'alimentation

    Pour un couple maximum, on privilégiera la tension la plus élevée, en se référant à la courbe de couple (torque curve) du moteur.

    Le courant de sortie de l'alimentation (en ampères) doit être supérieure au courant par phase du moteur. Ne pas hésiter à la surdimensionner un peu, de 30% par exemple.

    On peut alimenter l'arpschuino avec la même alim que le moteur si elle ne dépasse pas 13V, 24V si l'arpschuino est équipé du pré-régulateur en option.


    Configuration des drivers type Pololu (selon les modèles,de 1A à 1.5A maxi)

    Les plus courants sont les A4988 et les DRV8825, on les trouve partout, sur le site de pololu bien sûr, mais aussi sur les grands sites de vente en ligne et dans les boutiques proposant du matériel pour les imprimantes 3D.

    Vous pourrez aussi vous orienter vers les TMC2208 si vous recherchez des drivers particulièrement silencieux. Note : si vous utilisez un arpstepper d'une version inférieur à 2.1, il faudra relier la broche EN à la masse, en soudant un câble comme ici. Ce n'est plus nécessaire à partir de la version 2.1 de l'arpstepper.

    Nos arpsteppers permettent de brancher simplement ces drivers sur l'arpschuino. Chaque arpstepper peut recevoir jusqu'à 4 drivers et on peut brancher 2 arpsteppers sur un arpschuino pour un total de 8 moteurs.

    arpstepper

    Pour chaque driver, il est nécessaire de régler l'intensité du courant. C'est en ajustant la tension de référence (Vref) qu'on règle l'intensité du courant par phase délivré au moteur.

    Pour celà, vous devez connecter l'arpstepper à l'arpschuino32 avec la nappe HE10. Puis alimenter en premier lieu l'arpschuino32, et ensuite l'arpstepper. Par contre, ne branchez pas encore le moteur pas à pas à l'arpstepper.

    Ce réglage se fait au en tournant la petite vis présente sur le driver et en mesurant la tension avec un multimètre, comme sur l'image ci-dessous.

    En fonction de votre driver, il faut se référer aux documentations des constructeurs. Sur le site de pololu pour les A4988 et les DRV8825. Pour les TMC2208, c'est ici, avec un calculateur.

    réglage DRV8825

    Le réglage du nombre de pas par tour se fait grâce aux cavaliers présents sur l'arp>stepper. En fonction du driver utilisé, les tableaux de réglage diffèrent un peu.

    les cavaliers de l'arpstepper

    Tableau de réglage des micros pas pour l'A4988 :

    MS1 MS2 MS3 Microstep Resolution
    Low Low Low Full step
    High Low Low Half step
    Low High Low Quarter step
    High High Low Eighth step
    High High High Sixteenth step

    Tableau de réglage des micros pas pour le DRV8825 :

    MODE0 MODE1 MODE2 Microstep Resolution
    Low Low Low Full step
    High Low Low Half step
    Low High Low 1/4 step
    High High Low 1/8 step
    Low Low High 1/16 step
    High Low High 1/32 step
    Low High High 1/32 step
    High High High 1/32 step

    Tableau de réglage des micros pas pour le TMC2208 (deux cavaliers seulement):

    MS 1 MS 2 Microstep Resolution
    High Low 1/2 step
    Low High 1/4 step
    Low Low 1/8 step
    High High 1/16 step

    Pour d'autres drivers compatibles, reportez-vous à la documentation.


    Configuration des drivers pour les moteurs de plus d'un ampère.

    On va se baser ici sur le tableau imprimé sur le boîtier du driver.

    tableau

    Les trois premiers dip switchs servent à définir le nombre de pas par tour. On va pour l'instant partir sur une valeur moyenne de 800 pas. Ce qui donne, pour ce driver, on-off-off.

    Les trois suivants permettent de régler l'intensité du courant délivré par le driver. Choisir une valeur inférieure ou égale à l'intensité de votre moteur. Notre moteur est un 4,2A, on choisit donc 3,5A (off-off-off).

    dip switchs


    Configuration pour les moteurs pas à pas unipolaires.

    Pas de réglage particulier avec ce type de driver. Pas de micro pas, des demis pas sont possibles mais c'est un réglage à faire depuis l'arpschuino.

    28BYJ-48 unipolar driver

    Les 28BYJ-48 ont 32 pas par tour seulement, mais une réduction de 1/64 le porte à 2048, voire 4096 pas en mode demis pas. En revanche, n'espérez pas le faire tourner beaucoup plus vite que 30 tours minute.

    Laissez le cavalier en place. En fonction du modèle de moteur l'alimentation se fait en 5v ou en 12v.


    Câblage

    Effectuez toujours le câblage hors tension.

    L'image suivante illustre la façon de câbler un arpstepper :

    cablage arpstepper

    Le câblage avec les drivers en boîtiers n'est pas beaucoup plus compliqué.

    Reliez d'abord l'alimentation dédiée au moteur, aux broches GND (ou V-) et VCC (ou V+ ou Vdc+), puis les 4 câbles du moteur, les couleurs correspondent généralement à la photo mais il est dans tous les cas préférable de se référer à la fiche technique de votre moteur.

    câblage

    On va utiliser l'adaptateur arp>terminals (on aurait pu aussi choisir l'arp>breadboard) pour connecter le driver à l'arpschuino.

    Reliez le +5v aux entrées DIR+(+5v) et PULL+(+5v). Puis Arp0 de l'arpschuino à l'entrée PULL- (fil bleu). Et enfin Arp1 de l'arpschuino, à l'entrée DIR- (fil jaune).

    câblage

    Certains drivers ont l'entrée 5v en commun, les nom peuvent varier légèrement mais le principe reste le même.

    autre types de drivers


    Si vous avez besoin de mixer les deux types de drivers, c'est possible avec le stepper bridge. Placé à la place d'un driver Pololu, il permet de dériver les commandes step et dir vers un driver en boîtier, comme le montre l'illustration suivante.

    stepper bridge

    Les drivers pour moteur unipolaires basés sur des transistors se câblent de la façon suivante :

    wiring-28BYJ

    L'alimentation peut se faire en 5v ou en 12v selon le moteur utilisé.

    Pour la connexion à l'arpschuino, le plus simple est d'utiliser un arp>breadboard et deux nappes, HE10 côté arpschuino et Dupont 4 conducteurs, comme sur la photo :

    wiring-28BYJ


    Les switchs

    Lorsqu'on utilise des moteurs, l'utilisation d'interrupteurs de fin de course est souvent très utile, voire nécessaire. C'est parfaitement possible avec les arpschuinos, depuis la version 1.2 ils sont pris en charge par le firmware de l'arpschuino32.

    limit switch

    Pour fonctionner correctement, ces switchs doivent être équipés de résistances de tirage (pullup) et de petits condensateurs de déparasitage.

    shémat switch

    Si vous utilisez le port A ou B de l'arpschuino, les sorties sont équipés de pullup internes. En utilisant l'arp>terminal-C, vous aurez les petits condensateurs de déparasitage.

    Si vous utilisez le port input de l'arpschuino32, qui lui n'est pas munis de pullup internes, utilisez l'input terminal pour bénéficier de ses pullups et de ses condensateurs.

    photo arp>terminal-C et input terminal

    Dans les deux cas, reliez un pole du switch à la masse et l'autre à l'entrée.

    Ces interrupteurs ne doivent en aucun cas être considérés comme des dispositifs de sécurité type arrêt d'urgence.

    En revanche, vous pourrez bénéficier d'un système de homing (le moteur se recale automatiquement au point zéro au démarrage), et même d'un dispositif d'autocalibration !



    Avec un arpschuino32 : configuration

    Depuis la version 1.2 du firmware, de nombreuses améliorations ont été développées : accélération réglable, interrupteurs de fin de course, prise d'origine du moteur (homing) au démarrage et autocalibration.

    Si vous disposez d'un arpschuino32 avec un firmware plus ancien, faite la mise à jour comme décrit ici.

    Pas besoin de programmer l'arpschuino32, on le configure simplement via un navigateur web, comme décrit dans ce tuto.

    Stepper page


    Avec un arpschuino² : le code

    Le code par défaut de l'arpschuino² ne permet pas de piloter des moteurs pas à pas, il va falloir reprogrammer la carte.

    Pour cela nous aurons besoin du logiciel arduino

    Si ce n'est pas déjà fait, commencez par installer le core arpschuino comme décrit dans ce tuto.

    Depuis la version 1.1.0, la library arpstepper est installée automatiquement avec le core arpschuino. Si vous avez une version antérieure, faites une mise à jour comme indiqué dans ce même tuto.

    Nous allons utiliser le code arpschuino_4steppers qui est disponible dans les exemples de la library ArpStepper, à partir de la version 1.1.0 du core arpschuino.

    code source

    Ce code est fonctionnel, mais quelques ajustements sont nécessaires pour l'adapter à votre configuration mais rassurez-vous : pas besoin d'être programmeur pour s'atteler à cette tâche !

    Les parties en gris clair et/ou précédées de // sont des commentaires, elles ne sont pas prises en compte dans le programme, elles s'adressent à l'humain qui lit ce code (vous).

          Lignes précédées de // = lignes commentées (désactivées)

    définition du nombre de moteurs à piloter :

    
    	#define nbr_motor 4
    					

    Création des objets :

    
    	
    	// configuration matérielle, connexion et réglage du pilote :
    	//hardware configuration, driver connection and adjustment :
    	//(pin dir,pin pull, step_per_revolution)					
    	ArpStepper stepper0(Arp1,Arp0,200);
    	ArpStepper stepper1(Arp3,Arp2,6400);
    	ArpStepper stepper2(Arp5,Arp4,200);
    	ArpStepper stepper3(Arp7,Arp6,800);					
    	
    	//ArpStepper stepper4(Arp9,Arp8,800);
    	//ArpStepper stepper5(Arp11,Arp10,800);
    	//ArpStepper stepper6(Arp13,Arp12,800);
    	//ArpStepper stepper7(Arp15,Arp14,800);
    	
    					

    On "crée" dans le code nos objets stepper. Ici on les a appelés stepper0, stepper1... Mais on aurait pu leur donner n'importe quel nom.

    Entre parenthèses on indique, dans l'ordre, la pin de l'arpschuino reliée au DIR du driver, celle reliée au PULL (ou STEP) et enfin le nombre de pas par tour que l'on a définit lors de la configuration du driver.

    Dans cet exemple, 4 de ces objets sont créés, les créations des suivants sont commentées (désactivées).

    En fonction de votre usage, commentez (en mettant // en début de ligne), ou décommentez une partie de ces lignes pour créer le nombre de moteurs souhaités.


    Prise en charge de l'arpdress board :

    
    	Arp_arpdress_board();
    					

    Ce code, comme la plupart des codes arpschuino, offre la possibilité de définir l'adresse DMX avec l'arpdress board.

    C'est ici qu'on indique à l'arpschuino de prendre en charge l'arpdress board. Si vous ne l'utilisez pas, commentez cette ligne et définissez une adresse fixe en écrivant à la place, par exemple :

    
    	address=24;
    					

    Initialisation :

    
    	//(RPM_min(>0), RPM_max , revolutions, resolution(default 255))				
    	stepper0.init(1, 200, 12, _8bits);
    	//stepper0.invert_rotation(true);
    	stepper1.init(1, 100, 12, _16bits);
    	stepper2.init(2, 300);
    	stepper3.init(2, 300, 12);  
    	
    	//  stepper4.init(2, 300, 12, _8bits);
    	//  stepper5.init(2, 300, 12, _8bits);
    	//  stepper6.init(2, 300, 12, _8bits);
    	//  stepper7.init(2, 300, 12, _8bits);  
    	 
    					

    C'est ici que nous allons initialiser le comportement de nos moteurs.

    En fonction du nombre de moteurs utilisés, on commente ou on décommente, comme pour la création des objets.

    Les deux premiers paramètres entre parenthèses concernent la vitesse : vitesse minimum et vitesse maximum en tours par minutes. La vitesse maxi atteignable dépend du moteur utilisé, si vous demandez une vitesse trop élevée le moteur se bloquera...

    Le troisième paramètre définit la course totale du moteur en nombre de tours. On peut ici mettre un nombre à virgule.

    Le dernier paramètre est optionnel et concerne la commande, _8bits pour une commande avec un canal DMX, _16bits pour une commande sur deux canaux comme pour un projecteur asservi. Si ce dernier paramètre n'est pas renseigné, la commande sera en 8 bit par défaut.

    La ligne //stepper0.invert_rotation(true); est ici commentée, en la décommentant on inverse le sens de rotation du moteur concerné.


    action !

    
    	 stepper0.perform();
    	 stepper1.perform();
    	 stepper2.continuous();
    	 stepper3.perform();  
    		
    	//  stepper4.perform(); 
    	//  stepper5.perform();
    	//  stepper6.perform();
    	//  stepper7.perform();  
    		 
    					

    On indique ici l'action à effectuer, 2 sont disponibles, perform() et continuous().

    Avec perform() on contrôle précisément la position du moteur, en fonction de la course définie précédement.

    Avec continuous(), le moteur est en mode rotation continue. On contrôle le sens et la vitesse.


    patch :

    La fonction refresh() met à jour les ordres donnés aux moteurs. Dans notre cas, la commande se fait en DMX mais la library se prête aussi à d'autres types de commande, midi, OSC ou potentiomètre.

    Placée ici (dans la boucle frame_received()), cette fonction s'exécutera à chaque réception d'une trame DMX.

    On indique donc ici quels circuits DMX seront utilisés pour piloter nos moteurs.

    
       stepper0.refresh(DMX.RxBuffer[0], DMX.RxBuffer[1]);
    					

    DMX.RxBuffer[0], c'est la valeur DMX reçue. Le [0] (entre crochets) s'additionne à l'adresse DMX de l'arpschuino définie plus haut. Autrement dit, c'est l'adresse 1 si l'arpschuino est adressé en 1, 24 s'il est adressé en 24... Adresse de la carte + [0].

    Dans notre exemple, la position du stepper0 est contrôlée par le premier circuit, sa vitesse par le second.

    
       uint16_t position_stepper1 =(DMX.RxBuffer[2]<<8) | (DMX.RxBuffer[3]); 
       stepper1.refresh(position_stepper1, DMX.RxBuffer[4]);
    					

    Nous avions initialisé le stepper1 en mode _16BITS, la position est donc contrôlée par 2 circuits.

    La ligne uint16_t position_stepper1 =(DMX.RxBuffer[2]<<8) | (DMX.RxBuffer[3]); permet de transformer les niveaux 8 bits de deux canneaux en une seule valeure 16 bits (on l'appellera position_stepper1).

    Il ne reste plus qu'à la reporter dans refresh() : stepper1.refresh(position_stepper1, DMX.RxBuffer[4]);

    
       stepper2.refresh(DMX.RxBuffer[5], DMX.RxBuffer[6]);
       stepper3.refresh(DMX.RxBuffer[7], DMX.RxBuffer[8]);
    					

    Même chose pour les deux derniers moteurs. Le stepper2 est en mode continuous, le premier paramètre commande le sens de rotation, le second la vitesse.


    On branche ?

    Il ne reste plus qu'à alimenter l'arpschuino (la led rouge devrait s'allumer) et le driver et à brancher le câble Dmx (ou envoyer du Artnet wifi avec l'arpschuino32). Dès qu'on reçoit du signal, la led verte se met à clignoter rapidement.

    On peut maintenant tester le montage en montant les niveaux des adresse DMX concernées.

    En mode perform, on contrôle précisément la position du moteur. Le premier paramètre DMX (ou les deux premiers, en mode 16 bits) définit la position. Le second (ou le troisième), la vitesse.

    En mode continuous, le moteur effectue une rotation continue. Le premier paramètre DMX contrôle la direction, Le second la vitesse.

    Le moteur tourne ?

    Ca y est ça marche !


    En cas de difficultés, n'hésitez pas à poser des questions sur le forum arpschuino .