[APL] Piloter un potentiomètre motorisé

Piloter un potentiomètre motorisé

L'objet de ce bilet, c'est un démonstrateur pour le pilotage d'un potentiomètre motorisé que l'on trouve sur les tables de mixage automatisées. Il vous faudra adapter le code à votre utilisation, ce code est un code d'essai, où j'ai voulu tester la réponse et la précision de la commande de ce genre de jouets.

Si vous voulez voir le machin bouger, une vidéo médiocre ici : http://perso.orange.fr/rousseau-benoit/images/arduino/potmot/DSCF0001.AVI

Le matériel

Il vous faudra pour 4 personnes :

  • un potar motorisé ;
  • un pont en H genre L293B ;
  • 4 diodes genre 1N4007 si votre "pont en H" ne contient pas de diodes de roue libre ;
  • des dominos (3 suffisent) ;
  • du fil de cablable ;
  • étain ;
  • fer à souder ;
  • ...

Où récupérer ceci ?

Pour le potentiomètre motorisé, on me l'a donné mais vous pouvez en trouver sur des tables de mixage automatisées mises au rebus, ou surement sur ebay, ...

Pour le "pont en H", vus pouvez le réaliser avec des composants classques transistors, ... ou en trouver un tout fait. Il existe plein de références mais j'ai pour ma part récupéré un L293B sur un platine de vieux magnétoscope.

Wow, le coin Français Rock...
Merci Benoît.

Quelques questions:

1- Est-ce que le potentionmètre est absolu (est-ce que l'on envoi la position (entre 0 et 255 par exemple) ou bien ça marche par écarts)?

2- Tu ne sais vraiment pas où trouver des potentiomètres motorisés? Il y a un moment que j'en cherche et je n'ai pas vu ça distribué facilement et c'est assé rare de voir des table de mixages motorisé au rebus. Il y avait des compagnies sur internet, mais c'était ultra dispendieux.

Salut gll,

1 - oui, le potentiomètre est absolu. C'est un potentiomètre "ordinaire". Le convertisseur ana/num de la carte étant sur 10 bits, la valeur retournée varie de 0 à 1023.

2 - Oui, les potar motorisés sont chers et difficiles à trouver. Je peux t'en envoyer 2 ou 3 si tu veux mais pour l'instant mes finances sont à sec ! Donc il faudra attendre un peu avant que je t'envoie ça au Canada.

Ensuite, je n'ai pas terminé l'article, le code, ... car je n'ai pas eut le temps ce soir, je terminerai demain soir ou lundi.

Re,

Concernant les achats de potars motorisés, j'ai trouvé ceci :

Disponibilités Des Faders Motorisés
PANASONIC #EVANMKP08B14 chez All Electronics Corp./USA pour environ 7$ US 
ALPS Fader #RSAON11M9 chez albs ALLTRONIC/Germany pour environ 20 EUR 
ALPS Fader #RSAON11M9 chez Deltron Roxburgh/UK pour environ 10£ 
ALPS Fader RSAON11M9, numéro de commande #442081-07 chez Conrad pour environ 23 EUR

sur la page : www.uCApps.de

Le câblage

Là, y a un poil de boulot !

Le schéma de câblage est celui-ci :

Le principe est le suivant :

  • une entrée analogique est chargée de mesurer la position absolue du curseur du potentiomètre ;
  • deux broches numériques sont configurées en sorties pour piloter le moteur, à savoir les commandes moteur dans un sens, moteur dans l'autre sens et stop rapide ;
  • une sortie PWM est utilisée de manière à pouvoir faire varier la puissance envoyée au moteur pour le faire tourner plus ou moins vite ;
  • la carte arduino ne pouvant pas commander directement le petit moteur, un étage de puissance configuré en "pont en H" est assuré par le L293B ;
  • Le L293B n'a pas de diodes de protection intégrée, d'où la présence des quatres diodes cablées "volantes".

(1) Remarque : sur le schéma, des pointillés rouges et de petits (1) vous indiquent comment câbler l'alimentation du moteur directement sur la carte... mais ATTENTION ! Prenez garde, il faut ABSOLUMENT changer la position du cavalier d'alimentation sur la carte Arduino pour qu'il soit en position alimentation externe et branchez un petit bloc d'alimentation secteur sur la prise d'alimentation de la carte. N'ALIMENTEZ PAS LE MOTEUR A PARTIR DU 5V de la carte !. Pour ma part, j'ai choisi d'alimenter le moteur avec une pile 9V.

Le programme

C'est un programme de test, il n'est pas optimisé, ... c'est donc à adapter.

Le principe est simple : on envoie avec un terminal série un nombre entre 0 et 1023 inclus et le curseur du potetiometre se déplace jusqu'a cette valeur puis renvoie sur l'écran du terminal la valeur atteinte.

Si vous avez des soucis lors de la mise en route c'est peut être qu'il vous faut inverser les deux fils d'alimentation du moteur.

/***************************************/
// MotPot Arduino
// Benoît ROUSSEAU 27 juillet 2006
// - Pilotage d'un potentiomètre
// motorisé (étude de faisabilité)
/***************************************/

#define PILOT_A 7     // entrée A du pont en H
#define PILOT_B 8     // entrée B du pont en H
#define PILOT_PWM 9   // entrée "Enable" du pont en H
#define PILOT_REF 0   // entrée analogique reliée au commun de la piste du potentiomètre

#define ECRART_V_DIV2 150 // rapport PWM min pour déplacement moteur potentiomètre

int cmdValeur;
int cmdChar;

/***************************************/

void direction (byte dir)
{
  if (dir == 0)
  {
    digitalWrite (PILOT_A, HIGH);
    digitalWrite (PILOT_B, LOW);
  }
  else
  {
    digitalWrite (PILOT_A, LOW);
    digitalWrite (PILOT_B, HIGH);
  }
}

void allerA (int consigne)
{
  int positionlue = analogRead (PILOT_REF);
  int vitesse = 0;
  
  analogWrite (PILOT_PWM, 0);
  
  if (consigne == positionlue) return;
  if (consigne > 1023) return;
  if (consigne < 0) return;

  if (consigne > positionlue)
  {
    direction(1);
    if (positionlue < (consigne-ECRART_V_DIV2))
      analogWrite (PILOT_PWM, 255);
      
    while (positionlue < (consigne-ECRART_V_DIV2))
      positionlue = analogRead (PILOT_REF);
      
    analogWrite (PILOT_PWM, 140);
    while (positionlue < consigne)
      positionlue = analogRead (PILOT_REF); 
      
    digitalWrite (PILOT_B, LOW);
  }
  else
  {
    direction(0);
    if (positionlue > (consigne+ECRART_V_DIV2))
      analogWrite (PILOT_PWM, 255);
      
    while (positionlue > (consigne+ECRART_V_DIV2))
      positionlue = analogRead (PILOT_REF);
    
    analogWrite (PILOT_PWM, 140);
    while (positionlue > consigne)
      positionlue = analogRead (PILOT_REF);
    
    digitalWrite (PILOT_A, LOW);
  }
  
  analogWrite (PILOT_PWM, 0);
  
};

/***************************************/
void setup()
{
  pinMode(PILOT_A, OUTPUT);
  pinMode(PILOT_B, OUTPUT);
  pinMode(PILOT_PWM, OUTPUT);
  Serial.begin(9600);
};

void loop ()
{
    while (serialAvailable())
    {
      cmdChar = serialRead ();
      printByte (cmdChar);
      switch (cmdChar)
      {
        case 13 : // retour chariot commande
            allerA (cmdValeur);
            cmdValeur = 0;
        case '?' :
            Serial.print (analogRead(PILOT_REF));
          break;
        case '0' : 
        case '1' : 
        case '2' : 
        case '3' : 
        case '4' : 
        case '5' : 
        case '6' : 
        case '7' : 
        case '8' : 
        case '9' : cmdValeur = cmdValeur * 10 + (cmdChar-48); break;

      }
    }
};

Si vous avez des questions ou si vous réalisez quelque chose à partir de cela, dites le moi :smiley: !

Le prochain post, encore plus fort, un peu de patience...

Bonjour j'aimerai savoir comment vous faite pour recuperer la valeur du potentiometre.
Imaginions que quelqu'un positionne le potentiometre manuellement comment faire pour la recuperer.
Merci de votre aide

Bonjour Frédéric,

La fonction qui récupère la valeur numérique de la position du curseur du potentiomètre est "analogRead". Que la position du potetiometre change de manière "automatisée" ou en manuel, c'est la même fonction qui renvoie la valeur numérique de la position.

Pour plus d'information sur la fonction AnalogRead, consulte le manuel de référence Arduino ou ma traduction à l'adresse Pages perso Orange - Domaine obsolète

Bonjour,
J'aimerai savoir si vous connaissez le language JAL pour pouvoir m'aiguiller sur les commande a utiliser car j'ai trouve un montage qui permet de controler des potentiometres numerique et j'aimerai y adapter des potentiometre motorise...

Merci de votre reponse

Bonjour,

J'ai entendu parlé de JAL, mais je ne connais absolument rien sur ce language !
Par ailleurs, quel rapport avec JAL ?

Oui pardon j'ai oublier de vous dire le programme est sur une 16F877 de chez microchips j'avais oublié se detaille :o :-? :o :-X :-/

Bonjour,

Ce n'est absolument pas le bon endroit pour des questions sur la famille Microchip ou le langage JAl ! Je comprends mieux tes questions suite à mes réponses...

Trouve un forum sur lrs microcontrolleurs PIc et le langage JAL se sera plus simple et efficace. Je dev. bien sur PIC aussi mais en assembleur.

hello

I will have to reply in english because my french is really bad :frowning:

I've used jal quite a lot... the grandfather of arduino was a board called programma2003 which was running jal.
yes it is very lightweight and uses very little code but it's also very low level and making complex stuff requires a lot of work.. it doesn't have strings, it works only with 8 bit values. I felt it was very difficult for my students to get going if they didn't know how to program already.
that's why we moved to AVR processors and eventually made arduino

massimo

bonjour !
hum... le sujet date un peu, donc je ne trouve pas d a autres refrences.

Que faut il pour faire fonctionner ce potentiomètre motorisé là avec Arduino?
http://www.conrad.fr/potentiometre_a_piste_plate_motorise_p_48674_49110_841476_361282_FAS#

à moins que vous n ayez d autres produits en potentiomètres linéaires qui soient plus interessants :wink:
:slight_smile:

J'en ai utilisé trois comme ça. C'est très simple.

Le moteur est un simple courant continu, il se pilote avec un driver de type L293 documenté ici : Contrôleur "pont en H" pour moteurs électriques - PoBot

Ensuite il y a deux connecteurs pour le potentiomètre : la masse et une résistance variable correspondant à la position du curseur.

Tiens, j'ai retrouvé ce que j'avais fait avec : Filtrer un signal analogique - PoBot

Le dernier connecteur correspond au curseur : utilisé avec une résistance de pull-up, il permet de détecter si le doigt est posé sur le curseur, ce qui permet de débrayer le moteur pour laisser le potentiomètre libre, ou s'en servir comme bouton pour remettre une valeur motorisée.

Je n'en ai plus sous la main, si tu as d'autres questions, n'hésites pas. En tout cas c'est un très bon modèle.

olalalala.... ca assure chez la communauté arduino !

c est pour un usage hyper spécifique ( lumières en théatre) :
http://www.le-chat-noir-numerique.fr
(d'ailleurs je suis passé finalement par un buffer de bytes pour recevoir les infos)
normalement je passe par le midi. mais arduino... c'est énorme ! faut juste apprendre.... les possibilités sont vraiment énormes.

questions:
-donc normalement je peux lui envoyer une valeur précise, de 0 à 255, c est cà ?
-résistance en pull up > intégrée au moteur c'est çà ? ou bien c est un élément à part ?

  • y a t il un rerour d info pour arreter le pilotage ? ou bien le pilotage est abandonné dès que les mains sont sur le potard ?

-est ce qu il y un schéma que je puisse suivre ? (plus facile pour moi ) donc je n ai besoin que d un potard, d un L293 et d une résitance de pull up (?)

merci :slight_smile:

En fait, tu peux lui envoyer de 0 à 1023 puisque le potentiomètre se branche sur une entrée analogique de l'Arduino qui fait 10 bits.

Par contre tout dépend de ton asservissement du moteur pour qu'il atteigne la position. Si tu as une précision supérieure à 5 pas quand tu t'arrêtes, inutile de "gaspiller" des octets ou de perdre du temps.

Tu trouveras des exemples simples comme l'asservissement en vitesse : il faut que la vitesse (pwm sur le L293 qui pilote le moteur) soit proportionnel à l'écart entre la position souhaitée et la position courante. Plus tu t'approches du but, plus tu ralentis.

En théorie ça marche très bien, comme dans la seconde applet de cet article : Asservissement PID - PoBot malheureusement il y a la dure réalité, qui fait que le moteur peut avoir de l'inertie et le curseur va dépasser la position souhaitée, et tu auras des oscillations (pour piloter de la lumière, c'est plutôt moche).

Bienvenue dans le monde joyeux de la robotique :slight_smile:

Je vais refaire le schéma (sous Fritzing) dans un article dédié à ce potentiomètre. Ce sera pas avant ce week-end, me relancer. J'intégrerai le L293, le potentiomètre, etc...

"retour d'info pour arrêter le pilotage" : tout est à coder soit-même dans l'Arduino, il faut définir un seuil (ajouter un bouton pour l'init par exemple), détecter ce seuil, couper le driver de puissance (L293) quand le seuil est atteint, définir une règle de gestion quand le seuil repasse en-dessous, éventuellement mettre un hysteresis (seuil haut de dépassement, seuil bas de retour au contrôle), etc...

De quoi s'amuser. Surtout quand on a pas le potar sous la main..

merci luj06 c est super clair. nb: tu es sur sophia ?