Faire avancé un moteur pas a pas

Bonjour , j’utilise le code ci dessous pour faire fonctionner un moteur qui me fait avancé un petit chariot sur un guides linéaire open built .

Le principe de marche de ce code est j’appuis sur un BP le moteur démarre et s’arrête en rencontrant un fin de course . Ce qui marche très bien mais je voudrai l’améliorer .
L’idée c’est que une fois qu’il à rencontrer le fin de course je souhaiterai qu’il reparte pour faire un nombre de pas pré-déterminée . ( comme une mesure étalon )

j’ai essayé avec ce bout de code placé à la suite du delay ( vers le millieu du code )mais ca marche pas .

setup
stepper.setMaxSpeed(3000);
stepper.acceleration(230);
stepper.moveTo(30255);
loop
stepper.runSpeed();

En gardant cet exemple de petit code ,j’ai créer une autre condition du genre : if (FindecourseResetetat == HIGH) mais ca a pas marché puisque cette condition est déja utilisé .

Suivi d’un tas de formule différente mais … je trouve pas !

c’est pas si simple , vous avez une idée ?

#include <AccelStepper.h>
const int BpResetBroche = 12; // BP reset  PULL DOWN
const int FindecourseResetBroche = 11; // Fin de course PULL DOWN

const int LedPinBroche = 3;
int BpResetetat = 0;
int  FindecourseResetetat = 0;
int MarcheMoteur = 0;

AccelStepper stepper (1, 8, 4);






void Reset ()   // Remise à zéro
{
  stepper.setMaxSpeed(6000);
  stepper.setSpeed(-6000);
  stepper.runSpeed();

}




void setup()
{
  pinMode( FindecourseResetBroche, INPUT);
  pinMode( BpResetBroche, INPUT);
  pinMode( 3, OUTPUT);

  
}




void loop() {
  BpResetetat = digitalRead(12) ;
  FindecourseResetetat = digitalRead(11);

  if (BpResetetat == HIGH) // si le BP est appuyé la variable(marche moteur) = 1
  {
    MarcheMoteur = 1;
  }

                                     
  if (FindecourseResetetat == HIGH)  // si le fin de course est appuyé la variable (marche moteur)= 0

  {
    
    MarcheMoteur = 0;
    delay (3000);         //Pause après que le (FindecourseResetetat) passe à 0
   
  }

  if (MarcheMoteur == 1) 

  {
    Reset (); // met en marche le moteur  jusqu’à que le FindecourseResetetat ne l’arrête 
  }
 
if (MarcheMoteur == 0)
  {
    stepper.stop(); // arrete le moteur 

  }

}

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

vos événements seront les 2 boutons (le BP et le détecteur de fin de course), éventuellement le temps qui passe ou un nombre de steps

Apres la lecture du tuto sur la machine à état et surtout après la compréhension des différents code liés au switch, case , je retrouve dans ces trois codes du tuto un bouton pour plusieurs états de leds alors pour adapter le principe du switch case à ma machine , j’ai besoin de faire quelque ajustement pour comprendre les possibilités avec plus de boutons .

Donc je me suis imposé un petit exercice pour démarrer doucement avec 2 boutons et 1 led et déjà je bute sur mon codage .
le but étant d’allumer la led verte avec un bouton , puis de la faire clignoter avec un second appuis et de l’étendre avec un autre bouton .
Il me semble etre pas loin de la solution et pourtant ca marche pas !

// La librairie de gestion des boutons
#include <OneButton.h>

const int  buttonPin0 = A0; // notre bouton est sur la pin A0
OneButton button0(buttonPin0, true); // true pour le mettre en INPUT_PULLUP

const int  buttonPin1 = A1; // notre bouton est sur la pin A1
OneButton button1(buttonPin1, true); // true pour le mettre en INPUT_PULLUP
// les pins utilisées pour les LEDs


const int PinLedVerte = 11;
// la liste des états possible de notre système
// ainsi qu'une variable etatCourant prenant une de ces valeurs
enum {ETAT_ETEINT , ETAT_ALLUME , ETAT_CLIGNOTANT} EtatLedVerte;


void éteindre()
{
  digitalWrite(PinLedVerte,  LOW);


  EtatLedVerte = ETAT_ETEINT;
}

void simpleclick0()
{
  switch (EtatLedVerte) {
    case ETAT_ETEINT: // on était a arret et on a un appui, on allume la verte
      digitalWrite(PinLedVerte, HIGH); // LED verte alimentée
      EtatLedVerte = ETAT_ALLUME; // on note le nouvel état de notre système
      break;

      switch (EtatLedVerte)
      case ETAT_ALLUME: // la led est allumé et on a un appui, on fait clignoté la led verte
      digitalWrite(PinLedVerte, LOW);
      delay(500);
      digitalWrite(PinLedVerte, HIGH);
      delay(500);
      digitalWrite(PinLedVerte, LOW);
      delay(500);
      digitalWrite(PinLedVerte, HIGH);
      EtatLedVerte = ETAT_CLIGNOTANT; // nouvel état de notre système
      break;
  }
}

void simpleclick1()
{
  switch (EtatLedVerte) {
    case ETAT_CLIGNOTANT: // on avait la led verte allumée et on a un appui, on éteint la verte
      digitalWrite(PinLedVerte, LOW); // LED verte desalimentée
      éteindre();// on note le nouvel état de notre système
      break;
  }
}


void setup() {

  pinMode (PinLedVerte, OUTPUT);

  //conditions Initiales

  éteindre();

  // On attache la fonction simpleClick() comme callBack

  button0.attachClick(simpleclick0);

  // On attache la fonction simpleClick() comme callBack

  button1.attachClick(simpleclick1);

}

void loop() {


  // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire

  button0.tick();

  button1.tick();
  

}

Le principal problème : éteindre()

Pas de caractères accentués en C / C++.

Le deuxième problème :

void simpleclick0()
{
  switch (EtatLedVerte) {
    case ETAT_ETEINT: // on était a arret et on a un appui, on allume la verte
      Serial.println("ALLUME");
      digitalWrite(PinLedVerte, HIGH); // LED verte alimentée
      EtatLedVerte = ETAT_ALLUME; // on note le nouvel état de notre système
      break;

      switch (EtatLedVerte)    // A SUPPRIMER
      case ETAT_ALLUME: // la led est allumé et on a un appui, on fait clignoté la led verte

Pourquoi un deuxième case switch ?

A la question , pourquoi un deuxième case switch ? Parce que le tuto machine à état est présenté comme ça . Pas plus .
Effectivement je me suis trompré avec les accents, donc j 'ai modifier mon code en enlevant les caractères accentués mais j’arrive toujours pas à faire clignoté ma led . Ou je me trompe quelque part ,ou la solution du switch case ne me permet pas de la faire clignoté ( comme utilisé un délay à cet endroit du code ) ! Je me pose des questions ! c’est qu’un exemple mais j’aimerai bien savoir ?

// La librairie de gestion des boutons
#include <OneButton.h>

const int  buttonPin0 = A0; // notre bouton est sur la pin A0
OneButton button0(buttonPin0, true); // true pour le mettre en INPUT_PULLUP

const int  buttonPin1 = A1; // notre bouton est sur la pin A1
OneButton button1(buttonPin1, true); // true pour le mettre en INPUT_PULLUP
// les pins utilisées pour les LEDs


const int PinLedVerte = 11;
// la liste des états possible de notre système
// ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
enum {ETAT_ETEINT , ETAT_ALLUME , ETAT_CLIGNOTANT} EtatLedVerte;


void eteindre()
{
  digitalWrite(PinLedVerte,  LOW);


  EtatLedVerte = ETAT_ETEINT;
}

void simpleclick0()
{
  switch (EtatLedVerte) {
    case ETAT_ETEINT: // on était a arret et on a un appui, on allume la verte
    
      digitalWrite(PinLedVerte, HIGH); // LED verte alimentée
      Serial.println(EtatLedVerte);
      EtatLedVerte = ETAT_ALLUME; // on note le nouvel état de notre système
      Serial.println(EtatLedVerte);
      break;

      switch (EtatLedVerte)
      case ETAT_ALLUME: // la led est allumé et on a un appui, on fait clignoté la led verte
      digitalWrite(PinLedVerte, LOW);
      delay(500);
      digitalWrite(PinLedVerte, HIGH);
      delay(500);
      digitalWrite(PinLedVerte, LOW);
      delay(500);
      digitalWrite(PinLedVerte, HIGH);
      EtatLedVerte = ETAT_CLIGNOTANT; // nouvel état de notre système
      break;
  }
}

void simpleclick1()
{
  switch (EtatLedVerte) {
    case ETAT_CLIGNOTANT: // on avait la led verte allumée et on a un appui, on éteint la verte
      digitalWrite(PinLedVerte, LOW); // LED verte desalimentée
      eteindre();// on note le nouvel état de notre système
      break;
  }
}

// On initialise notre système dans le setup
// ------------------------------------------------------
void setup() {

  Serial.begin(9600);
  pinMode (PinLedVerte, OUTPUT);

  //conditions Initiales
  eteindre();

  // On attache la fonction simpleClick() comme callBack
  button0.attachClick(simpleclick0);
  // On attache la fonction simpleClick() comme callBack
  button1.attachClick(simpleclick1);
}

void loop() {
  // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
  button0.tick();
  button1.tick();
  

}

je me trompe encore . Le switch sert à rien .Il est pas noté dans l'exemple . Désolé . Vous avez résolu mon problème dès votre premier texto . Merci beaucoup

Il me semblait bien :slight_smile:

Il me viens une question sur la librairie one button qui est utilisé dans mon code . En restant dans mon switch case , parce que je l’utilise simplement dans mon code , si j’ai besoin d’allumer ma led verte juste quand j’appuis sur un autre bouton que j’ai appellé buttonPin2 dans mon code et quelle s’éteint quand je le relâche .

Es ce vraiment possible de le faire dans mon switch case .
Je me pose cette question parce que mes essais ne m’on pas permis de lire buttonPin2 avec digital read dans mon code .
Qui à un avis sur la question ? Je suis passé a cotés de quelque chose ?

Revoici le code comme exemple ci dessous :

// La librairie de gestion des boutons
#include <OneButton.h>

const int  buttonPin0 = A0; // notre bouton est sur la pin A0
OneButton button0(buttonPin0, true); // true pour le mettre en INPUT_PULLUP

const int  buttonPin1 = A1; // notre bouton est sur la pin A1
OneButton button1(buttonPin1, true); // true pour le mettre en INPUT_PULLUP
// les pins utilisées pour les LEDs

const int  buttonPin2 = A2; // notre bouton est sur la pin A2
OneButton button1(buttonPin1, true); // true pour le mettre en INPUT_PULLUP
// les pins utilisées pour les LEDs


const int PinLedVerte = 11;
// la liste des états possible de notre système
// ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
enum {ETAT_ETEINT , ETAT_ALLUME , ETAT_CLIGNOTANT,} EtatLedVerte;


void eteindre()
{
  digitalWrite(PinLedVerte,  LOW);


  EtatLedVerte = ETAT_ETEINT;
}

void simpleclick0()
{
  switch (EtatLedVerte) {
    case ETAT_ETEINT: // on était a arret et on a un appui, on allume la verte
    
      digitalWrite(PinLedVerte, HIGH); // LED verte alimentée
      Serial.println(EtatLedVerte);
      EtatLedVerte = ETAT_ALLUME; // on note le nouvel état de notre système
      Serial.println(EtatLedVerte);
      break;

      
      case ETAT_ALLUME: // la led est allumé et on a un appui, on fait clignoté la led verte
      digitalWrite(PinLedVerte, LOW);
      delay(500);
      digitalWrite(PinLedVerte, HIGH);
      delay(500);
      digitalWrite(PinLedVerte, LOW);
      delay(500);
      digitalWrite(PinLedVerte, HIGH);
      
      
       Serial.println(EtatLedVerte);
      EtatLedVerte = ETAT_CLIGNOTANT; // nouvel état de notre système
       Serial.println(EtatLedVerte);
      break;
      
      
  }
}

void simpleclick1()
{
  switch (EtatLedVerte) {
    case ETAT_CLIGNOTANT: // on avait la led verte allumée et on a un appui, on éteint la verte
      digitalWrite(PinLedVerte, LOW); // LED verte desalimentée
      eteindre();// retour a l'etat initial
       Serial.println(EtatLedVerte);
      break;
  }
}

// On initialise notre système dans le setup
// ------------------------------------------------------
void setup() {

  Serial.begin(9600);
  
  pinMode (PinLedVerte, OUTPUT);

  //conditions Initiales
  eteindre();

  // On attache la fonction simpleClick() comme callBack
  button0.attachClick(simpleclick0);
  // On attache la fonction simpleClick() comme callBack
  button1.attachClick(simpleclick1);
}

void loop() {
  // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
  button0.tick();
  button1.tick();


}

Il n'y a pas de raison pour que digitalRead() ne soit pas utilisable dans une fonction callback().

Réflexion faite, la librairie OneButton() appelle la callback Click() ou DoubleClick() après que le bouton ait été relâché.
Donc on peut dire que lire l'état du bouton dans la callback Click() ou DoubleClick() ne sert à rien.

Le seul cas où une callback est appelée pendant l'appui est LongPress.

Il faut prendre compte de cette transition possible dans la machine à etat, pas commencer à bidouiller un truc spaghetti dans un callback...