Gestion des servos moteur avec PCA9685

Bonjour à tous,

Voici mon projet : créer un bras robot avec 5 servos moteurs ainsi qu'un moteur pas à pas, le tout controllé par un joystick et des boutons.

Problème : le code ne fonctionne pas.

J'ai vérifié les branchements et cela ne semble pas être le problème.
Je pense que le soucis se situe dans l'utilisation de la librairie Adafruit_PWMServoDriver mais étant novice, je ne sais pas le détecter.
Je me permets de préciser que pour l'utilisation de cette dernière j'ai utiliser du code trouvé sur le net (Source), notamment pour les variables pulse_wide et pulse_width et que je comprends pas vraiment ce qu'elles font, surtout pour pulse_width.

Je précise que j'utilise 4 servos moteurs MG996 et un micro servo SG90, le tout controllé avec un PCA9685.
Pour le moteur pas à pas, c'est un Nema 17 avec un DRV8825.
La carte est une Arduino Mega.

Voici mon code (je me doute que j'aurais pu le simplifier en créant une fonction mais ce n'est pas la question) :

#include <AccelStepper.h>
#include <Adafruit_PWMServoDriver.h>
#include <Wire.h>
// Déclaration des broches pour le moteur pas à pas :
#define STEP_PIN 2
#define DIR_PIN 3

// Sensibilité du joystick :
#define JOYSTICK_THRESHOLD 50

#define MIN_PULSE_WIDTH 650
#define MAX_PULSE_WIDTH 2350
#define FREQUENCY 50

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// Déclaration des broches pour le Joystick :
const int joystick_XPin = A0;  // Broche analogique pour l'axe X du joystick

// Déclaration des broches pour les boutons
const int joystick_bouton_corpsPin = 8;  // Broche numérique pour le bouton du joystick
const int bouton_epaulePin = 9;
const int bouton_coudePin = 10;
const int bouton_poignetHBPin = 11;
const int bouton_poignetGDPin = 12;
const int bouton_mainPin = 13;

bool joystick_bouton_corps_Precedent = HIGH;  // État précédent du bouton joystick_bouton_corps_Precedent
bool bouton_epaule_Precedent = HIGH;
bool bouton_coude_Precedent = HIGH;
bool bouton_poignetHB_Precedent = HIGH;
bool bouton_poignetGD_Precedent = HIGH;
bool bouton_main_Precedent = HIGH;


// Déclaration du moteur
AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);

void setup() {

  Serial.begin(9600);  // debug
  pwm.begin();         // début de la communication
  pwm.setPWMFreq(FREQUENCY);

  // Mise à l'origine des servos :
  pwm.setPWM(0, 0, 0);
  pwm.setPWM(1, 0, 0);
  pwm.setPWM(2, 0, 0);
  pwm.setPWM(3, 0, 0);
  pwm.setPWM(4, 0, 0);


  // moteur pas à pas, réglages :
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);

  stepper.setMaxSpeed(1000);
  stepper.setAcceleration(500);


  // Configuration des boutons
  pinMode(joystick_bouton_corpsPin, INPUT_PULLUP);
  pinMode(bouton_epaulePin, INPUT_PULLUP);
  pinMode(bouton_coudePin, INPUT_PULLUP);
  pinMode(bouton_poignetHBPin, INPUT_PULLUP);
  pinMode(bouton_poignetGDPin, INPUT_PULLUP);
  pinMode(bouton_mainPin, INPUT_PULLUP);
}




void loop() {

  int x_data = analogRead(joystick_XPin);
  int pulse_wide = map(x_data, 0, 1023, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
  int pulse_width = int(float(pulse_wide) / 1000000 * FREQUENCY * 4096);

  // Lecture de l'état actuel des boutons
  bool etat_joystick_bouton_corps = digitalRead(joystick_bouton_corpsPin);
  bool etat_bouton_epaule = digitalRead(bouton_epaulePin);
  bool etat_bouton_coude = digitalRead(bouton_coudePin);
  bool etat_bouton_poignetHB = digitalRead(bouton_poignetHBPin);
  bool etat_bouton_poignetGD = digitalRead(bouton_poignetGDPin);
  bool etat_bouton_main = digitalRead(bouton_mainPin);

  // ########################## Controle du moteur pas à pas : #######################################
  // Vérification si le bouton corps a été cliqué
  if (etat_joystick_bouton_corps == LOW && joystick_bouton_corps_Precedent == HIGH) {
    // Determine the direction based on the joystick position
    if (x_data < 512 - JOYSTICK_THRESHOLD) {
      stepper.setSpeed(500);  // Set speed for one direction
    } else if (x_data > 512 + JOYSTICK_THRESHOLD) {
      stepper.setSpeed(-500);  // Set speed for the opposite direction
    } else {
      stepper.setSpeed(0);  // Stop the motor if joystick is centered
    }

    // Step the motor one step
    stepper.runSpeed();

    // You can add a delay here to control the speed of the motor
    delay(10);
  }
  // #################################################################################################



  // ########################## Controle du servo épaule : ###########################################
  // Vérification si le bouton épaule a été cliqué
  if (etat_bouton_epaule == LOW && bouton_epaule_Precedent == HIGH) {
    pwm.setPWM(0, 0, pulse_width);
  }
  // #################################################################################################



  // ########################## Controle du servo coude : ############################################
  // Vérification si le bouton coude a été cliqué
  if (etat_bouton_coude == LOW && bouton_coude_Precedent == HIGH) {
    pwm.setPWM(1, 0, pulse_width);
  }
  // #################################################################################################



  // ########################## Controle du servo poignet Haut/Bas : #################################
  // Vérification si le bouton poignet Haut/Bas a été cliqué
  if (etat_bouton_poignetHB == LOW && bouton_poignetHB_Precedent == HIGH) {
    pwm.setPWM(2, 0, pulse_width);
  }
  // #################################################################################################



  // ########################## Controle du servo poignet Gauche/Droite : ############################
  // Vérification si le bouton poignet Gauche/Droite a été cliqué
  if (etat_bouton_poignetGD == LOW && bouton_poignetGD_Precedent == HIGH) {
    pwm.setPWM(3, 0, pulse_width);
  }
  // #################################################################################################



  // ########################## Controle du servo main : #############################################
  // Vérification si le bouton main a été cliqué
  if (etat_bouton_main == LOW && bouton_main_Precedent == HIGH) {
    pwm.setPWM(4, 0, pulse_width);
  }
  // #################################################################################################

  // Mise à jour de l'état précédent des boutons
  joystick_bouton_corps_Precedent = etat_joystick_bouton_corps;
  bouton_epaule_Precedent = etat_bouton_epaule;
  bouton_coude_Precedent = etat_bouton_coude;
  bouton_poignetHB_Precedent = etat_bouton_poignetHB;
  bouton_poignetGD_Precedent = etat_bouton_poignetGD;
  bouton_main_Precedent = etat_bouton_main;

  delay(50);  // Délai pour éviter les rebonds des boutons
}

Voici une représentation de mes branchements :

Bonjour jean_pascal

Il n'y a rien qui fonctionne ou seulement des bouts?

A+
jpbbricole

Je viens de remarquer quelque chose :

Lorsque je bouge le joystick dans un sens, maintient sa position, puis que je clique sur l'un des boutons poussoir, le servo bouge en effet, proportionnellement, à la position du joystick (du moins, c'est mon impression).
Mais ça n'est pas continu. Je dois re-bouger le joystick, re-presser le bouton qui lui correspond et là... le servo bouge à nouveau.

Même chose avec le moteur pas à pas mais ça fonctionne encore moins bien car c'est le "clique" du joystick qui lui est attitré.

Bonjour jean_pascal

Pour debugger ton programme tu devrai afficher certaines variables comme ceci:

	// ########################## Controle du servo épaule : ###########################################
	// Vérification si le bouton épaule a été cliqué
	if (etat_bouton_epaule == LOW && bouton_epaule_Precedent == HIGH) {
		Serial.println("bouton_epaule" + String(pulse_width));
		pwm.setPWM(0, 0, pulse_width);
	}

Ainsi tu verra fonctionner ton programme.
Tu disperses ces print un peu partout, quitte à les enlever une fois le travail terminé.

Cordialement
jpbbricole

Voilà ce qu'il se passe quand j'appuie sur les boutons sans bouger le joystick :
image

Et ça c'est lorsque je bouge le joystick en même temps :
image

De ce que je vois, les valeurs min et max prise par la variable pulse_width sont 133 et 480 (ou 481).
La valeur avec le joystick en position neutre est 304.

En dehors de ce constat, avec mes connaissances personnelles je ne suis pas capable de déterminer quel est le problème.
Une idée ?

Dans ton programme, toutes les actions sont liées à une transition HAUT -> BAS d'un bouton à chaque fois tu fais un test

 (etat_bouton_xxxxx == LOW && bouton_xxxx_Precedent == HIGH)

Donc c'est normal que tu sois obligé de cliquer un bouton pour valider les actions.

Si tu expliquais ce que tu voulais faire ce serait peut-être plus facile de t'aider.

bonjour @fdufnews,

l'objectif est le suivant : quand je clique sur le bouton 1 ou coude dans mon cas, les mouvements du joystick vont faire bouger le servo associé à ce bouton.
Donc quand le joystick est à l'origine (que je ne le touche pas) le servo ne bouge pas mais si je le pousse vers +x ou -x alors le servo va rejoindre la position associé au mouvement du joystick et y reste tant qu'il n'y a pas eu de nouvelles "instructions".

Si je clique sur un autre bouton, alors les mouvements du joystick vont être reçu et executées par le servo associé à ce nouveau bouton et ainsi de suite pour tous les moteurs y compris le moteur pas à pas avec cette fois le bouton du joystick lui même.

En gros tous les moteurs bougent en fonction du joystick et les boutons permettent de sélectionner lequel des moteurs va suivre les mouvement du joystick.

C'est-à-dire, un appui fugitif suffit ou il faut tenir le bouton pendant toute l'action?
Et si c'est un appui fugitif, est-ce que l'action se fera sur le même axe tant que tu n'appuiras pas sur un autre bouton ou bien y-a-t-il une limite de temps?

Exactement, appui fugitif et tant que je n'appuie pas sur un autre bouton l'action continue sur le même axe donc le même moteur.

OK.
Donc il faut séparer la lecture des boutons et l'envoi des infos du joystick.
Je verrais bien quelque chose comme ça.

  1. tu définis des "modes" et tu crées une variable mode
enum modes {rien, corps, epaule, coude, poignetHBP, poignetGD, main} ;
modes mode = rien;
  1. tu gères les boutons
if (etat_joystick_bouton_corps == LOW && joystick_bouton_corps_Precedent == HIGH) {
     mode = corps;
}
if (etat_bouton_epaule == LOW && bouton_epaule_Precedent == HIGH) {
     mode = epaule;
}
..... répéter pour les autres boutons
  1. tu gères les actions
switch(mode){
   case corps:
        action pour le corps
   break;
   case epaule:
        action epaule
   break;
   case ..... répéter pour les autres cas
}

Edit: correction dans le code

1 Like

Bonsoir @fdufnews,

Merci, j'ai fais ce que tu m'as dis mais juste en enlevant le "=" dans cette partie du code.

Et ça commence à fonctionner correctement.

Tous fonctionne très bien pour le contrôle avec les boutons seulement, j'ai remarqué 3 problèmes :

  1. Les servos reviennent à leur position d'origine dès que je lâche le joystick, mais j'aimerais qu'ils restent là où je les ai "emmenés".

  2. Lorsque l'un des servos est sélectionné, que son bouton à été pressé, mais que je ne bouge pas le joystick il tremble / vibre plus ou moins légèrement.

  3. La rotation de 180° ne se fait pas, je dirais que les servos bougent entre 0° et 160° environ (cela vient peut-être des variables pulse_wide et pulse_width avec MIN_PULSE_WIDTH et MAX_PULSE_WIDTH mais ça n'est qu'une hypothèse, je ne m'y connais pas assez).

Je remet le code avec les modifications au cas où :

#include <AccelStepper.h>
#include <Adafruit_PWMServoDriver.h>
#include <Wire.h>
// Déclaration des broches pour le moteur pas à pas :
#define STEP_PIN 2
#define DIR_PIN 3

// Sensibilité du joystick :
#define JOYSTICK_THRESHOLD 50

#define MIN_PULSE_WIDTH 650
#define MAX_PULSE_WIDTH 2350
#define FREQUENCY 50

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// Déclaration des broches pour le Joystick :
const int joystick_XPin = A0;  // Broche analogique pour l'axe X du joystick

// Déclaration des broches pour les boutons
const int joystick_bouton_corpsPin = 8;  // Broche numérique pour le bouton du joystick
const int bouton_epaulePin = 9;
const int bouton_coudePin = 10;
const int bouton_poignetHBPin = 11;
const int bouton_poignetGDPin = 12;
const int bouton_mainPin = 13;

enum modes { rien,
             corps,
             epaule,
             coude,
             poignetHB,
             poignetGD,
             main };
modes mode = rien;


bool joystick_bouton_corps_Precedent = HIGH;  // État précédent du bouton joystick_bouton_corps_Precedent
bool bouton_epaule_Precedent = HIGH;
bool bouton_coude_Precedent = HIGH;
bool bouton_poignetHB_Precedent = HIGH;
bool bouton_poignetGD_Precedent = HIGH;
bool bouton_main_Precedent = HIGH;


// Déclaration du moteur
AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);

void setup() {

  Serial.begin(9600);  // debug
  pwm.begin();         // début de la communication
  pwm.setPWMFreq(FREQUENCY);

  // Mise à l'origine des servos :
  pwm.setPWM(0, 0, 0);
  pwm.setPWM(1, 0, 0);
  pwm.setPWM(2, 0, 0);
  pwm.setPWM(3, 0, 0);
  pwm.setPWM(4, 0, 0);


  // moteur pas à pas, réglages :
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);

  stepper.setMaxSpeed(1000);
  stepper.setAcceleration(500);


  // Configuration des boutons
  pinMode(joystick_bouton_corpsPin, INPUT_PULLUP);
  pinMode(bouton_epaulePin, INPUT_PULLUP);
  pinMode(bouton_coudePin, INPUT_PULLUP);
  pinMode(bouton_poignetHBPin, INPUT_PULLUP);
  pinMode(bouton_poignetGDPin, INPUT_PULLUP);
  pinMode(bouton_mainPin, INPUT_PULLUP);
}




void loop() {

  int x_data = analogRead(joystick_XPin);
  int pulse_wide = map(x_data, 0, 1023, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
  int pulse_width = int(float(pulse_wide) / 1000000 * FREQUENCY * 4096);

  // Lecture de l'état actuel des boutons
  bool etat_joystick_bouton_corps = digitalRead(joystick_bouton_corpsPin);
  bool etat_bouton_epaule = digitalRead(bouton_epaulePin);
  bool etat_bouton_coude = digitalRead(bouton_coudePin);
  bool etat_bouton_poignetHB = digitalRead(bouton_poignetHBPin);
  bool etat_bouton_poignetGD = digitalRead(bouton_poignetGDPin);
  bool etat_bouton_main = digitalRead(bouton_mainPin);

  // ########################## Controle du moteur pas à pas : #######################################
  // Vérification si le bouton corps a été cliqué
  if (etat_joystick_bouton_corps == LOW && joystick_bouton_corps_Precedent == HIGH) {
    mode = corps;
    // Determine the direction based on the joystick position
  }
  // #################################################################################################



  // ########################## Controle du servo épaule : ###########################################
  // Vérification si le bouton épaule a été cliqué
  if (etat_bouton_epaule == LOW && bouton_epaule_Precedent == HIGH) {
    mode = epaule;
  }
  // #################################################################################################



  // ########################## Controle du servo coude : ############################################
  // Vérification si le bouton coude a été cliqué
  if (etat_bouton_coude == LOW && bouton_coude_Precedent == HIGH) {
    mode = coude;
  }
  // #################################################################################################



  // ########################## Controle du servo poignet Haut/Bas : #################################
  // Vérification si le bouton poignet Haut/Bas a été cliqué
  if (etat_bouton_poignetHB == LOW && bouton_poignetHB_Precedent == HIGH) {
    mode = poignetHB;
  }
  // #################################################################################################



  // ########################## Controle du servo poignet Gauche/Droite : ############################
  // Vérification si le bouton poignet Gauche/Droite a été cliqué
  if (etat_bouton_poignetGD == LOW && bouton_poignetGD_Precedent == HIGH) {
    mode = poignetGD;
  }
  // #################################################################################################



  // ########################## Controle du servo main : #############################################
  // Vérification si le bouton main a été cliqué
  if (etat_bouton_main == LOW && bouton_main_Precedent == HIGH) {
    mode = main;
  }
  // #################################################################################################


  switch (mode) {
    case corps:
      if (x_data < 512 - JOYSTICK_THRESHOLD) {
        stepper.setSpeed(500);  // Set speed for one direction
      } else if (x_data > 512 + JOYSTICK_THRESHOLD) {
        stepper.setSpeed(-500);  // Set speed for the opposite direction
      } else {
        stepper.setSpeed(0);  // Stop the motor if joystick is centered
      }

      // Step the motor one step
      stepper.runSpeed();

      // You can add a delay here to control the speed of the motor
      delay(10);
      break;
    case epaule:
      pwm.setPWM(0, 0, pulse_width);
      break;
    case coude:
      pwm.setPWM(1, 0, pulse_width);
      break;
    case poignetHB:
      pwm.setPWM(2, 0, pulse_width);
      break;
    case poignetGD:
      pwm.setPWM(3, 0, pulse_width);
      break;
    case main:
      pwm.setPWM(4, 0, pulse_width);
      break;
  }

  // Mise à jour de l'état précédent des boutons
  joystick_bouton_corps_Precedent = etat_joystick_bouton_corps;
  bouton_epaule_Precedent = etat_bouton_epaule;
  bouton_coude_Precedent = etat_bouton_coude;
  bouton_poignetHB_Precedent = etat_bouton_poignetHB;
  bouton_poignetGD_Precedent = etat_bouton_poignetGD;
  bouton_main_Precedent = etat_bouton_main;

  delay(50);  // Délai pour éviter les rebonds des boutons
}

Merci d'avance pour ton aide précieuse. :grin:

Sujet up

C'est le fonctionnement que tu as demandé. On sélectionne un canal et on recopie la valeur du joystick dans le servo.
2 solutions possibles:

  • Supprimer le ressort de rappel du joystick
  • Prévoir un bouton supplémentaire pour désactiver la recopie avant de lâcher le joystick. Le bouton fera passer dans le mode rien.

Edit: une solution supplémentaire

  • passage dans le mode rien automatiquement si la valeur du joystick ne change pas pendant un temps donné. Pas toujours facile à gérer et surtout pas nécessairement compatible avec l'application envisagée.

Là, pas grand chose à faire à part peut-être mettre un condensateur sur la sortie du joystick pour filtrer un peu le bruit. Il ne faut pas se leurrer, le codeur Analogique-Numérique des cartes Arduino n'a pas des performances Hi-Fi. Il donne un résultat sur 10 bits mais avec 2 bits de bruit environ. Comme en plus tu convertis une valeur entre 0-1023 vers une valeur 650-2350 tu amplifies encore un peu plus le bruit.
Éventuellement, tu pourrais faire un filtrage numérique mais le système sera un peu moins réactif aux mouvements du joystick.

Pour un filtrage numérique simple, tu peux faire:

void loop() {

   static float joyval = 0;
   // 0 ≤ k ≤ 1 plus k est petit plus le bruit est atténué mais moins le système sera réactif, si k = 1 il n'y a aucun filtrage
  float k = 0.7; 

  joyval = (1.0 - k) * joyval + k * analogRead(joystick_XPin);
  int x_data = (int) joyval;
   
// la suite du code ne change pas

Là, 2 possibilités:

  • les servos ne couvrent pas 180°. Ça arrive...
  • tu n'as pas les bonnes valeurs de MIN_PULSE_WIDTH et MAX_PULSE_WIDTH qu'il faut déterminer empiriquement et éventuellement pour chaque servo.

Bonjour,

Après avoir stoppé mon projet pendant 2 mois, j'ai plus de temps maintenant.
J'ai donc réussi à faire le code que je voulais mais j'ai un léger soucis. Les moteurs sont assez lent et j'aimerais juste qu'ils soient un peu plus rapide.

vidéo du fonctionnement actuel : https://youtube.com/shorts/kJqx2Gxs9Mg?feature=share

Voici mon code actuel : (je sais qu'il peut être factorisé mais ce n'est pas mon principal problème)

// Projet Bras robot

// Inclusion des bibliothèques
#include "HCPCA9685.h"
#include <AccelStepper.h>

#define I2CAdd 0x40  // Adresse I2C du module PCA9685

#define JOYSTICK_THRESHOLD 50  // Ajuster la sensibilité du joystick

// Définir les broches pour chaque bouton, le joystick et le moteur pas à pas
const int button1Pin = 2;
const int button2Pin = 3;
const int button3Pin = 4;
const int button4Pin = 5;
const int button5Pin = 6;
// const int buttonResetPin = 11; // Bouton possible afin de définir la position de départ du bras

const int joystick_XPin = A0;
const int buttonJoy = 7;

// suivre l'ordre du DRV8825
const int DIR_PIN = 8;
const int STEP_PIN = 9;
// #define STEP_PIN 8
// #define DIR_PIN 9

// Variables pour stocker l'état des boutons
bool button1State = false;
bool button2State = false;
bool button3State = false;
bool button4State = false;
bool button5State = false;
// bool buttonResetState = false;
bool buttonJoyState = false;

// Variables pour stocker la position de chaque servo
int Servo1Position;
int Servo2Position;
int Servo3Position;
int Servo4Position;
int Servo5Position;

HCPCA9685 HCPCA9685(I2CAdd);  // Création d'une instance de la classe HCPCA9685 avec l'adresse I2C

AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);  // Création d'une instance de la classe AccelStepper

void setup() {
  // Initialiser les broches des boutons comme entrées avec résistances pull-up
  pinMode(button1Pin, INPUT_PULLUP);
  pinMode(button2Pin, INPUT_PULLUP);
  pinMode(button3Pin, INPUT_PULLUP);
  pinMode(button4Pin, INPUT_PULLUP);
  pinMode(button5Pin, INPUT_PULLUP);
  // pinMode(buttonResetPin, INPUT_PULLUP);
  pinMode(buttonJoy, INPUT_PULLUP);

  HCPCA9685.Init(SERVO_MODE);  // Initialiser le module PCA9685 en mode servo
  HCPCA9685.Sleep(false);      // Désactiver le mode veille 

  // Initialiser les positions des servos
  Servo1Position = 250;
  Servo2Position = 250;
  Servo3Position = 250;
  Servo4Position = 250;
  Servo5Position = 250;

  // Déplacer les servos à la position centrale
  HCPCA9685.Servo(1, Servo1Position);  // Bouger le servo 1 à la position centrale
  HCPCA9685.Servo(2, Servo2Position);  // Bouger le servo 2 à la position centrale
  HCPCA9685.Servo(3, Servo3Position);  // Bouger le servo 3 à la position centrale
  HCPCA9685.Servo(4, Servo4Position);  // Bouger le servo 4 à la position centrale
  HCPCA9685.Servo(5, Servo5Position);  // Bouger le servo 5 à la position centrale

  // Réglage des broches pour le moteur pas à pas
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);

  // Réglage des paramètres du moteur pas à pas
  stepper.setMaxSpeed(1000);
  stepper.setAcceleration(500);

  // Initialiser la communication série
  Serial.begin(9600);
}

void loop() {

  int joystickValue = analogRead(joystick_XPin);  // Lire la valeur du joystick

  // Lire l'état des boutons (LOW signifie appuyé)
  bool button1Press = !digitalRead(button1Pin);
  bool button2Press = !digitalRead(button2Pin);
  bool button3Press = !digitalRead(button3Pin);
  bool button4Press = !digitalRead(button4Pin);
  bool button5Press = !digitalRead(button5Pin);
  // bool buttonResetPress = !digitalRead(buttonResetPin);
  bool buttonJoyPress = !digitalRead(buttonJoy);

  // Mettre à jour les états des boutons
  if (button1Press) {
    button1State = true;
    button2State = false;
    button3State = false;
    button4State = false;
    button5State = false;
    // buttonResetState = false;
    buttonJoyState = false;
  } else if (button2Press) {
    button1State = false;
    button2State = true;
    button3State = false;
    button4State = false;
    button5State = false;
    // buttonResetState = false;
    buttonJoyState = false;
  } else if (button3Press) {
    button1State = false;
    button2State = false;
    button3State = true;
    button4State = false;
    button5State = false;
    // buttonResetState = false;
    buttonJoyState = false;
  } else if (button4Press) {
    button1State = false;
    button2State = false;
    button3State = false;
    button4State = true;
    button5State = false;
    // buttonResetState = false;
    buttonJoyState = false;
  } else if (button5Press) {
    button1State = false;
    button2State = false;
    button3State = false;
    button4State = false;
    button5State = true;
    // buttonResetState = false;
    buttonJoyState = false;
  }  // else if (buttonResetPress) {
     // button1State = false;
     // button2State = false;
     // button3State = false;
     // button4State = false;
     // button5State = false;
     // buttonResetState = true;
     // buttonJoyState = false;
  else if (buttonJoyPress) {
    button1State = false;
    button2State = false;
    button3State = false;
    button4State = false;
    button5State = false;
    // buttonResetState = false;
    buttonJoyState = true;
  }

  delay(50);


  // Actionnement des moteurs en fonction de l'état des boutons

  // Bouton 1
  if (button1State) {
    // Déplacer le servo 0
    if (joystickValue > 800) {
      if (Servo1Position < 420) {  // Vérifier si la position du servo est inférieure à 420 (max)
        Servo1Position++;          // Incrémenter la position du servo
      }
    }
    delay(10);
    HCPCA9685.Servo(1, Servo1Position);  // Déplacer le servo 1 à la position actuelle

    if (joystickValue < 300) {
      if (Servo1Position > 1) {
        Servo1Position--;
      }
    }
    delay(10);
    HCPCA9685.Servo(1, Servo1Position);
  }

  // Bouton 2
  if (button2State) {
    // Déplacer le servo 1
    if (joystickValue > 800) {
      if (Servo2Position < 420) {  
        Servo2Position++;          
      }
    }
    delay(10);
    HCPCA9685.Servo(2, Servo2Position);  

    if (joystickValue < 300) {
      if (Servo2Position > 1) {
        Servo2Position--;
      }
    }
    delay(10);
    HCPCA9685.Servo(2, Servo2Position);
  }

  // Bouton 3
  if (button3State) {
    // Déplacer le servo 2
    if (joystickValue > 800) {
      if (Servo3Position < 420) {  
        Servo3Position++;          
      }
    }
    delay(10);
    HCPCA9685.Servo(3, Servo3Position);  

    if (joystickValue < 300) {
      if (Servo3Position > 1) {
        Servo3Position--;
      }
    }
    delay(10);
    HCPCA9685.Servo(3, Servo3Position);
  }

  // Bouton 4
  if (button4State) {
    // Déplacer le servo 3
    if (joystickValue > 800) {
      if (Servo4Position < 420) {  
        Servo4Position++;          
      }
    }
    delay(10);
    HCPCA9685.Servo(4, Servo4Position);  

    if (joystickValue < 300) {
      if (Servo4Position > 1) {
        Servo4Position--;
      }
    }
    delay(10);
    HCPCA9685.Servo(4, Servo4Position);
  }

  // Bouton 5
  if (button5State) {
    // Déplacer le servo 4
    if (joystickValue > 800) {
      if (Servo5Position < 420) {  
        Servo5Position++;          
      }
    }
    delay(10);
    HCPCA9685.Servo(5, Servo5Position);  

    if (joystickValue < 300) {
      if (Servo5Position > 1) {
        Servo5Position--;
      }
    }
    delay(10);
    HCPCA9685.Servo(5, Servo5Position);
  }


  // Bouton Reset
  // if (buttonResetState) {
  //    delay(500);
  //   Servo0Position = 250;
  //   Servo1Position = 250;
  //   Servo2Position = 250;
  //   Servo3Position = 250;
  //   Servo4Position = 250;
  //   Servo5Position = 250;

  //   HCPCA9685.Servo(0, Servo0Position);
  //   HCPCA9685.Servo(1, Servo1Position);
  //   HCPCA9685.Servo(2, Servo2Position);
  //   HCPCA9685.Servo(3, Servo3Position);
  //   HCPCA9685.Servo(4, Servo4Position);
  //   HCPCA9685.Servo(5, Servo5Position);
  // }


  // Bouton Joystick
  if (buttonJoyState) {
    // Déplacer le moteur pas à pas
    if (joystickValue < 512 - JOYSTICK_THRESHOLD) {
      stepper.setSpeed(500);  

    } else if (joystickValue > 512 + JOYSTICK_THRESHOLD) {
      stepper.setSpeed(-500); 

    } else {
      stepper.setSpeed(0);  
    }

    // Faire tourner le moteur pas à pas
    stepper.runSpeed();

    // Délai pour contrôler la vitesse de rotation
    delay(5);
  }
}

Bonjour jean_pascal

Tu devrais supprimer cette ligne;
delay(50);
A l'oscillo, les pas du moteur sont, avec:

et sans:

Ne pas oublier, delay() est bloquant, y compris pour un moteur.

Cordialement
jpbbricole

Salut jpbbricole,

Merci beaucoup c'est top !

:blush:

Bonne continuation!

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.