Servomoteur bouton poussoir

Bonjour,
Je suis en train de réaliser un robot avec des servomoteurs. Ces servomoteurs sont sur un joy-it motorino lui-même relié à une carte arduino uno. Des boutons reliés à la carte permettent de réaliser des actiond. Un premier bouton permet de lancer le programme. Celui-ci fonctionne. Cependant lorsquie j'intègre une autre fonction, le second bouton fonctionne pas ni même n'apparaît. J'ai essayé il fonctionne et est bien branché.
Pouvez-vous m'aider ?
Ci dessous le programme

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150 
#define SERVOMAX  600
#define USMIN  600 
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_2 3
#define BUTTON_PIN_1 2

bool programmeEnCours = false;

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON_PIN_2, INPUT_PULLUP);
  pinMode(BUTTON_PIN_1, INPUT_PULLUP);
  Serial.println("GRIDUS");

  pwm.begin();
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(SERVO_FREQ); 

}

void setServoPulse(uint8_t n, double pulse) {
  double pulselength;
  
  
  pulselength = 1000000; 
  pulselength /= SERVO_FREQ;  
  Serial.print(pulselength); Serial.println(" us per period"); 
  pulselength /= 4096;  
  Serial.print(pulselength); Serial.println(" us per bit"); 
  pulse *= 1000000;  
  pulse /= pulselength;
  Serial.println(pulse);
  pwm.setPWM(n, 0, pulse);

  delay(100); // Attendre delayTime millisecondes après chaque position
}

void loop() {
  
  int buttonState1 = digitalRead(BUTTON_PIN_1);

  if (buttonState1 == LOW ) {
    programmeEnCours = true;
   
    delay(500);
    // Démarrer le programme
    Serial.println("Début du programme");
    delay(500); // Délai pour éviter les rebonds du bouton
  }
  
  while (programmeEnCours == true) {
    int buttonState2 = digitalRead(BUTTON_PIN_2);
   if (buttonState2 == LOW ) {
     programmeEnCours = false;
     Serial.println("pause");
      delay(500); // Délai pour éviter les rebonds du bouton
    }
   else {// Utilisation du canal 0 pour le servomoteur
    uint8_t servoChannel = 0;

    // Passage de 0 à 70 degrés
    uint16_t targetAngle = 70;
    uint16_t pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

    delay(2000); // Attendre 2 secondes

    // Utilisation du canal 1 pour le servomoteur
    servoChannel = 1;


    // Retour de passage de 0 à 10 degré
    targetAngle = 10;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position


   // Utilisation du canal 2 pour le servomoteur
    servoChannel = 2;
    
    // Passage de 0 à 85 degré
    targetAngle =85;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
    


    delay(2000); // Attendre 2 secondes

  

    // Utilisation du canal 1 pour le servomoteur
    servoChannel = 1;
    
    // Retour de 10 à 30 degré
    targetAngle = 30;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

    // Utilisation du canal 1 pour le servomoteur
    servoChannel = 2;
    
    // Passage de 85 à 100 degré
    targetAngle = 100;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
  
    // Utilisation du canal 0 pour le servomoteur
    servoChannel = 0;
    
    // Retour de 70 à 60 degré
    targetAngle = 60;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

    delay(2000); // Attendre 2 secondes

  

    // Utilisation du canal 0 pour le servomoteur
    servoChannel = 0;
    
    // Retour de 60 à 0 degré
    targetAngle = 0;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

    delay(2000); // Attendre 2 secondes

    
    // Utilisation du canal 2 pour le servomoteur
    servoChannel = 2;
    
    // Passage de 85 à 120 degré
    targetAngle = 120;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

    // Utilisation du canal 1 pour le servomoteur
    servoChannel = 1;
    
    // Retour de 0 à 0 degré
    targetAngle = 30;
    pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
    pwm.setPWM(servoChannel, 0, pulseValue);
    setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position



    Serial.println("FIN PROGRAMME");

   delay(5000); // Attendre 5 secondes

   programmeEnCours = false;
  }
  



  
}
}

:warning:
Post mis dans la mauvaise section, on parle anglais dans les forums généraux. déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans Les bonnes pratiques du Forum Francophone

Je suis désolé je suis nouveau je n'avais pas remarqué.

Bonjour pslr18

Ton bouton fonctionne, et il apparaît dans la console Serial.println("pause"); pour autant que buttonState1 == LOW et de par là, programmeEnCours == true
Si tu lis le bouton 2, "en même temps" que le bouton 1, pause apparaît dans la console. Ton programme ne fait plus rien, jusqu'à ce que tu presses le bouton 1.

Question: que veux tu faire avec ce bouton 2?

Cordialement
jpbbricole

Le problème, c'est que le second bouton n'est lu qu'au début de la boucle du programme.
Donc:

  • soit le programme est démarré et alors tu ne lis plus le bouton
  • soit le programme est stoppé et le second bouton est inutile

Je pense que ce n'est pas ce que tu voulais faire.

C'est cela, je ne lis plus le second bouton.
Dois-je le placer à l'intérieur de la boucle ?

Il faut donc que je n'introduise pas le bouton 1 dans les fonctions du 2.
Ce second bouton servirait à mettre en pause et continuer le programme lorsque celui-ci serait en fonctionnement. Ce serait une "sécurité"

Bonjour pslr18

Les 2 boutons doivent être lus de façon indépendante dans loop() c'est ces 2 lectures qui décident de l'état de programmeEnCours.

Je peux te faire un exemple, la question est: l'appui sur BUTTON_PIN_2 fait-il une pause dans les 9 mouvements de servo et une pression sur BUTTON_PIN_1 fait reprendre à la suite ou l'appui sur BUTTON_PIN_2 fait quitter la série de 9 mouvements de servo?

A+
Cordialement
jpbbricole

le BUTTON_PIN 2 servirait à mettre en pause le programme, et le BUTTON_PIN 1 à le démarrer ou le reprendre là ou il s'était arrêté, pour finir les 9 mouvements. Je souhaite appuyer à n'importe quel moment du programme.
En vous remerciant par avance
Cordialement
Paul

Bonjour pslr18

Comme je ne connais pas cette carte, j'ai retouché ton programme un minimum :wink:.

Ainsi, pour pouvoir arrêter la séquence des 9 mouvements n'importe où, il faut choisir un point de passage commun à ces 9 mouvements en l'occurrence void setServoPulse

Ainsi, à chaque lancement d'un mouvement de servo, le bouton 2 est lu:

void setServoPulse(uint8_t n, double pulse) {
	Serial.print("\nServo #" + String(n));
	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");

S'il y a pression du bouton 2, le programme tourne en boucle:
while(digitalRead(BUTTON_PIN_1) != LOW ) // On attend tant que le bouton 1 n'est pas pressé pour redémarrer {} jusqu'à ce que le bouton 1 soit pressé pour poursuivre les mouvements.
Le texte d'information apparaît dans la console

Servo #1	PAUSE
		    REPRISE

Pour ce qui est de la lecture du bouton 2, du fait des nombreuses temporisations avec delay(2000); // Attendre 2 secondes il faudra le presser un temps plus ou moins long (ne pas s'attendre à une réaction immédiate).

Le programme:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150
#define SERVOMAX  600
#define USMIN  600
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_2 3
#define BUTTON_PIN_1 2

bool programmeEnCours = false;

void setup() {
	Serial.begin(9600);
	pinMode(BUTTON_PIN_2, INPUT_PULLUP);
	pinMode(BUTTON_PIN_1, INPUT_PULLUP);
	Serial.println("GRIDUS");

	pwm.begin();
	pwm.setOscillatorFrequency(27000000);
	pwm.setPWMFreq(SERVO_FREQ);

}

void loop() {
	
	int buttonState1 = digitalRead(BUTTON_PIN_1);

	if (buttonState1 == LOW ) {
		programmeEnCours = true;
		
		delay(500);
		// Démarrer le programme
		Serial.println("Début du programme");
		delay(500); // Délai pour éviter les rebonds du bouton
	}
	
	while (programmeEnCours == true) {
		// Utilisation du canal 0 pour le servomoteur
		uint8_t servoChannel = 0;

		// Passage de 0 à 70 degrés
		uint16_t targetAngle = 70;
		uint16_t pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;


		// Retour de passage de 0 à 10 degré
		targetAngle = 10;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position


		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 0 à 85 degré
		targetAngle =85;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		


		delay(2000); // Attendre 2 secondes

		

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 10 à 30 degré
		targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 100 degré
		targetAngle = 100;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		
		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 70 à 60 degré
		targetAngle = 60;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		delay(2000); // Attendre 2 secondes

		

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 60 à 0 degré
		targetAngle = 0;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		delay(2000); // Attendre 2 secondes

		
		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 120 degré
		targetAngle = 120;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 0 à 0 degré
		targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position



		Serial.println("FIN PROGRAMME");

		delay(5000); // Attendre 5 secondes

		programmeEnCours = false;
	}
}

void setServoPulse(uint8_t n, double pulse) {
	Serial.print("\nServo #" + String(n));
	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");



	double pulselength;
		
	pulselength = 1000000;
	pulselength /= SERVO_FREQ;
	Serial.print(pulselength); Serial.println(" us per period");
	pulselength /= 4096;
	Serial.print(pulselength); Serial.println(" us per bit");
	pulse *= 1000000;
	pulse /= pulselength;
	Serial.println(pulse);
	pwm.setPWM(n, 0, pulse);

	delay(100); // Attendre delayTime millisecondes après chaque position
}

A ta disposition pour toutes questions.

Cordialement
jpbbricole

Le programme fonctioonne!
Je ne savais pas qu'on pouvait introduire des commandes if et while dans void setServoPulse. Je ne connais pas non plus les /n /t, pouvez vous m'expliquer? de plus, vous dites que du fait des nombreues temporisation faudra le presser plus ou moins, si on diminue les temporisations les commandes seront plus claires?
Merci encore pour vos réponses,
Cordialement
Paul

Suuuuper :+1: :+1: :+1:

Une fonction n'est jamais figée on peut y ajouter tout ce qui est nécessaire.

Attention, ce n'est pas /n et /t mais \n et \t.

\n signifie nouvelle ligne, c'est à dire que le curseur va au début de la ligne suivante.
\t est un saut du curseur à la prochaine position de tabulation, positions "virtuelles" ces tabulateur permettent d'aligner des textes verticalement.

Oui, plus ou moins longtemps. Je voulais dire, par là, qu'il ne fallait pas s'attendre à une réaction immédiate lors de la pression du bouton 2. Par exemple s'il y a
delay(2000); // Attendre 2 secondes
il n va rien se passer tant que delay n'est pas terminé, du fait que pendant cette fonction, l'Arduino ne fait rien d'autre que d'attendre la fin des 2000 millisecondes, donc il ne lit pas le bouton.

Non, diminuer les temporisations fausserai le déroulé des opérations, il suffit d'être conscient du "problème" :wink:

Cordialement
jpbbricole

Utiliser une machines à état pour faire ce genre de chose me semblerait bien adapté
Programmation Automate fini / Machine à état

D'accord j'ai compris le principe, je vous remercie ! je reviens vers vous si j'ai un autre problème !

Du coup j'ai ajouté un troisième bouton qui permet lui d'arrêter le programme et de faire revenir aux positions de base. Celui-ci fonctionne mais le soucis étant qu'il faut appuyer plusieurs fois avant que celui-ci s'arrête (pas un soucis non plus) mais surtout qu'une fois appuyé, je ne peux plus relancer le programme avec le premier bouton.

Voici le peogramme:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150
#define SERVOMAX  600
#define USMIN  600
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_2 3
#define BUTTON_PIN_1 2
#define BUTTON_PIN_3 4
bool programmeEnCours = false;

void setup() {
	Serial.begin(9600);
	pinMode(BUTTON_PIN_2, INPUT_PULLUP);
	pinMode(BUTTON_PIN_1, INPUT_PULLUP);
  pinMode(BUTTON_PIN_3, INPUT_PULLUP);
	Serial.println("GRIDUS");

	pwm.begin();
	pwm.setOscillatorFrequency(27000000);
	pwm.setPWMFreq(SERVO_FREQ);

}

void loop() {
	
	int buttonState1 = digitalRead(BUTTON_PIN_1);

	if (buttonState1 == LOW ) {
		programmeEnCours = true;
		
		delay(500);
		// Démarrer le programme
		Serial.println("Début du programme");
		delay(500); // Délai pour éviter les rebonds du bouton
	}
	
	while (programmeEnCours == true) {
		// Utilisation du canal 0 pour le servomoteur
		uint8_t servoChannel = 0;

		// Passage de 0 à 70 degrés
		uint16_t targetAngle = 80;
		uint16_t pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position


		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;


		// Retour de passage de 0 à 10 degré
		targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position


		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 0 à 85 degré
		targetAngle =85;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		


		delay(3000); // Attendre 2 secondes

		

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 10 à 30 degré
		targetAngle = 40;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 100 degré
		targetAngle = 100;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		
		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 70 à 60 degré
		targetAngle = 60;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		delay(3000); // Attendre 2 secondes

		

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 60 à 0 degré
		targetAngle = 0;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		
		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 120 degré
		targetAngle = 120;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 0 à 0 degré
		targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position



		Serial.println("FIN PROGRAMME");

		delay(5000); // Attendre 5 secondes

		programmeEnCours = false;
	}
}

void setServoPulse(uint8_t n, double pulse) {
	Serial.print("\nServo #" + String(n));
	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");

  Serial.print("\nServo #" + String(n));
	if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé arrêt du cycle
		Serial.print("\tArrêt Programme");
    
    uint8_t servoChannel;
	  double targetAngle;
	  int pulseValue;

    servoChannel = 0;
		targetAngle = 0;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position


		servoChannel = 2;
		targetAngle = 120;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue);


    servoChannel = 1;
    targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position

    Serial.println("FIN PROGRAMME");

    programmeEnCours = false;

	
	}


	double pulselength;
		
	pulselength = 1000000;
	pulselength /= SERVO_FREQ;
	Serial.print(pulselength); Serial.println(" us per period");
	pulselength /= 4096;
	Serial.print(pulselength); Serial.println(" us per bit");
	pulse *= 1000000;
	pulse /= pulselength;
	Serial.println(pulse);
	pwm.setPWM(n, 0, pulse);

	delay(100); // Attendre delayTime millisecondes après chaque position
}

Bonjour pslr18

Voilà une façon de faire, je n'ai pas le temps, actuellement, de t'en faire tout le détail, je le ferai à mon retour.
La lecture du bouton 3 se fait ainsi:

	if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");

		programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
	}

et le retour en position d'attente par:

		if (programmeEnCours == false){break;}     // On sort de la boucle while

Pour chaque mouvement de servo.

Ton programme nécessiterai d'être entièrement réorganisé, mais ce sera pour plus tard :wink:

Le programme:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150
#define SERVOMAX  600
#define USMIN  600
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_1 2
#define BUTTON_PIN_2 3
#define BUTTON_PIN_3 4

bool programmeEnCours = false;

void setup() {
	Serial.begin(9600);
	pinMode(BUTTON_PIN_1, INPUT_PULLUP);
	pinMode(BUTTON_PIN_2, INPUT_PULLUP);
	pinMode(BUTTON_PIN_3, INPUT_PULLUP);

	Serial.println("GRIDUS");

	pwm.begin();
	pwm.setOscillatorFrequency(27000000);
	pwm.setPWMFreq(SERVO_FREQ);

}

void loop() {
	
	int buttonState1 = digitalRead(BUTTON_PIN_1);

	if (buttonState1 == LOW ) {
		programmeEnCours = true;
		
		delay(500);
		// Démarrer le programme
		Serial.println("Début du programme");
		delay(500); // Délai pour éviter les rebonds du bouton
	}
	
	while (programmeEnCours == true) {
		// Utilisation du canal 0 pour le servomoteur
		uint8_t servoChannel = 0;

		// Passage de 0 à 70 degrés
		uint16_t targetAngle = 70;
		uint16_t pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;


		// Retour de passage de 0 à 10 degré
		targetAngle = 10;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while


		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 0 à 85 degré
		targetAngle =85;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while
		


		delay(2000); // Attendre 2 secondes

		

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 10 à 30 degré
		targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 100 degré
		targetAngle = 100;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while
		
		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 70 à 60 degré
		targetAngle = 60;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 60 à 0 degré
		targetAngle = 0;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		
		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 120 degré
		targetAngle = 120;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 0 à 0 degré
		targetAngle = 30;
		pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
		pwm.setPWM(servoChannel, 0, pulseValue);
		setServoPulse(servoChannel, pulseValue); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while



		Serial.println("FIN PROGRAMME");

		delay(5000); // Attendre 5 secondes

		programmeEnCours = false;
	}
}

void setServoPulse(uint8_t n, double pulse) {
	Serial.print("\nServo #" + String(n));
	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");

	if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");

		programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
	}



	double pulselength;
		
	pulselength = 1000000;
	pulselength /= SERVO_FREQ;
	Serial.print(pulselength); Serial.println(" us per period");
	pulselength /= 4096;
	Serial.print(pulselength); Serial.println(" us per bit");
	pulse *= 1000000;
	pulse /= pulselength;
	Serial.println(pulse);
	pwm.setPWM(n, 0, pulse);

	delay(100); // Attendre delayTime millisecondes après chaque position
}

A+
Cordialement
jpbbricole

D'accord je vous remercie déjà pour cette réponse
Cordialement
Paul

Bonjour pslr18

Est-ce que le bouton 3 fonctionne?

En fait, l'essentiel est, le return dans la condition bouton 3 pressé:

	if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");

		programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
	}

qui fait quitter la fonction void setServoPulse avant sa fin qui est, normalement, après sa dernière instruction, delay(100);.
Ensuite comme programmeEnCours est devenu false, à chaque pas de programme, s'il n'y a plus de programme en cours, on quitte la boucle while (programmeEnCours == true) où que l'on se trouve par: if (programmeEnCours == false){break;} // On sort de la boucle while

Ici des informations sur return et break.

Toujours dans le but d'optimiser ton programme, certaines répétitions peuvent être "concentrées" en un seul endroit.
Ainsi,

	pulseValue = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);
	pwm.setPWM(servoChannel, 0, pulseValue);

qui est répété à chaque pas du programme, moyennant un petit aménagement, peut âtre transféré dans void setServoPulse ainsi:

void setServoPulse(uint8_t servoChannel, uint16_t targetAngle) {
	double pulse = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);;
	pwm.setPWM(servoChannel, 0, pulse);

Je te laisses regarder la différence avec la version précédente.

Le programme:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150
#define SERVOMAX  600
#define USMIN  600
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_1 2
#define BUTTON_PIN_2 3
#define BUTTON_PIN_3 4

bool programmeEnCours = false;

void setup() {
	Serial.begin(9600);
	pinMode(BUTTON_PIN_1, INPUT_PULLUP);
	pinMode(BUTTON_PIN_2, INPUT_PULLUP);
	pinMode(BUTTON_PIN_3, INPUT_PULLUP);

	Serial.println("GRIDUS");

	pwm.begin();
	pwm.setOscillatorFrequency(27000000);
	pwm.setPWMFreq(SERVO_FREQ);

}

void loop() {
	
	int buttonState1 = digitalRead(BUTTON_PIN_1);

	if (buttonState1 == LOW ) {
		programmeEnCours = true;
		
		delay(500);
		// Démarrer le programme
		Serial.println("Début du programme");
		delay(500); // Délai pour éviter les rebonds du bouton
	}
	
	while (programmeEnCours == true) {
		// Utilisation du canal 0 pour le servomoteur
		uint8_t servoChannel = 0;

		// Passage de 0 à 70 degrés
		uint16_t targetAngle = 70;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		// Retour de passage de 0 à 10 degré
		targetAngle = 10;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		// Passage de 0 à 85 degré
		targetAngle =85;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		// Retour de 10 à 30 degré
		targetAngle = 30;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 2;
		// Passage de 85 à 100 degré
		targetAngle = 100;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		// Retour de 70 à 60 degré
		targetAngle = 60;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		// Retour de 60 à 0 degré
		targetAngle = 0;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		// Passage de 85 à 120 degré
		targetAngle = 120;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		// Retour de 0 à 0 degré
		targetAngle = 30;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		Serial.println("FIN PROGRAMME");

		delay(5000); // Attendre 5 secondes

		programmeEnCours = false;
	}
}

void setServoPulse(uint8_t servoChannel, uint16_t targetAngle) {
	double pulse = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);;
	pwm.setPWM(servoChannel, 0, pulse);

	Serial.print("\nServo #" + String(servoChannel));
	Serial.print(" > " + String(targetAngle));

	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");

	if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");

		programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
	}



	double pulselength;
		
	pulselength = 1000000;
	pulselength /= SERVO_FREQ;
	Serial.print(pulselength); Serial.println(" us per period");
	pulselength /= 4096;
	Serial.print(pulselength); Serial.println(" us per bit");
	pulse *= 1000000;
	pulse /= pulselength;
	Serial.println(pulse);
	pwm.setPWM(servoChannel, 0, pulse);

	delay(100); // Attendre delayTime millisecondes après chaque position
}

Si tu es intéressé, on peut pousser plus loin l'optimisation, c'est volontiers :wink:

A+
Cordialement
jpbbricole

Les boutons fonctionnent !
Merci pour ce programme. Pour ce qui est juste du bouton 3. Je souhaiterai une fois le programme en break de mettre en statu que le boucle est while (programmeEnCours == true) soit Programme en cours == false; et par la suite introduire les mouvements de remise à 0 de mes servomoteurs dans
` if (digitalRead(BUTTON_PIN_3) == LOW ) { // Bouton 3 pressé Arret du cycle
Serial.println("\tARRET");

	programmeEnCours = false;
	return;     // On quitte la fonction setServoPulse
}`

Ce qui ferait:

if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");
    // Utilisation du canal 4pour le servomoteur
		servoChannel = 4;


		// Retour de passage de 0 à 90 degré
		targetAngle = 90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		
		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 85 à 90 degré
		targetAngle = 90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 0 à 30 degré
		targetAngle = 30;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while
 
    delay(2000);

   
    
    
		servoChannel = 3;


		// Retour de passage de 0 à 90 degré
		targetAngle = 90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while



		Serial.println("FIN PROGRAMME");
                programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
}

Voici le programme actuel:

 `#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150
#define SERVOMAX  600
#define USMIN  600
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_1 2
#define BUTTON_PIN_2 3
#define BUTTON_PIN_3 4

bool programmeEnCours = false;

void setup() {
	Serial.begin(9600);
	pinMode(BUTTON_PIN_1, INPUT_PULLUP);
	pinMode(BUTTON_PIN_2, INPUT_PULLUP);
	pinMode(BUTTON_PIN_3, INPUT_PULLUP);
Serial.println("GRIDUS");

pwm.begin();
pwm.setOscillatorFrequency(27000000);
pwm.setPWMFreq(SERVO_FREQ);

}

        ` void loop() {`
	
	int buttonState1 = digitalRead(BUTTON_PIN_1);

	if (buttonState1 == LOW ) {
		programmeEnCours = true;
		
		delay(500);
		// Démarrer le programme
		Serial.println("Début du programme");
		delay(500); // Délai pour éviter les rebonds du bouton
	}
	
	while (programmeEnCours == true) {
		// Utilisation du canal 0 pour le servomoteur
		uint8_t servoChannel = 0;

		// Passage de 10 à 84 degrés
		uint16_t targetAngle = 84;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

  
		servoChannel = 3;


		// Retour de passage de 90 à 0 degré
		targetAngle = 0;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while


		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;


		// Retour de passage de 30 à 50 degré
		targetAngle = 50;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

    delay(2000); // Attendre 2 secondes

  	// Utilisation du canal 4 pour le servomoteur
		servoChannel = 4;


		// Retour de passage de 90 à 115 degré
		targetAngle = 115;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

    delay(2000); // Attendre 2 secondes


		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 0 à 90 degré
		targetAngle =90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while
		


		delay(2000); // Attendre 2 secondes

		

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 50 à 60 degré
		targetAngle = 60;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 90 à 100 degré
		targetAngle = 100;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while
		
		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		
		// Retour de 84 à 60 degré
		targetAngle = 60;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		// Retour de 60 à 10 degré
		targetAngle = 10;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

    // Utilisation du canal 4 pour le servomoteur
		servoChannel = 4;


		// Retour de passage de 0 à 90 degré
		targetAngle = 90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		
		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		
		// Passage de 100 à 90 degré
		targetAngle = 90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		
		// Retour de 0 à 30 degré
		targetAngle = 30;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while
 
    delay(2000);

   
    
    // Utilisation du canal 3 pour le servomoteur
		servoChannel = 3;


		// Retour de passage de 0 à 90 degré
		targetAngle = 90;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){break;}     // On sort de la boucle while



		Serial.println("FIN PROGRAMME");

		delay(5000); // Attendre 5 secondes

		programmeEnCours = false;
	}
}

void setServoPulse(uint8_t servoChannel, uint16_t targetAngle) {
  double pulse = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);;
	pwm.setPWM(servoChannel, 0, pulse);

	Serial.print("\nServo #" + String(servoChannel));
  Serial.print(" > " + String(targetAngle));

	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");

	if (digitalRead(BUTTON_PIN_3) == LOW ) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");

		programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
	}



	double pulselength;
		
	pulselength = 1000000;
	pulselength /= SERVO_FREQ;
	Serial.print(pulselength); Serial.println(" us per period");
	pulselength /= 4096;
	Serial.print(pulselength); Serial.println(" us per bit");
	pulse *= 1000000;
	pulse /= pulselength;
	Serial.println(pulse);
	pwm.setPWM(servoChannel, 0, pulse);

	delay(100); // Attendre delayTime millisecondes après chaque position


}

Une dernière amélioration que je souhaiterai réaliser est diminuer la vitesse des servomoteurs.

Et par la suite réaliser l'optimisation!
A+
Cordialement
Paul

Bonjour pslr18

Essaies ça:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
#define SERVOMIN  150
#define SERVOMAX  600
#define USMIN  600
#define USMAX  2400
#define SERVO_FREQ 50

#define BUTTON_PIN_1 2
#define BUTTON_PIN_2 3
#define BUTTON_PIN_3 4

bool programmeEnCours = false;

void setup() {
	Serial.begin(9600);
	pinMode(BUTTON_PIN_1, INPUT_PULLUP);
	pinMode(BUTTON_PIN_2, INPUT_PULLUP);
	pinMode(BUTTON_PIN_3, INPUT_PULLUP);

	Serial.println("GRIDUS");

	pwm.begin();
	pwm.setOscillatorFrequency(27000000);
	pwm.setPWMFreq(SERVO_FREQ);

}

void loop() {
	
	int buttonState1 = digitalRead(BUTTON_PIN_1);

	if (buttonState1 == LOW ) {
		programmeEnCours = true;
		
		delay(500);
		// Démarrer le programme
		Serial.println("Début du programme");
		delay(500); // Délai pour éviter les rebonds du bouton
	}
	
	while (programmeEnCours == true) {
		// Utilisation du canal 0 pour le servomoteur
		uint8_t servoChannel = 0;

		// Passage de 0 à 70 degrés
		uint16_t targetAngle = 70;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		// Retour de passage de 0 à 10 degré
		targetAngle = 10;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		// Passage de 0 à 85 degré
		targetAngle =85;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		// Retour de 10 à 30 degré
		targetAngle = 30;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 2;
		// Passage de 85 à 100 degré
		targetAngle = 100;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		// Retour de 70 à 60 degré
		targetAngle = 60;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 0 pour le servomoteur
		servoChannel = 0;
		// Retour de 60 à 0 degré
		targetAngle = 0;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		delay(2000); // Attendre 2 secondes

		// Utilisation du canal 2 pour le servomoteur
		servoChannel = 2;
		// Passage de 85 à 120 degré
		targetAngle = 120;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		// Utilisation du canal 1 pour le servomoteur
		servoChannel = 1;
		// Retour de 0 à 0 degré
		targetAngle = 30;
		setServoPulse(servoChannel, targetAngle); // Attendre 10 millisecondes entre chaque position
		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

		Serial.println("FIN PROGRAMME");

		delay(5000); // Attendre 5 secondes

		programmeEnCours = false;
	}
}

void setServoPulse(uint8_t servoChannel, uint16_t targetAngle) {
	double pulse = map(targetAngle, 0, 180, SERVOMIN, SERVOMAX);;
	pwm.setPWM(servoChannel, 0, pulse);

	Serial.print("\nServo #" + String(servoChannel));
	Serial.print(" > " + String(targetAngle));

	if (digitalRead(BUTTON_PIN_2) == LOW ) {     // Bouton 2 pressé Suspension du cycle
		Serial.print("\tPAUSE");

		while(digitalRead(BUTTON_PIN_1) != LOW )     // On attend tant que le bouton 1 n'est pas pressé pour redémarrer
		{}
		Serial.print("\n\t\tREPRISE");
	}
	Serial.println("");

	if (digitalRead(BUTTON_PIN_3) == LOW && programmeEnCours == true) {     // Bouton 3 pressé Arret du cycle
		Serial.println("\tARRET");

		programmeEnCours = false;
		return;     // On quitte la fonction setServoPulse
	}



	double pulselength;
		
	pulselength = 1000000;
	pulselength /= SERVO_FREQ;
	Serial.print(pulselength); Serial.println(" us per period");
	pulselength /= 4096;
	Serial.print(pulselength); Serial.println(" us per bit");
	pulse *= 1000000;
	pulse /= pulselength;
	Serial.println(pulse);
	pwm.setPWM(servoChannel, 0, pulse);

	delay(100); // Attendre delayTime millisecondes après chaque position
}

void programmeStop()
{
	programmeEnCours = false;

	// Remise à 0 des servo
	setServoPulse(0, 0);
	setServoPulse(1, 0);
	setServoPulse(2, 0);
}

Il y a une nouvelle fonction, void programmeStop() qui est appelée au moment de quitter le programme par:

		if (programmeEnCours == false){programmeStop(); break;}     // On sort de la boucle while

PS: Pour la vitesse, il faut voire du côté de la bibliothèque, jette y un coups d'œil, je regarderai, aussi, de mon côté.

A+
Cordialement
jpbbricole