ModelleisenbahN

Accueil > La technologie > Arduino > Manœuvre des aiguilles avec des servo-moteurs > Commande du servo-moteur par bouton poussoir

Manœuvre des aiguilles en analogique avec des servo-moteurs

Commande du servo-moteur par bouton poussoir

publié par Jean-Luc, le lundi 11 novembre 2013

Tags aiguille - arduino - servo

Nous allons maintenant ajouter un bouton poussoir pour commander le mouvement du servo-moteur. Cet article fait suite à « Mise en œuvre d’un servo-moteur ».

Le système fonctionnera de la manière suivante : Lorsque le servo-moteur est dans une des positions extrêmes, une pression sur le poussoir donnera au servo-moteur une vitesse lui permettant de gagner l’autre position extrême. Lorsque le servo-moteur est en mouvement, une pression sur le bouton inversera la vitesse.

Mise en œuvre du bouton poussoir

Comme déjà expliqué, nous allons réserver les entrées/sorties numériques, les broches 0 à 13 de l’Arduino, au pilotage des servo-moteurs et à l’allumage des LED témoin.

Pour l’instant, l’unique bouton poussoir est connecté sur une entrée analogique, A0 par exemple. Une entrée analogique permet à l’Arduino de lire une grandeur analogique, entre 0V et 5V, et de la convertir en un nombre que l’on pourra manipuler dans le programme. Le nombre obtenu peut prendre des valeurs comprises entre 0 (pour 0V) et 1023 (pour 5V) avec donc 1024 valeurs possibles.

Pour notre bouton, il n’y aura que deux valeurs, celle qui correspond au bouton relâché et celle qui correspond au bouton enfoncé. Le bouton est connecté à l’Arduino comme ceci.

PNG - 44.2 ko
Connexion du bouton poussoir à l’Arduino Uno

Lorsque le bouton est relâché, l’entrée analogique A0 est tirée à 0V via la résistance de 10kΩ. Lorsque le bouton est pressé, l’entrée est mise à 5V.

Du côté du programme, nous allons séparer l’espace de valeurs (0 à 1023) en deux parties égales : les valeurs inférieures ou égales à 511 et celles supérieures à 511 et nous allons définir une fonction qui lit la valeur analogique, la compare à la valeur milieu et retourne soit RELACHE, soit PRESSE. Ces deux constantes sont des booléens, c’est à dire des valeurs logiques. Elle sont définies pour faciliter la lecture du programme. Jusqu’alors nous n’avons vu que des fonctions qui ne retournaient rien, c’est à dire void. Ici la fonction lireBouton retourne un booléen, qui sera l’état du bouton. Nous avons donc le morceau de programme suivant avec la définition des constantes nécessaires et la fonction de lecture de l’état du bouton poussoir.

  1. /* le bouton est connecté à la broche A0 */
  2. const int pinBouton = 0;
  3. /* valeur logique pour indiquer que le bouton est pressé */
  4. const boolean PRESSE = true;
  5. /* valeur logique pour indiquer que le bouton est relâché */
  6. const boolean RELACHE = false;
  7.  
  8. /*
  9.  * lecture du bouton poussoir. Le bouton poussoir est connecté
  10.  * sur une entrée analogique. Quand il est pressé, l'entrée est
  11.  * connectée au +5V. Quand il est relaché, l'entrée est connectée
  12.  * à la masse. On va discriminer les deux états en comparant la
  13.  * valeur analogique lue à 511 qui est la valeur milieu.
  14.  */
  15. boolean lirePoussoir()
  16. {
  17. boolean resultat = RELACHE;
  18. if (analogRead(pinBouton) > 511) {
  19. resultat = PRESSE;
  20. }
  21. /* retourne l'état */
  22. return resultat;
  23. }

Télécharger

Mais l’état du bouton ne nous intéresse pas directement. En effet, ne mettre le servo-moteur en mouvement que lorsque le bouton est pressé forcerait l’utilisateur à maintenir le bouton pressé pendant le mouvement. Ce sont donc les changements d’état du bouton qui nous intéressent : le fait de passer de l’état RELACHE à l’état PRESSE ou le fait de passer de l’état PRESSE à l’état RELACHE. Pour détecter ces changements d’état, il faut mémoriser l’état précédent du bouton et, quand on lit son état actuel, le comparé à l’état précédent pour déterminer si l’un des changements a eu lieu. On a donc besoin d’une variable pour y mémoriser l’état précédent. Pour clarifier les choses et rendre le programme lisible, nous allons aussi définir 3 constantes : AUCUN_EVENEMENT, l’état précédent du bouton est identique à l’état courant, EVENEMENT_PRESSE, l’état précédent du bouton était RELACHE, l’état courant est PRESSE et EVENEMENT_RELACHE, l’état précédent du bouton était PRESSE, l’état courant est RELACHE. Ces constantes sont des byte, c’est à dire un type de donnée pouvant prendre 256 valeurs différentes, ce qui suffit amplement.

  1. const byte AUCUN_EVENEMENT = 0;
  2. const byte EVENEMENT_PRESSE = 1;
  3. const byte EVENEMENT_RELACHE = 2;

Télécharger

Enfin nous allons définir la fonction lireEvenement() qui va lire l’état courant du bouton et calculer l’événement. Le code vient assez naturellement.

  1. /*
  2.  * construction d'un événement.
  3.  * - Si l'état du bouton n'a pas changé entre l'état précédent du bouton
  4.  * et le nouvelle état, l'événement est AUCUN_EVENEMENT.
  5.  * - Si le pouton était précédemment RELACHE et qu'il est maintenant PRESSE,
  6.  * l'événement est EVENEMENT_PRESSE.
  7.  * - Si le pouton était précédemment PRESSE et qu'il est maintenant RELACHE,
  8.  * l'événement est EVENEMENT_RELACHE.
  9.  */
  10. byte lireEvenement()
  11. {
  12. byte evenement;
  13.  
  14. /* lit l'état courant du bouton */
  15. boolean nouvelEtat = lirePoussoir();
  16. /* calcule l'événement */
  17. if (nouvelEtat == etatBouton)
  18. evenement = AUCUN_EVENEMENT;
  19. if (nouvelEtat == PRESSE && etatBouton == RELACHE)
  20. evenement = EVENEMENT_PRESSE;
  21. if (nouvelEtat == RELACHE && etatBouton == PRESSE)
  22. evenement = EVENEMENT_RELACHE;
  23. /* L'état courant devient l'état précédent */
  24. etatBouton = nouvelEtat;
  25. /* retourne l'événement */
  26. return evenement;
  27. }

Télécharger

Afin de tester la lecture du poussoir indépendamment, nous allons mettre en œuvre l’envoi de message sur la ligne série qui, via l’USB, s’affiche dans le Moniteur Série de l’environnement de programmation Arduino. Il faut tout d’abord ouvrir la connexion dans la fonction setup() en utilisant la méthode begin(...) de Serial. Nous allons ensuite utiliser la méthode println pour afficher un message sur le moniteur série. Voici le programme complet pour cette première application mettant en œuvre un bouton.

  1. const int pinBouton = 0; /* le bouton est connecté à la broche A0 */
  2.  
  3. const boolean PRESSE = true;
  4. const boolean RELACHE = false;
  5.  
  6. boolean etatBouton = RELACHE;
  7.  
  8. const byte AUCUN_EVENEMENT = 0;
  9. const byte EVENEMENT_PRESSE = 1;
  10. const byte EVENEMENT_RELACHE = 2;
  11.  
  12. boolean lirePoussoir()
  13. {
  14. boolean resultat = RELACHE;
  15. if (analogRead(pinBouton) > 512) {
  16. resultat = PRESSE;
  17. }
  18. return resultat;
  19. }
  20.  
  21. byte lireEvenement()
  22. {
  23. byte evenement;
  24. boolean nouvelEtat = lirePoussoir();
  25. if (nouvelEtat == etatBouton)
  26. evenement = AUCUN_EVENEMENT;
  27. if (nouvelEtat == PRESSE && etatBouton == RELACHE)
  28. evenement = EVENEMENT_PRESSE;
  29. if (nouvelEtat == RELACHE && etatBouton == PRESSE)
  30. evenement = EVENEMENT_RELACHE;
  31. etatBouton = nouvelEtat;
  32. return evenement;
  33. }
  34.  
  35. void setup()
  36. {
  37. Serial.begin(9600);
  38. }
  39.  
  40. void loop()
  41. {
  42. byte evenement = lireEvenement();
  43.  
  44. if (evenement == EVENEMENT_PRESSE) Serial.println("presse !");
  45. if (evenement == EVENEMENT_RELACHE) Serial.println("relache !");
  46. }

Télécharger

À ma grande surprise ce programme fonctionne sans effort supplémentaire ! À ma grande surprise car lorsque l’on presse ou que l’on relâche un bouton, le contact ou la coupure ne s’effectue pas d’un coup et une succession rapide de contact-coupure a lieu. On appelle cela un rebond. Mon poussoir n’a pas de caractéristique particulière et j’ai par ailleurs eu des rebonds en le connectant à une entrée numérique. La réponse à ce mystère est donc ailleurs.

Deux techniques sont possibles pour filtrer les rebonds des poussoirs :

  • par matériel : un condensateur de filtrage ;
  • par logiciel : laisser passer du temps entre deux lectures.

Or, la conversion analogique numérique n’est pas instantanée. Entre deux conversions successives et donc deux acquisitions successive de la valeur analogique, il s’écoule 100µs. Ce qui équivaut à la solution logicielle de « laisser passer du temps entre 2 lectures ». Cette durée semble être suffisante pour filtrer les rebonds de notre bouton.

Intégration avec le programme de pilotage du servo-moteur

Nous allons maintenant intégrer notre fonction de lecture d’événement au programme de pilotage du servo-moteur tel que nous l’avons présenté dans l’article précédent.

Il faut procéder à quelques modification. Tout d’abord, il faut supprimer l’aller-retour qu’effectue le servo-moteur. Ensuite, il faut ajouter une variable qui va permettre de savoir dans quel état se trouve le servo-moteur afin de prendre la décision adéquate quand le bouton est pressé. On va distinguer 4 états :

SERVO_A_ANGLE_MIN : le servo-moteur est arrêté dans la position correspondant à l’angle minimum. Sa vitesse est égale à 0.
SERVO_A_ANGLE_MAX : le servo-moteur est arrêté dans la position correspondant à l’angle maximum. Sa vitesse est égale à 0.
SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX : le servo est en mouvement vers la position d’angle maximum. Sa vitesse est égale à 1.
SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN : le servo est en mouvement vers la position d’angle minimum. Sa vitesse est égale à -1.

Comme tout est nombre, nous allons définir chacune de ces constantes comme étant un byte et définir une variable etatServo de type byte comme ceci.

  1. const byte SERVO_A_ANGLE_MIN = 0;
  2. const byte SERVO_A_ANGLE_MAX = 1;
  3. const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX = 2;
  4. const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN = 3;
  5.  
  6. const int angleMin = 1250;
  7. const int angleMax = 1750;
  8.  
  9. Servo monServo;
  10. int vitesse = 0;
  11. int angle = angleMin;
  12. byte etatServo = SERVO_A_ANGLE_MIN;

Télécharger

Dans setup(), nous retrouvons l’accrochage de monServo à la broche 2. La gestion du mouvement du servo est modifiée. Quand l’angle dépasse l’angle maximum, il est recalé comme auparavant. Mais dorénavant la vitesse est mise à 0 et l’état du servo est changé en SERVO_A_ANGLE_MAX. Quand l’angle dépasse l’angle minimum, il est recalé à l’angle minimum, la vitesse est mise à 0 et l’état du servo est changé en SERVO_A_ANGLE_MIN. De cette manière, le servo arrête son mouvement quand il atteint l’une des positions extrêmes.

On va ensuite lire l’événement. Si l’événement est EVENEMENT_PRESSE, on va effectuer les actions suivantes :

  • Si le servo est dans l’état SERVO_A_ANGLE_MIN ou
    SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN, la vitesse est mise à 1 et l’état du servo est changé en SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX.
  • Si le servo est dans l’état SERVO_A_ANGLE_MAX ou
    SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX, la vitesse est mise à -1 et et l’état du servo est changé en SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN

Le programme complet est le suivant.

  1. #include <Servo.h>
  2.  
  3. const byte SERVO_A_ANGLE_MIN = 0;
  4. const byte SERVO_A_ANGLE_MAX = 1;
  5. const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX = 2;
  6. const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN = 3;
  7.  
  8. const int angleMin = 1250;
  9. const int angleMax = 1750;
  10.  
  11. Servo monServo;
  12. int vitesse = 0;
  13. int angle = angleMin;
  14. byte etatServo = SERVO_A_ANGLE_MIN;
  15.  
  16. const int pinBouton = 0; /* le bouton est connecté à la broche A0 */
  17.  
  18. const boolean PRESSE = true;
  19. const boolean RELACHE = false;
  20.  
  21. boolean etatBouton = RELACHE;
  22.  
  23. const byte AUCUN_EVENEMENT = 0;
  24. const byte EVENEMENT_PRESSE = 1;
  25. const byte EVENEMENT_RELACHE = 2;
  26.  
  27. /*
  28.  * fonctions de gestion du poussoir
  29.  */
  30. boolean lirePoussoir()
  31. {
  32. boolean resultat = RELACHE;
  33. if (analogRead(pinBouton) > 512) {
  34. resultat = PRESSE;
  35. }
  36. return resultat;
  37. }
  38.  
  39. byte lireEvenement()
  40. {
  41. byte evenement;
  42. boolean nouvelEtat = lirePoussoir();
  43. if (nouvelEtat == etatBouton)
  44. evenement = AUCUN_EVENEMENT;
  45. if (nouvelEtat == PRESSE && etatBouton == RELACHE)
  46. evenement = EVENEMENT_PRESSE;
  47. if (nouvelEtat == RELACHE && etatBouton == PRESSE)
  48. evenement = EVENEMENT_RELACHE;
  49. etatBouton = nouvelEtat;
  50. return evenement;
  51. }
  52.  
  53. /*
  54.  * La fonction setup() est exécutée 1 fois
  55.  * au démarrage du programme
  56.  */
  57. void setup()
  58. {
  59. monServo.attach(2);
  60. }
  61.  
  62. /*
  63.  * La fonction loop() est exécutée
  64.  * répétitivement
  65.  */
  66. void loop()
  67. {
  68. /* actualisation de l'angle du servo */
  69. monServo.writeMicroseconds(angle);
  70.  
  71. angle = angle + vitesse;
  72.  
  73. if (angle > angleMax) {
  74. angle = angleMax;
  75. vitesse = 0;
  76. etatServo = SERVO_A_ANGLE_MAX;
  77. }
  78. else if (angle < angleMin) {
  79. angle = angleMin;
  80. vitesse = 0;
  81. etatServo = SERVO_A_ANGLE_MIN;
  82. }
  83.  
  84. /* lecture de la commande de l'utilisateur */
  85. byte evenement = lireEvenement();
  86.  
  87. if (evenement == EVENEMENT_PRESSE) {
  88. switch (etatServo) {
  89. case SERVO_A_ANGLE_MIN:
  90. case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN:
  91. vitesse = 1;
  92. etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX;
  93. break;
  94. case SERVO_A_ANGLE_MAX:
  95. case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX:
  96. vitesse = -1;
  97. etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN;
  98. break;
  99. }
  100. }
  101.  
  102. delay(3);
  103. }

Télécharger

Ce programme est l’occasion d’introduire une nouvelle construction du C, le switch ... case. Il s’agit d’un choix multiple. On a vu avec le if ... else ... un choix double. Ici la valeur de la variable etatServo indique à quel case le programme continue son exécution. L’exécution se poursuit jusqu’à rencontrer un break qui fait que le programme continue sont exécution après le switch.

Distinguer les états SERVO_A_ANGLE_MIN et SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN n’est pas nécessaire, idem pour SERVO_A_ANGLE_MAX et SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX. On le conserve tout de même car le programme est plus lisible ainsi et la distinction qui est faite va nous servir plus tard.

Une petite vidéo du montage volant et de l’exécution de ce dernier programme.

Démonstration du programme

24 Messages

  • Commande du servo-moteur par bouton poussoir 2 août 2014 22:04, par Denis

    Bonsoir,
    vous commandez directement le servo moteur par l’arduino sans passer par un amplificateur ?

    repondre message

  • Bonsoir,

    Tout d abord un grand merci pour toutes ces informations detaillees. Je debute en Arduino, et ne comprends pas pourquoi les fonctions "boolean lirePoussoir() " et "byte lireEvenement()" fonctionnent tout le temps, comme si elles etaient dans la boucle, alors qu elles sont en dehors de la boucle ...

    Aussi, je souhaiterais controler deux servos moteurs avec leur propre boutton correspondant, de sorte a ce que le premier boutton presse active le servo qui lui est assigne, mais desactive le boutton restant et son servos correspondant par la meme occasion. Auriez vous des pistes a me proposer ? Je ne sais pas comment desactiver un boutton et/servo ...

    Merci et bonne continuation.

    repondre message

    • Bonjour,

      La fonction lireEvenement() est appelée dans loop. Dans le dernier listing, à peu près au milieu de loop, vous avez un :

      1. /* lecture de la commande de l'utilisateur */
      2. byte evenement = lireEvenement();

      Télécharger

      À cet instant, l’Arduino va exécuter le code de la fonction lireEvenement() puis quand c’est terminé, revient continuer l’exécution de loop.

      De même lireEvenement() appelle la fonction lirePoussoir()

      Pour « désactiver » un bouton il suffit de l’ignorer quand il a été pressé. Pour lier cela au fait que le premier bouton a été pressé, il faut une variable booléenne pour que le programme se rappelle qu’il a été pressé. Quand le 1er bouton est pressé, la variable est mise à TRUE. Quand le second bouton est pressé, si la variable est FALSE, on effectue le mouvement du servo, si elle est TRUE, on ne fait rien.

      Détaillez mieux ce que vous voulez faire car avec votre cahier des charges, une fois que l’on a pressé le premier bouton, le second devient inactif pour le reste de l’exécution du programme.

      repondre message

  • Commande du servo-moteur par bouton poussoir 20 décembre 2014 22:28, par Adrien

    Bonsoir, d’abord bravo et merci pour ce partage de qualité.
    J’aimerais vous poser une question ;
    Dans mon cas j’essaye de faire en sorte que lorsque j’appui sur un bouton, les LEDs que j’ais branchées sur l’arduino ais une animation différente, j’ai donc créé des fonction et les appels lorsque j’appui sur le bouton, le problème étant que lorsqu’une fonction est lancé, plus moyen de changer de fonction, car la presse sur le bouton n’est plus détecter, pourriez vous m’indiquer la démarche a suivre afin que la presse du bouton soit détecter n’importe quand ?
    D’avance merci.

    repondre message

    • Commande du servo-moteur par bouton poussoir 23 décembre 2014 12:09, par Jean-Luc

      Bonjour,

      C’est normal, lorsque l’Arduino exécute une fonction, avec sans doute des appels à delay(...), il ne lit pas l’état de votre bouton. Il faut modifier le programme pour que entre 2 changement d’état des LEDs, le bouton soit lu.

      Contactez moi via le formulaire pour me donner votre adresse e-mail. Je vous contacterai afin que vous m’envoyiez votre programme. Je pourrai vous indiquer les modifications à effectuer.

      Cordialement

      repondre message

  • Commande du servo-moteur par bouton poussoir 6 janvier 2015 10:22, par Trofis

    Votre programme est super bien expliqué par contre j’aurais une question :
    Je ne comprend pas les angles que vous avez pris, car je crois de mémoire que c’est compris entre 0-1024 les valeurs des angles pour le servomoteur mais après si on veut on peut convertir avec la fonction "map" je crois, je ne suis pas sur de ce que je dis.

    repondre message

  • Commande du servo-moteur par bouton poussoir 18 février 2015 23:10, par Michael Collin

    Bonjour, et merci pour ces informations,

    Dans le cadre d’un projet je dois piloter un servo en fonction d’un événement type analogique (3 cas possibles). Je souhaiterais qu’en fonction de l’état mon servo se mette soit en position min, soit milieu (position par défaut) soit max.
    Auriez vous une idée ?

    repondre message

  • Commande du servo-moteur par bouton poussoir 22 février 2015 17:55, par Philippe DUCHENE

    Bonjour
    J’ai réalisé ds son intégralité le montage des 8 servos. Tout fonctionne correctement hormis le problème suivant :

    A la mise sous tension, les servos ne restent pas dans la position initiale mais se repositionnent TRES RAPIDEMENT, ce qui peut être très gênant pour l’utilisation du servo pour la porte d’un bâtiment, par exemple.
    Cela donne plutôt l’impression d’être un problème de programmation que parasite car le servo ne "frétille" pas mais réagi normalement à la pression sur le BP mais une fraction de seconde en vitesse rapide pour très bien fonctionner par la suite, il en est de même pour les autre servos.
    Dans l’attente de votre précieuse aide
    Cordialement
    Philippe

    repondre message

    • Commande du servo-moteur par bouton poussoir 23 février 2015 10:51, par Jean-Luc

      Bonjour,

      C’est normal. À l’allumage, les servos sont positionnés à l’angle minimum. Ça se passe dans le constructeur de DescripteurServo et dans la méthode connecte de la classe DescripteurServo.

      Donc si vous avez éteint le montage avec des servos à l’angle maximum, ces derniers vont se positionner d’un coup à l’angle minimum quand vous le rallumez.

      repondre message

    • Commande du servo-moteur par bouton poussoir 31 janvier 2016 11:47, par Serge

      Bonjour

      Je suis confronte au même problème et sans me pretendre un spécialiste j’ai trouvé une solution qui vaut ce qu’elle vaut mais qui marche

      Je remplace les boutons poussoirs de commande par des inverseurs stables
      J’alimente d’abord l’arduino, puis j’envoie le +5V sur les servos
      Le programme ayant commencé à tourner, les sorties sont initialisées avant que les servos ne soit alimentés
      In fine on peut commander l’alimentation 5V par l’arduino lui-même après une temporisation.
      Pour le moment je suis en phase de mise au point, peut-être que je découvrirai une meilleure solution
      L’inconvénient de mon montage est que si je veux automatiser la commande remplacer des inverseurs stabilisés est plus compliqué que d’envoyer juste une impulsion

      Bonne journee

      repondre message

  • Commande du servo-moteur par bouton poussoir 19 octobre 2015 11:54, par Pascal

    Bonjour,

    Je découvre votre site, je ne connais absolument rien en électronique et encore moins en programmation, mais je constate une chose importante, c’est que vos articles sont très bien rédigés.
    J’ai pour projet de monter un petit TCO avec Led et bouton poussoir, or sur les site de vente il y a des boutons on/on et on/off, voici donc ma question, dans ce type de commande de servo quel type de bouton poussoir ?

    Merci
    Pascal

    repondre message

  • Commande du servo-moteur par bouton poussoir 21 avril 2016 17:06, par MATHIEU

    Bonjour,
    J’ai acheté un arduino car votre programme correspond à un de mes projets. Je fabrique des machines à vapeur et des locos vapeur. Mon temps de loisir n’est pas extensible et je n’ai pas le temps de découvrir cet Arduino plus en profondeur.
    Votre programme semble bien fonctionner, mais en ce qui me concerne, en fin d’angle mini ou maxi le servo continu de couiner. Si je touche a peine l’axe cela s’arrête ou redémarre. Malgré tout la rotation du servo est arrêtée pendant le couinement. Je souhaite qu’en fin de course aller ou retour le servo s’arrête proprement. Impatient de vous lire, très cordialement,
    M.MATHIEU

    repondre message

  • Commande du servo-moteur par bouton poussoir 9 mai 2016 08:34, par Jean Vedie

    Bonjour
    Voulant se servir de votre programme pour la commande de signaux mécanique commandé par l’inverseur d’un moteur d’aiguille il faut que ce ne soit pas un contact momentané mais permanent ?

    repondre message

  • Commande du servo-moteur par bouton poussoir 20 juin 2016 11:41, par Jean VEDIE

    Merci de votre réponse, cela fonctionne parfaitement, mais une autre question
    Je voudrais avec le même principe commander par 1 seul bouton 2 servos mais avec l’un e sens anti horaire et l’autre en sens horaire ?
    Cela est il faisable ?
    si oui comment ;
    cordialement

    repondre message

  • Commande du servo-moteur par bouton poussoir 24 juillet 18:00, par Alexis

    le programme est le même avec plusieurs servo moteur, si non, je dois rajoute quoi ?

    repondre message

  • salut moi j aimerai commender le servo avec le bouton poussoir de façon à, ce que si j’apuie sur le bouton poussoir le servo se deplace de minin vers max seulement.
    l’autre sens je veux la commender avec un clavier matrix.
    merci de m’aider.

    repondre message

Répondre à cet article

Les thèmes

Archives

Informations

ModelleisenbahN | publié sous licence Creative Commons by-nc-nd 2.0 fr | généré dynamiquement par SPIP & Blog'n Glop