arpschuino

Piloter des servomoteurs en DMX avec arpschuino.


servomoteur DMX

Ce tuto à été mis à jour en octobre 2022, avec l'arivée de l'arpschuino32.

Nous allons voir comment piloter des servomoteurs, en DMX, avec arpschuino (2 ou 32).

Matériel requis:

* Nous n'avons aucun lien avec les sociétés citées, les images et les liens sont fournis à titre d'exemple.


Préparatifs

Commençons par observer les spécifications du ou des servomoteurs que nous allons utiliser. En particulier la plage de tension utilisable (Voltage Range) et la consommation (Current Drain).

L'alimentation doit être choisie en fonction des moteurs, ne pas hésiter à la surdimensionner un peu. Plus la tension est élevée, plus le couple et la vitesse seront élevés. Les alimentations 6v ne sont pas courantes, on peut choisir une alimentation 5v, leur tension de sortie peut le plus souvent être élevée à 5,5v environ grâce au potentiomètre d'ajustement.


Câblage

Effectuez toujours le câblage hors tension.

On peut brancher un servo (2 si la consommation des servos est faible) directement sur l'arpschuino². Dans ce cas, mettre le jumper de sélection de tension en position "5V".

Ce n'est pas possible avec l'arpschuino32 qui fonctionne sous 3.3v, sauf avec certain micro-servos qui peuvent fonctionner avec une tension aussi faible.

Comme on peut le voir sur la photo suivante, le brochage des servos permet de se connecter au VCC(+5V), au gnd et à la sortie Arp7 (port du haut) ou Arp15 (port du bas) de l'arpschuino².

servomoteur DMX

Avec l'arpschuino32, ou avec l'arpschuino² si on souhaite utiliser plus de servomoteurs ou les alimenter avec une tension supérieure à 5V, le mieux est d'utiliser notre arp>servo.

Reliez l'alimentation des servos au bornier, puis chaque moteur se branche directement sur l'arp>servo. attention au sens !

câblage

Selon les marques, la couleur des câbles change ... Voici les cas les plus courants :

gnd

Vcc

signal

marron

rouge

orange

noir

rouge

jaune

noir

rouge

blanc

Avec un arpschuino32 : configuration

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

Servo page


Avec un arpschuino² : téléverser

Le code par défaut de l'arpschuino² ne permet pas de piloter des servomoteurs.

Il va donc falloir reprogrammer l'arpschuino (tuto ici). Nous allons utiliser le code arpschuino_servos qui est disponible dans les exemples de la library arpschuino, à partir de la version 1.0.8 du core arpschuino.

code source

Tel quel, ce code devrait fonctionner directement pour 8 servomoteurs branchés sur les sorties Arp0 à Arp7.


On branche ?

Il ne reste plus qu'à alimenter l'arpschuino (la led rouge devrait s'allumer) et l'arp>servo. Dès qu'on reçoit du signal, la led verte se met à clignoter rapidement.

On peut maintenant tester le montage en montant le niveau de la première adresse DMX (par défaut 1 ou celle définie par l'arpdress board).

Le moteur tourne ?


Ca y est, ça marche !

La course maxi n'est pas toujours indiquée dans la doc, mais si votre servo vibre ou a un comportement erratique en fin de course, c'est probablement que cette valeur est dépassée.

Vous aurez peut-être besoin de plus de 8 servos ? De modifier leur course ?

Autant de raisons de modifier le code pour l'adapter à vos besoins.


Aller plus loin.

Regardons ce code source de plus près :

Les parties en gris clair et/ou précédé 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)

Création des objets :



 Servo servo_0;  // create servo object to control a servo
 Servo servo_1;
 Servo servo_2;
 Servo servo_3;
 Servo servo_4;
 Servo servo_5;
 Servo servo_6;
 Servo servo_7;

 //Servo servo_8;
 //Servo servo_9;
 //Servo servo_10;
 //Servo servo_11;
 //Servo servo_12;
 //Servo servo_13;
 //Servo servo_14;
 //Servo servo_15;

Ici c'est la création des "objets servo", il en faut un par servomoteur utilisé. Dans cet exemple, 8 de ces objets sont creé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é.


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;

Affectation des moteurs aux sorties :


	servo_0.attach(Arp0);
	servo_1.attach(Arp1);
	servo_2.attach(Arp2);
	servo_3.attach(Arp3); 
	servo_4.attach(Arp4);
	servo_5.attach(Arp5);
	servo_6.attach(Arp6);
	servo_7.attach(Arp7);  

	//  servo_8.attach(Arp8);
	//  servo_9.attach(Arp9);
	//  servo_10.attach(Arp10);
	//  servo_11.attach(Arp11); 
	//  servo_12.attach(Arp12);
	//  servo_13.attach(Arp13);
	//  servo_14.attach(Arp14);
	//  servo_15.attach(Arp15);

En fonction du nombre de moteurs utilisés, on commente ou on décommente, comme pour la création des objets. Et on indique la sortie de l'arpschuino qui sera utilisée (Arp0, Arp1...) pour chacun des moteurs.


Patch et course :


 servo_0.write(map(ArduinoDmx0.RxBuffer[0], 0, 255, 0, 160));
 servo_1.write(map(ArduinoDmx0.RxBuffer[1], 0, 255, 0, 160));
 servo_2.write(map(ArduinoDmx0.RxBuffer[2], 0, 255, 0, 160));  
 servo_4.write(map(ArduinoDmx0.RxBuffer[4], 0, 255, 0, 160));
 servo_5.write(map(ArduinoDmx0.RxBuffer[5], 0, 255, 0, 160));  
 servo_6.write(map(ArduinoDmx0.RxBuffer[6], 0, 255, 0, 160));  
 servo_7.write(map(ArduinoDmx0.RxBuffer[7], 0, 255, 0, 160));

// servo_8.write(map(ArduinoDmx0.RxBuffer[8], 0, 255, 0, 160));          
// servo_9.write(map(ArduinoDmx0.RxBuffer[9], 0, 255, 0, 160));
// servo_10.write(map(ArduinoDmx0.RxBuffer[10], 0, 255, 0, 160));  
// servo_11.write(map(ArduinoDmx0.RxBuffer[11], 0, 255, 0, 160));       
// servo_12.write(map(ArduinoDmx0.RxBuffer[12], 0, 255, 0, 160));
// servo_13.write(map(ArduinoDmx0.RxBuffer[13], 0, 255, 0, 160));  
// servo_14.write(map(ArduinoDmx0.RxBuffer[14], 0, 255, 0, 160));  
// servo_15.write(map(ArduinoDmx0.RxBuffer[15], 0, 255, 0, 160));

Une fois de plus, on commente ou décommente, en fonction du nombre de moteurs utilisés.

Ces lignes sont un petit peu plus complexes, on peut le décomposer en 2 parties :


	map(ArduinoDmx0.RxBuffer[0], 0, 255, 0, 160)

ArduinoDmx0.RxBuffer[0], c'est la valeur DMX reçue. Le [0] (entre crochets) s'aditionne à l'adresse DMX de l'arpschuino definie 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].

La fonction map va transformer cette valeur DMX reçue, qui va de 0 à 255, en valeurs en degrés, ici de 0 à 160°, utilisable pour piloter le servo.

la course du servomoteur va ici de 0 à 160°. Vous pouvez la réduire ou l'augmenter, sans dépasser la course maximale de votre servo.

Et enfin :


	servo_0.write();

Cette fonction envoie la valeure en degrés que nous venons d'obtenir, au servomoteur.


Après ça, vous aurez peut-être envie/besoin de faire évoluer le code, de le combiner avec un autre etc... On trouve sur le net énormément de documentation sur la programmation arduino, alors n'hésitez pas à vous lancer.

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