arpschuino

   Nouveau !

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


moteur pas à pas et driver

Notre tuto moteurs pas à pas est l'un des plus visité mais il commençait à dater un peu. Nous avons donc décidé de le mettre à jour à l'occasion de l'arrivée de nos adaptateurs pour petits drivers et de notre librairie arpStepper.

Nous allons voir comment piloter des moteurs pas à pas de puissance, en DMX, avec arpschuino et des drivers.


arpschuino, arpstepper et moteurs pas à pas


Matériel requis:

  • Un arpschuino².
  • Un moteur pas à pas (bipolaire, 4 fils).
  • Un driver de moteur pas à pas, type pololu 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)*.
  • * 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. La configuration des drivers type Pololu.
    4. La configuration des drivers pour les moteurs de plus d'un ampère.
    5. Le câblage.
    6. Le code.

    Choix du moteur

    Rappel : ce tuto est écrit pour les moteurs pas à pas bipolaires (4 fils).

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

    Les moteurs sérieux 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.

    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.

    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.

    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

    Le réglage de l'intensité du courant délivré au moteur se fait au en tournant la petite vis présente sur le driver. On trouve sur le net énormément de documentation sur la façon de procéder, bien sûr sur le site de pololu, en vidéo ou ici en français.

    Cela surprendra certaines âmes sensibles ;) mais c'est bien en mesurant la tension qu'on règle l'intensité du courant.

    Attention, ce réglage doit se faire avec l'arpstepper relié à l'arpschuino, mais avec l'alimentation du moteur débranchée.

    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

    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


    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, GND(-) et VCC(+), puis les 4 câbles du moteur, les couleurs correspondent généralement à la photo, dans le cas contraire réferez vous à la datasheet 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


    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'atteller à 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 appellé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 parametres entre parentheses 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 parametre définit la course totale du moteur en nombre de tours. On peut ici mettre un nombre à virgule.

    Le dernier parametre est optionnel et concerne la commande, _8bits pour une commande avec un canal DMX, _16bits pour une commande sur deux cannaux 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'aditionne à 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. 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.

    Le moteur tourne ?

    Ca y est ça marche !


    Aller plus loin.

    Rien ne vous empêche de faire évoluer ce code, d'ajouter des interrupteurs de fin de course, une séquence d'initialisation...

    Pour vous familiariser avec la library, n'hésitez pas à jeter un coup d'oeil aux deux autres exemples de la lib, très simples, ils sont là pour vous aider à isoler les différentes fonctionnalités.

    En cas de soucis ou d'hésitation, n'hésitez pas à nous contacter :

    arpschuino@gmx.fr