Tient , j'ai trouvé ça :



Si tu veut faire une télécommande , il va te falloir une deuxième Arduino et du coup deux modules Bluetooth.


Une solution plus simple pourrait être de faire courir une gaine avec un câble jusqu'au guidon ou l'endroit où tu veut que la commande se trouve. , Tu pourrais par exemple faire courir une gaine a coté de tes gaines de câble de frein.

Merci pour la recherche j'avais peur de cela justement d'avoir besoin d'un second Arduino + 2 modules..

Actuellement le montage est avec fil et ça fonctionne bien. J'avais envie de pouvoir avoir un montage plus simple et plus propre. Mais je pense que ce n'est pas trop grave au final..  

Merci 

Re, je regarde également pour passer en bluetooth afin de rendre le montage plus simple.

Dans mes recherches je trouve beaucoup de chose avec une commande via smartphone... mais rien avec un simple bouton poussoir.. 

Du coup je vois pas trop comme ça fonctionne faut-il un module HC-05 sur l'arduino nano et un second module avec le bouton poussoir et batterie ? 

Merci

Je connais des led bicolor, mais pas de boutons intégrant ce genre de led ... 
 

Je pense avoir trouvé, voici un lien https://fr.rs-online...ussoirs/9131740

Il faut voir la consommation mais ça peut être interessant de tester .. 

Bonjour, tout le monde, 

Je reviens vers vous car j'ai une petite question concernant mon projet qui est tjrs en phase de test. (très concluant mais il faut peaufiner encore)  

Est-il possible d'avoir un bouton poussoir avec une led qui aurait 2 couleurs (vert et rouge) sur la partie poussoir?

L'idée serait d'avoir suivant les positions du moteur soit le bouton en rouge ou en vert. Je pense que cela est possible mais je ne trouve pas de bouton poussoir comme cela .. auriez vous une idée ? 

Merci 

Si tu utilises toujours le programme de Mike, à chaque démarrage, le servo est initialisé en position 0.

Alors je viens de faire un test est effectivement il revient en position zéro qui est à fond à droite. Quand je le débranche en position zéro et que je le branche il ne bouge pas. il bouge uniquement quand il est débranché en position 1. Ok cela est normal et mon souci vient de l'amortisseur.

Merci   

bonjour, tout le monde, 

Petit souci.., imaginons que le moteur soit en position "à fond vers la droite" une fois dans cette position je débranche la batterie.

Le lendemain je rebranche la batterie et le moteur se met à tourner tout seul.. (sans impulsion sur le bouton)

Je ne sais pas vers quel coté il tourne me cela pourrait me faire décaler ma position de fonctionnement.. Cela est-il possible ?? 

Merci 

Pourquoi ne pas supprimer l'alimentation et le Shield ? Le Shield n'est là que pour faciliter les branchements.

La batterie serait connectée directement au servo et au Nano.

Du coup tout serait en 7,4V et le servo aurait un couple plus élevé. Mais supportera t-il les 8,5V ?

Quand la batterie est chargée, c'est 8,5V, et non 7,4V qui est une valeur moyenne.

Le shield n'est pas branché. il ma servit pour le montage et supprimé pour le montage finale. je l'avais commandé avec les pins montées mais le prochain ça sera sans pour simplifier le montage finale. 

Pour le couple je vais rester comme ça pour le moment car ça fonctionne bien. Il faudrait par-contre un servo étanche et éventuellement avec pignons métallique pour assurer le coup.

Merci 

Après, honnêtement, si ça marche comme ça, pas sur que ce soit vraiment utile de chercher à gagner en couple

Oui je suis assez d'accord je vais laisser comme ça  

Pour la batterie je voulais dire une seule batterie mais avec le montage interne des accus fixer en ligne. En gros une batterie avec une forme de cigare .. 

Il faudrait aussi je que trouve un cerveau avec les mêmes caractéristiques mais étanche. Il faudrait que je vois avec Mika118 .. 

Merci 

Alors voici le montage de l'ensemble. ça fonctionne très bien, il faut juste que j'optimise un peu l'ensemble comme trouver une batterie plus petite ou alors avoir les 2 accus sur la longueur.. Il faudrait également que je rende le câblage plus simple et pratique avec une fiches qui réunis l'ensemble des files .. Il faudrait que je monte Arduino sans les pins pour gagner de la place également.. 

Donc à suivre mais en tout cas ça fonctionne et je suis bien content. Merci a vous

Bonsoir,

tu veux faire quoi exactement?

 

Limiter le couple? Ou augmenter le couple?

 

Si tu veux limiter le couple, je penses que c'est possible (cf l'exemple ProgrammEEPROM fourni avec la librairie).

 

Si tu veux augmenter le couple, c'est peut-être possible en logiciel (mais j'y crois pas trop, le plus logique étant que par défaut le couple max soit autorisé). Sinon, c'est probablement possible en augmentant la tension d'alimentation du servo (sauf erreur de ma part, ils est actuellement alimenté en 5V : si tu passes à 6 ou 7V (voire 7.4V), tu gagnera probablement en couple. Attention à ne pas pousser trop loin au risque de cramer le servo (à priori, il est donné pour 7.4V max))

je pensais augmenter le couple car j'ai l'impression que le moteur lute un peu ça fonctionne quand même très bien. Mais oui éventuellement il faudrait que je test avec une batterie plus forte.. 

 

Bon si tu essayes ça :

#include <SCServo.h>

SCServo SERVO; 

#define PINBOUTON 8
#define POS0 0
#define POS1 1000
#define SPEED 1000
#define IDSERVO 1
#define WAITINGTIME 2000

bool positionNumber = 0;
uint16_t servoPositions[2] = {POS0, POS1};
                                    
void setup() {
  pinMode (PINBOUTON, INPUT_PULLUP);                               // Initialisation du pin de lecture du bouton
  Serial.begin(1000000);
  SERVO.pSerial = &Serial;
  delay(500);
  SERVO.EnableTorque(IDSERVO, true);
  SERVO.WritePos(IDSERVO, servoPositions[positionNumber], SPEED);  // Initialisation de la position du servo
}


void loop() {
  if(!digitalRead(PINBOUTON)) {
    positionNumber = !positionNumber;                 
    SERVO.WritePos(IDSERVO, servoPositions[positionNumber], SPEED);
    delay(WAITINGTIME); 
  }
}

 

ça donne quoi ?

 

Et bien ça fonctionne super bien   

J'ai gagné un mois de recherche vraiment top. Merci merci 

Du coup j'ai pu faire des tests et est-il possible de régler le couple du servo ? 

Le servo tourne?

 

Pour le bouton, c'est normal qu'il "n'est pas reconnu", tu ne lis jamais le bouton (la seule chose que tu fais, c'est définir une variable "bouton" (que je te conseillerais de renommer pinBouton pour plus de clarté) et lui donner la valeur 8.

Si tu veux que le bouton ait un effet, il faut programmer cet effet (et la lecture du bouton)

du coup voila :

j'ai modifié le programme :

SCServo SERVO; // crée une constante appelée « monservo » utilisable par la bibliothèque Servo.

int bouton = 8;
int etatbouton = 0;
                                    
void setup() 
{


Serial.begin(1000000);
  SERVO.pSerial = &Serial;
  delay(500);
  SERVO.EnableTorque(1, 1);
}


void loop() {
  SERVO.WritePos(1,0, 1000);// Servo ID:1, tourner vers la position 0 en 3s
  delay(2000);
  SERVO.WritePos(1,1000, 1000);// Servo ID:1, tourner vers la position 1000 en 3s
  delay(2000);
}

Bonjour,

comme l'a dit Mike, le message dit qu'il manque un point virgule à la fin de la ligne 13 (la dernière ligne avec du texte), celle avec "delay". Vérifie si tu n'as pas enlevée le point virgule par mégarde.

 

Et en effet, ce code n'utilise pas le bouton : c'est juste pour te montrer qu'il faut deux positions différentes pour faire tourner le moteur (et au passage, ça te permettra de vérifier si le moteur répond à l'ID 1, sinon il faudra trouver quel est son ID)

Oui ok j'ai compris du coup le " ; " est OK et il n'y a plus d'erreur . une fois téléversé il ne se passe rien.. 

Il s'agirait donc d'un souci de ID 

j'ai donc rajouté a void setup :

{

Pour la balise code, elle est sur la seconde ligne d'icones, et ressemble à "< >"

 

Pour la commande SERVO.WritePos, le format de la fonction est le suivant :

SERVO.WritePos(ID, Position, Durée)

Donc on communique avec le servo avec l'identifiant ID, auquel on dit de se rendre à la position Position en une durée Durée.

 

Donc quand tu écris le code suivant :

  SERVO.WritePos(1,0x0000, 3000);// Servo ID:1, rotate to the position:0x000
  SERVO.WritePos(2, 0x0000, 3000);// Servo ID:1, rotate to the position:0x000
  delay(3000);

ça revient à dire au servo avec l'ID 1 d'aller en position 0 en 3s (ie 3000ms) ; puis de dire au servo avec l'ID 2 d'aller à la position 0 en 3s (ie 3000ms), puis d'attendre 3s (ie 3000ms) (ce qui laisse le temps aux servos de bouger)

 

En l'occurance, vu que tu as un seul servo, ça ne sert à rien de s'adresser à la fois au servo avec l'ID 1 et à celui avec l'ID 2 vu que tu n'en a qu'un seul (il faut donc utiliser l'ID de ton servo).

 

En revanche, il faut que tu fasses bouger ton servo entre 2 positions si tu veux voir quelque chose.
 

Par exemple le code suivant devrait faire faire des allers-retours au servo avec l'ID 1 (3s pour chaque direction) :

#include <SCServo.h>                   // permet de faire appel à la bibliothèque Servo
 
SCServo SERVO;                       // crée une constante appelée « monservo » utilisable par la bibliothèque Servo.
                                      // (vous pouvez la nommez comme vous voulez, exemple : servo_1, mais pensez à le remplacer dans le programme).
void setup() {

}
 
void loop() {
  SERVO.WritePos(1,0, 3000);// Servo ID:1, tourner vers la position 0 en 3s
  delay(3000);
  SERVO.WritePos(1,1000, 3000);// Servo ID:1, tourner vers la position 1000 en 3s
  delay(3000);
}

Ok d'accord je pense comprend Merci de prendre le temps. 

Du coup je viens de tester et j'ai de nouveau un message d'erreur : 

Plusieurs points :
-Est-ce que tu comprends à quoi correspond chacune des lignes de ton code? Si non, alors dis nous lesquelles tu ne comprends pas, et on te les expliquera
- dans ton code, tu as deux lignes "SERVO.WritePos" qui se suivent, qui s'adressent à deux moteurs différents (ID=1 et ID=2), ce qui ne fait pas beaucoup de sens vu que tu as un seul servi
- fais attention à bien modifier les commentaires si tu modifié le code correspondant : j'ai vu plusieurs fois des commentaires qui sont faux (par exemple, dans le commentaire du second SERVO.WritePos, tu as mis qu'il s'agit du servo 1,alors que tu commande celui avec l'ID 2)
- pense à utiliser la valise code pour ton code, c'est beaucoup plus lisible

Et enfin, pour ton problème en lui-même : quand le bouton est enfoncé, tu dis au servo d'aller à la position 0 (je connais pas ces moteurs en particulier, soit il s'agit d'une position fixe, soit de la position à l'allumage). Par contre, quand le bouton est relâché, tu ne donne aucune nouvelle destination.
Donc initialement le bouton est en position 0,et tu ne lui dit jamais d'aller ailleurs : il n'a donc aucune raison de bouger

Je comprend vaguement après il y a l'explication à droite. Il faut que je me penche sur cette fameuse valise code qui faut que je trouve ..  

Ok je comprend, par contre je ne comprend pas commun et où je commande celui avec l'ID2 ? 

Merci 

 

Ici nous t'aidons gratuitement pour que tu comprennes ce que tu fais. 
On est pas là pour te pondre le programme qui fonctionne ... 

Et pour comprendre ce que tu fais mieux vaut aller étape par étape.  

Si tu maitrisais parfaitement les deux codes précédant et la base du langage arduino / la logique du codage, normalement tu aurais du réussir sans trop de problème à faire le code qui correspond à ton cas. 
Si tu but tu as besoin de mieux maîtriser ce que tu fais. 

 

Je suis tout à fait d'accord je ne maîtrise pas et c'est bien pour cela que je suis sur le forum. 

J'ai juste un souci de temps c'est pour cela que je cherche des solutions rapide. tout à un compte et je le comprend bien, pas de souci. 

Je vous remercie pour les pistes 

éventuellement je me dit que pour gagner du temps il serait préférable de se mettre sur le gros programme qui était un peu compliqué .. mais au moins ça sera plus rapide car si à chaque programme c'est compliqué.. ça ne fait pas avancer. Autant allé droit au but .. 

Merci pour votre aide. 

Bonjour,
Il faut mettre le nom de la variable dans laquelle tu défini le numéro de pin du bouton. Ici, c'est juste "bouton". (Même si je te suggère d'utiliser un nom plus explicite comme "pinBouton" pour éviter la confusion avec l'état du bouton)

Bonjour, merci pour votre réponse: Du coup j'ai fait le changement voir ci dessous :

#include <SCServo.h>                   // permet de faire appel à la bibliothèque Servo

SCServo SERVO;                       // crée une constante appelée « monservo » utilisable par la bibliothèque Servo.
                                      // (vous pouvez la nommez comme vous voulez, exemple : servo_1, mais pensez à le remplacer dans le programme).


int bouton = 8;                       // déclare le bouton poussoir sur la PIN 8.
int etatbouton = 0;                   // variable représentant le bouton, soit ouvert ou fermé, ici au départ à 0 donc fermé.


void setup() {
pinMode (bouton, INPUT_PULLUP);             // on indique que le bouton est une entrée.
SCServo SERVO;                   // commande de la bibliothèque Servo, qui consiste à « attacher » le servomoteur à la PIN 9
}


void loop() {
  etatbouton = digitalRead (bouton);  // On lit l’état du bouton pour savoir s’il est ouvert ou fermé


  if (etatbouton==HIGH) {            // Si la variable “etatbouton” est ouverte, à l’état haut, donc laisse passer le courant.
  SERVO.WritePos(1,0x0000, 3000);// Servo ID:1, rotate to the position:0x000
  SERVO.WritePos(2, 0x0000, 3000);// Servo ID:1, rotate to the position:0x000
  delay(3000);


}}

Du coup je fais un test avec un code simple pour faire fonctionner le servo voir ci dessous : 

// Ardwinner Servo-003-Bouton.// code Arduino pour déclencher un servomoteur à partir d’un bouton poussoir pour lui faire un prendre un angle précis (ici 90°), puis revenir à sa position initiale (ici 0°).


// note de montage : brancher le bouton poussoir sur la PIN 5V, la PIN Ground et la PIN 8, brancher le servomoteur sur la PIN 5V, la PIN Ground et la PIN 9.


#include <SCServo.h>                   // permet de faire appel à la bibliothèque Servo


SCServo SERVO;                       // crée une constante appelée « monservo » utilisable par la bibliothèque Servo.
                                      // (vous pouvez la nommez comme vous voulez, exemple : servo_1, mais pensez à le remplacer dans le programme).


int bouton = 8;                       // déclare le bouton poussoir sur la PIN 8.
int etatbouton = 0;                   // variable représentant le bouton, soit ouvert ou fermé, ici au départ à 0 donc fermé.


void setup() {
pinMode (ARDUINOPIN, INPUT_PULLUP);             // on indique que le bouton est une entrée.
SCServo SERVO;                   // commande de la bibliothèque Servo, qui consiste à « attacher » le servomoteur à la PIN 9
}


void loop() {
  etatbouton = digitalRead (bouton);  // On lit l’état du bouton pour savoir s’il est ouvert ou fermé


  if (etatbouton==HIGH) {            // Si la variable “etatbouton” est ouverte, à l’état haut, donc laisse passer le courant.
  SERVO.WritePos(1,0x0000, 3000);// Servo ID:1, rotate to the position:0x000
  SERVO.WritePos(2, 0x0000, 3000);// Servo ID:1, rotate to the position:0x000
  delay(3000);


}}

Tu as bien ouvert le moniteur série (Outils->Moniteur Série)?

Et tu n'as rien qui s'affiche?

 

Si c'est bien ça :

- vérifie que dans le moniteur est bien sur "9600 baud" (en bas à droite)

- si tu n'as toujours rien qui s'affiche dans le moniteur série, essaye d'ajouter la ligne suivante juste après la ligne "Serial.begin" :

Serial.println("ok, le setup fonctionne bien");

et bien non je n'avais pas fait ça. et effectivement ça fonctionne. j'ai une ligne de ON et quand j'appuis et le nombre de est variable selon comment j'appuie mais une impulsion Classic est de 1 OFF à 2 OF qui passe.

je pense que c'est bon signe du coup ?.. Du coup quelle code faudrait-il mettre dans ma formule ? 

Merci beaucoup 

C'est ton "pinBouton" l'erreur, il est déclarer nul part. (remplace pinButon par ARDUINOPIN)

Ok alors bien je n'ai plus d'erreur. du coup le bouton ne réagit pas aucun signal en retour .. 

Bon, 

Apprenons à marcher avant de courir. 

Fait un code plus simple : Sans le servo pour vérifier que tu sais utiliser ton bouton et que ça marche bien comme il faut. 

Regarde le Tome 2 de débuter avec arduino ( Tome toujours pas fini d'ailleurs ... )  plus précisément https://www.robot-maker.com/ouvrages/2-6-entrees-arduino/ modifie le premier code en mettant la pull up interne comme indiqué par Sandro : 

 

 

 

Et vérifie que tout marche bien comme prévu. ( Quand tu appuis sur le bouton vérifie que le texte ne s'affiche qu'une fois et pas plusieurs fois par appuis etc ... Ce qui permet de vérifier que tu n'as pas de problème de rebonds ) 

Une fois que tu sais faire ça tu as plus qu'à fusionner tes deux programmes. 

Note quand tu remmettras le servo évite de faire des Serialprint car ça sera envoyé au servomoteur ...

merci pour l'aide, j'ai donc fait l'exemple avec la modification et j'ai un message d'erreur ( voir capture ) 

Bonjour,

je crois avoir trouvé d'où viens ton problème.

 

Sauf erreur de ma part (si j'en crois tes photos et les modifs que tu as faites dans le code), ton bouton est branché sur le pin numérique n°8 : correct?

 

Le problème est que tu utilises les fonctions analogRead, qui sont prévues pour les pins analogiques (ie A0 à A7). Leur comportement n'est pas définit quand tu essaye de lire un pin numérique (d'après ce que j'ai compris du code source de la fonction analogRead, tu te retrouve à lire le pin analogique 8 modulo 8, soit le pin A0, mais sans garantie, le code source étant assez obscure).

 

Donc tu as deux possibilités :

1) tu branche ton bouton sur un pin analogique comme dans l'exemple. NB : pour ça, il faut aussi brancher une résistance comme dans l'exemple

2) tu lis le bouton comme un pin numérique, et pas comme un pin analogique. Pour ça, tu remplace la fonction lirePoussoir() par :

boolean lirePoussoir()
{
    boolean resultat = RELACHE;

    if (digitalRead(pinBouton)==HIGH) {
        resultat = PRESSE;
    }
    return resultat;
}

ou de manière plus compacte par :

boolean lirePoussoir()
{
    return digitalRead(pinBouton);
}

ou de manière encore plus compacte, tu supprime entièrement la fonction, et tu remplace l'appel à la fonction lirePoussoir() par digitalRead(pinBouton)
 

 

 

À noter :

- un "problème" des boutons est que le contact est mécanique, et qu'il y a parfois des "rebonds" (ie au moment ou on appuie sur le bouton (ou qu'on le relache), il y a un premier contact, puis une micro-coupure, puis un nouveau contact, ... jusqu'à ce que le contact soit bien établi. Du point de vue du programme, ça donne l'impression qu'on appuie plein de fois super vite sur le bouton.

Il y a plusieurs solutions à ce problème :

1) rajouter un petit délai dans le programme, pour être sur que le bouton soit stabilisé avant de le lire à nouveau

2) rajouter un condensateur (un composant électronique), qui permet de "lisser" la tension, et donc de faire disparaître les rebonds

3) la petite "astuce" du code d'exemple, d'utiliser un pin analogique : un pin analogique est relativement lent à lire (environ 100µs), ce qui peut suffire. L’inconvénient est qu'on 'a aucune maîtrise sur le délai : selon le bouton, il peut être insuffisant, ou au contraire plus long que nécessaire (bon, ça, dans ton programme, c'est pas grave)

 

- ce serait pas mal si tu pouvais nous faire un petit récaptilatif de qu'est-ce qui est branché comment/sur quel pin

 

- en particulier, selon comment tu as branché ton bouton, il se peut que les états soient inversés, voir qu'il faille que tu active la résistance de "pull-up" interne.

 

- si comme le laisse penser la photo, ton pin est branché entre les pins GND et 8 (sans résistance), alors tu as probablement les deux "problèmes". Pour les corriger, il te faut:

1) ajouter la résistance de pull-up interne, en ajoutant la ligne suivant dans la fonction setup :

pinMode(pinBouton, INPUT_PULLUP);

2) corriger l'inversion (que tu obtiens naturellement si tu utilise une résistance de pull-up (que ce soit la pull-up internet ou une résistance que tu mets toi même entre le bouton et le 5V)). Pour ça, il vas probablement falloir que tu modifie légèrement le code que je t'ai donné plus haut :

boolean lirePoussoir()
{
    boolean resultat = RELACHE;

    if (digitalRead(pinBouton)==LOW) {   //nb : HIGH remplacé par LOW
        resultat = PRESSE;
    }
    return resultat;
}

ou de manière plus compacte par :

boolean lirePoussoir()
{
    return !digitalRead(pinBouton);   //nb : ajout du point d'exclamation, qui veut dire "non logique", c'est à dire qu'on remplace 0 (ie LOW) par 1 (ie HIGH) et vice-versa
}

ou de manière encore plus compacte, tu supprime entièrement la fonction, et tu remplace l'appel à la fonction lirePoussoir() par !digitalRead(pinBouton)


 

Merci pour votre réponse c'est top de donner de son temps merci 

Du coup j'avoue que c'est du chinois tout ça pour moi.. 

Alors oui j'ai branché sur le pin 8 (j'ai d'ailleurs un doute sur le branchement, GND et signal c'est bien cela ? 

Je n'ai pas de résistance donc l'idéal serait faire sans.. J'ai donc testé la seconde possibilité et cela ne fonctionne pas. il se passe rien.. 

Pour palier au "problème " de bouton 

"1) rajouter un petit délai dans le programme, pour être sur que le bouton soit stabilisé avant de le lire à nouveau"

ou se trouver cela dans le code ? 

"3) la petite "astuce" du code d'exemple, d'utiliser un pin analogique : un pin analogique est relativement lent à lire (environ 100µs), ce qui peut suffire. "

quelle l'emplacement de cette PIN ? 

apriori il faudrait configurer le pin en entré pull up ... 

ci joint une photo du branchement ça parlera plus. 

​A savoir qu'il y avoir une batterie pour piloter tout ça (il y a deja une photo du branchement) 

Merci 

Je pense avoir trouvé un programme (http://modelleisenbahn.triskell.org/spip.php?article58)
qui semble très proche voir similaire. (Il faudra je pense revoir l'angle du servo..)

j'ai modifier le code pour adapter à mon cas le voici :

#include <SCServo.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;


SCServo SERVO;
int vitesse = 0;
int angle = angleMin;
byte etatServo = SERVO_A_ANGLE_MIN;


const int pinBouton = 8; /* 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()
{
  SCServo SERVO;
}


/*
 * La fonction loop() est exécutée
 * répétitivement
 */
void loop()
{
   
    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);}

J'ai aucun message d'erreur lors du téléversment mais cela ne fonctionne pas... J'ai aucun réaction du servo le BP 

Avez vous une idée sur le souci ?

Merci