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

lundi 11 novembre 2013, par Jean-Luc

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.

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.

/* le bouton est connecté à la broche A0 */
const int pinBouton = 0;
/* valeur logique pour indiquer que le bouton est pressé */
const boolean PRESSE = true; 
/* valeur logique pour indiquer que le bouton est relâché */
const boolean RELACHE = false;
 
/*
 * lecture du bouton poussoir. Le bouton poussoir est connecté
 * sur une entrée analogique. Quand il est pressé, l'entrée est 
 * connectée au +5V. Quand il est relaché, l'entrée est connectée
 * à la masse. On va discriminer les deux états en comparant la
 * valeur analogique lue à 511 qui est la valeur milieu.
 */
boolean lirePoussoir()
{
    boolean resultat = RELACHE;
    if (analogRead(pinBouton) > 511) {
        resultat = PRESSE;
    }
    /* retourne l'état */
    return resultat;
}

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.

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

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.

/*
 * construction d'un événement.
 * - Si l'état du bouton n'a pas changé entre l'état précédent du bouton
 *   et le nouvelle état, l'événement est AUCUN_EVENEMENT.
 * - Si le pouton était précédemment RELACHE et qu'il est maintenant PRESSE,
 *   l'événement est EVENEMENT_PRESSE.
 * - Si le pouton était précédemment PRESSE et qu'il est maintenant RELACHE,
 *   l'événement est EVENEMENT_RELACHE.
 */
byte lireEvenement()
{
    byte evenement;
 
    /* lit l'état courant du bouton */
    boolean nouvelEtat = lirePoussoir();
    /* calcule l'événement */
    if (nouvelEtat == etatBouton)
        evenement = AUCUN_EVENEMENT;
    if (nouvelEtat == PRESSE && etatBouton == RELACHE)
        evenement = EVENEMENT_PRESSE;
    if (nouvelEtat == RELACHE && etatBouton == PRESSE)
        evenement = EVENEMENT_RELACHE;
    /* L'état courant devient l'état précédent */
    etatBouton = nouvelEtat;
    /* retourne l'événement */
    return evenement;
}

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.

const int pinBouton = 0; /* le bouton est connecté à la broche A0 */
 
const boolean PRESSE = true;
const boolean RELACHE = false;
 
boolean etatBouton = RELACHE;
 
const byte AUCUN_EVENEMENT = 0;
const byte EVENEMENT_PRESSE = 1;
const byte EVENEMENT_RELACHE = 2;
 
boolean lirePoussoir()
{
  boolean resultat = RELACHE;
  if (analogRead(pinBouton) > 512) {
    resultat = PRESSE;
  }
  return resultat;
}
 
byte lireEvenement()
{
    byte evenement;
    boolean nouvelEtat = lirePoussoir();
    if (nouvelEtat == etatBouton)
        evenement = AUCUN_EVENEMENT;
    if (nouvelEtat == PRESSE && etatBouton == RELACHE)
        evenement = EVENEMENT_PRESSE;
    if (nouvelEtat == RELACHE && etatBouton == PRESSE)
        evenement = EVENEMENT_RELACHE;
    etatBouton = nouvelEtat;
    return evenement;
}
 
void setup()
{
    Serial.begin(9600);
}
 
void loop()
{
    byte evenement = lireEvenement();
  
    if (evenement == EVENEMENT_PRESSE) Serial.println("presse !");
    if (evenement == EVENEMENT_RELACHE) Serial.println("relache !");
}

À 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.

const byte SERVO_A_ANGLE_MIN = 0;
const byte SERVO_A_ANGLE_MAX = 1;
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX = 2;
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN = 3;
 
const int angleMin = 1250;
const int angleMax = 1750;
 
Servo monServo;
int vitesse = 0;
int angle = angleMin;
byte etatServo = SERVO_A_ANGLE_MIN;

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.

#include <Servo.h>
 
const byte SERVO_A_ANGLE_MIN = 0;
const byte SERVO_A_ANGLE_MAX = 1;
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX = 2;
const byte SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN = 3;
 
const int angleMin = 1250;
const int angleMax = 1750;
 
Servo monServo;
int vitesse = 0;
int angle = angleMin;
byte etatServo = SERVO_A_ANGLE_MIN;
 
const int pinBouton = 0; /* le bouton est connecté à la broche A0 */
 
const boolean PRESSE = true;
const boolean RELACHE = false;
 
boolean etatBouton = RELACHE;
 
const byte AUCUN_EVENEMENT = 0;
const byte EVENEMENT_PRESSE = 1;
const byte EVENEMENT_RELACHE = 2;
 
/*
 * fonctions de gestion du poussoir
 */
boolean lirePoussoir()
{
    boolean resultat = RELACHE;
    if (analogRead(pinBouton) > 512) {
        resultat = PRESSE;
    }
    return resultat;
}
 
byte lireEvenement()
{
    byte evenement;
    boolean nouvelEtat = lirePoussoir();
    if (nouvelEtat == etatBouton)
        evenement = AUCUN_EVENEMENT;
    if (nouvelEtat == PRESSE && etatBouton == RELACHE)
        evenement = EVENEMENT_PRESSE;
    if (nouvelEtat == RELACHE && etatBouton == PRESSE)
        evenement = EVENEMENT_RELACHE;
    etatBouton = nouvelEtat;
    return evenement;
}
 
/*
 * La fonction setup() est exécutée 1 fois
 * au démarrage du programme
 */
void setup()
{
  monServo.attach(2);
}
 
/*
 * La fonction loop() est exécutée
 * répétitivement
 */
void loop()
{
    /* actualisation de l'angle du servo */
    monServo.writeMicroseconds(angle);
  
    angle = angle + vitesse;
  
    if (angle > angleMax) {
        angle = angleMax;
        vitesse = 0;
        etatServo = SERVO_A_ANGLE_MAX;
    }
    else if (angle < angleMin) {
        angle = angleMin;
        vitesse = 0;
        etatServo = SERVO_A_ANGLE_MIN;
    }
 
    /* lecture de la commande de l'utilisateur */
    byte evenement = lireEvenement();
  
    if (evenement == EVENEMENT_PRESSE) {
        switch (etatServo) {
            case SERVO_A_ANGLE_MIN:
            case SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN:
                vitesse =  1;
                etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX;
                break;
            case SERVO_A_ANGLE_MAX:
            case SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX:
                vitesse = -1;
                etatServo = SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN;
                break;
        } 
    }
 
    delay(3);
}

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

Messages

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

    • Oui, l’entrée de commande à une très forte impédance et un ampli n’est pas nécessaire. Concernant l’alimentation, il est par contre préférable de la séparer.

  • 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.

    • Bonjour,

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

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

      À 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.

  • 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.

    • 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

  • 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.

  • 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 ?

    • Bonjour,

      Il faut que le programme lise l’entrée analogique puis avec une succession de if ...  else ... imbriqués qui vont séparer les trois cas, commande la position du servo.

      Cordialement

  • 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

    • 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.

    • 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

    • Bonjour,

      Dans la dernier version du logiciel, la position est sauvegardée en EEPROM et retrouvée au démarrage suivant.

  • 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

  • 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

    • bonsoir,
      ton moteur couine car il dépasse son maxi et son mini, donc il ne faut pas le mettre au maxi ,réduire l angle a cent soixante dix huit pou maxi par exemple et un degré pour le mini.

  • 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 ?

  • 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

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

  • 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.

  • bonjour

    petite question et-il possible d’ajouter une led a cette installation pour que quand le servo est en position lever la led allume est quand il est en position bas la led sois éteinte.
    et si c’est possible comment ?

    merci de votre réponse

  • Bonjour et vraiment merci pour ces explications ...certes je suis debutant avec l’arduino que je trouve excellent pour mes projets...par contre apres avoir "epluché " le net je ne comprends pas exactement comment placer 2 fin de courses( 1 droit, 1 gauche ) pour que le servo ( 360° ) s’arrete selon le besoin et reparte ds la direction inverse...commendé par un inter 3 positions par un recepteur via un radio-commande ( transmetteur )...chaque fin de course possede 3 broches et j’ai lu qu’il valait mieux connecter le NC sur le Ground...je pense que le commun doit aller sur 1 broche ( à lire ) ds le programme et donc definir l’etat, mais le NC doit il être sur le 5V...?
    la logique est parfois + simple que ce que l’on pense mais je sche un peu....
    Bonne journée

  • Bonjour,
    Bravo pour votre blog et ce post très instructifs !
    Je suis débutant dans la programmation arduino et j’ai comme objectif de piloter un bras articulé à l’aide de trois servo. Ce bras servira à enlever ou mettre un capot de télescope. La commande se fait par l’intermédiaire d’un interrupteur deux positions connecté sur une entrée digital.
    J’ai réussi, malgré mon ignorance en programmation, à réaliser un petit programme, à l’aide de mblock et quelques lignes de commande récupérées sur le net, qui me permet, en fonction de la position de l’interrupteur, de positionner chaque servo à des angles spécifiques.
    Mon problème est d’essayer de ralentir le mouvement des servo. J’ai donc testé votre programme qui fonctionne très bien pour moi mais je n’arrive pas à isoler la partie ralentissement afin de l’intégrer dans mon programme.
    L’idée est de dire au servo d’aller à une consigne particulière avec une vitesse ralentie.
    Merci d’avance pour votre aide.
    Fabrice

    Voir en ligne : Commande du servo-moteur par bouton poussoir

  • Bonjour, tout d’abord merci pour ce programme très détaillé.
    J’ai cependant un problème, j’aimerai que lorsque j’appuie sur le bouton, le servo-moteur aille dans un sens puis qu’il revienne à sa position initiale en appuyant donc une seule fois sur le bouton. Merci d’avance.

    • Bonjour,
      C’est vrai que ça serait une variante intéressante. N’hésitez pas à publier le programme modifié quand vous aurez une version opérationnelle !

  • bonsoir je début en arduino donc mes connaissance sont assez faible.
    Je me suis inspirer de votre tuto pour un projet personnel que j’ai, mais j’ai un petit soucis j’aimerai piloter 3 servo mais en temps différent.
    Je m’explique, je voudrai que le servo 1 et 2 fonctionnes en même temps et une fois quil ont fait leur cycle, le servo 3 se met en marche puis inversement le 3 en premier et les 1 et 2 en second.
    j’ai a peut prêt compris votre programmation mais je n’arrive pas a rentrer les codes pour faire ce que je veux est ce que vous pourriez me donnez un petit coup de pouce^^

    en vous remerciant

  • Bonjour et merci pour cet article.
    j’ai refais sans problème votre montage,seulement je souhaite programmer 2 servos avec 2 poussoirs avec un programme identique et je n’arrive pas à faire fonctionner le deuxiéme servo. Avez vous une solution ?
    Cordialement

  • Bonjour, J’ai installé un passage à niveau, sur mon circuit de train et l’ai automatisé grace à l’utilisation de 2 servo-moteurs (1 pour chaque barrière) en téléversant le programme complet (récupéré sur l’article : commande du servo-moteur par bouton poussoir) et en utilisant une carte arduino uno. Tout fonctionne parfaitement bien.
    Ma question est la suivante : A la mise sous tension de la carte, alors que les servo-moteurs se calent à une extrémité de leur course, est’il possible que ceux-ci se calent à l’autre extrémité. merci pour votre aide et bonne journée
    Jacques.

  • Bonjour. Si vous faites référence au sketch Huit_boutons_huit_servos_detach_reglage_eeprom_temoins_cpp.ino alors, le fait que les servos se mettent en position minimum est fixé aux lignes 236 et 239 est c’est valable pour tous les servos.

Un message, un commentaire ?

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)