IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Switch case et moteur pas a pas


Sujet :

Arduino

  1. #1
    Nouveau Candidat au Club
    Homme Profil pro
    elctricien interim
    Inscrit en
    Décembre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vaucluse (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : elctricien interim

    Informations forums :
    Inscription : Décembre 2019
    Messages : 5
    Points : 1
    Points
    1
    Par défaut Switch case et moteur pas a pas
    Bonjour à tous ,
    cela fait quelques mois que je cherche à faire fonctionner un moteur pas à pas avec plusieurs boutons .
    Mes recherches m'ont mener au switch case et la librairie one button ou j'ai pu trouver quelques explications et exemples remarquables .
    Pour commencer j'ai battis mon code en remplaçant simplement le moteur par une led en essayant de l'allumer et l’éteindre de différente façon avec plein de boutons . Et alléluia j'y arrive !

    Mais voilà en remplaçant la led par le moteur nema 17 et bien je n'y arrive pasde cette façon et je ne comprends pas pourquoi .
    Dans l'espoir que quelqu'un puisse m'éclairer je vais vous montrer le code simplifier c'est a dire avec un bouton marche et un arrêt qui me permettent d'allumer et éteindre la LED ainsi que le bout de code pour mettre en marche le moteur .

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    #include <OneButton.h>
    #include <AccelStepper.h>
     
    const int  buttonPin0 = A0; // mon bouton est sur la pin A0
    OneButton button0(buttonPin0, true); // true pour le mettre en INPUT_PULLUP
     
     
     
    const int  buttonPin4 = A4; // mon bouton est sur la pin A4
    OneButton button4(buttonPin4, true); // true pour le mettre en INPUT_PULLUP
     
    AccelStepper stepper (1, 8, 4);
     
    // la pins utilisées pour la LED
    const int PinLedVerte = 11;
     
    // Etats possible du système ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
    enum {ETAT_STOP, ETAT_MAVPV} EtatLedVerte;
     
     
     
     
     
    void Top () { // Ce qui me permet de faire bouger mon moteur
     
      stepper.setMaxSpeed(4000);
      stepper.setSpeed(1000);
      stepper.runSpeed();
    }
     
     
     
     
    void arret()// Ce qui initialise ma variable sur ETAT_STOP;
    {
      digitalWrite(PinLedVerte,  LOW);
      EtatLedVerte = ETAT_STOP;
    }
     
     
     
    void simpleclick0()//marche avant petite vitesse
    {
      switch (EtatLedVerte) {
        case ETAT_STOP: // on était a arret et on a un appui, on allume la verte
          digitalWrite(PinLedVerte, HIGH); // LED verte alimentée
     
          EtatLedVerte = ETAT_MAVPV; // on note le nouvel état de notre système
          if (ETAT_MAVPV == 1) {
            Top ();
          }
     
          break;
      }
    }
     
     
     
     
    void simpleclick4() // Bouton arret
    {
      switch (EtatLedVerte) {
        case ETAT_MAVPV:
          arret();// 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
      arret();
     
      // On attache la fonction simpleClick() comme callBack
      button0.attachClick(simpleclick0);
     
      button4.attachClick(simpleclick4);
    }
     
     
    void loop() {
      // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
      button0.tick();
      button4.tick();
    }

  2. #2
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 809
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 809
    Points : 5 665
    Points
    5 665
    Par défaut
    il y a un souci au moins à ce niveau là:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
          if (ETAT_MAVPV == 1) {
            Top();
          }
    vous ne voulez sans doute pas comparer la valeur de la constante de l'enum.. mais bon, comme cette constante vaut 1, le test est toujours vrai et donc Top() toujours appelé

    sinon votre code est un peu cryptique, utilisez des noms de variables parlants... Par exemple on comprend bien ce que ETAT_STOP veut dire dans
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    enum {ETAT_STOP, ETAT_MAVPV} EtatLedVerte;
    mais ETAT_MAVPV c'est un peu du chinois...

    Pourquoi appeler vos boutons 1 et 4... on s'en fiche des pins sur lesquels ils sont connectés et ça pourrait changer... donnez leur un nom parlant, idem pour les callbacks... Et en général on essaye d'avoir des noms de variables qui commencent par une minuscule et chaque nouveau mot dans le nom démarre ensuite par une majuscule (on appelle cela le camelCase), par ex on écrit plutôt pinLedVerte au lieu de PinLedVerte (ou alors quand on veut montrer que c'est une constante parfois on met tout en majuscule). C'est juste une histoire de convention mais essayez de garder une cohérence dans les noms de vos variables, ça fait plus propre

    en nettoyant donc un peu le code ça donne cela
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    #include <OneButton.h>
    #include <AccelStepper.h>
     
    const byte pinBoutonMarche = A0; // mon bouton est sur la pin A0
    OneButton boutonMarche(pinBoutonMarche, true); // true pour le mettre en INPUT_PULLUP
     
    const byte pinBoutonArret = A4; // mon bouton est sur la pin A4
    OneButton boutonArret(pinBoutonArret, true); // true pour le mettre en INPUT_PULLUP
     
    AccelStepper moteurPaP (1, 8, 4);
     
    // la pins utilisées pour la LED
    const int pinLedVerte = 11;
     
    // Etats possible du système ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
    enum {ETAT_STOP, ETAT_MAVPV} EtatLedVerte;
     
     
    // Ce qui me permet de faire bouger mon moteur
    void Top()
    {
      moteurPaP.setMaxSpeed(4000);
      moteurPaP.setSpeed(1000);
      moteurPaP.runSpeed();
    }
     
    // Ce qui initialise ma variable sur ETAT_STOP;
    void arret()
    {
      digitalWrite(pinLedVerte, LOW);
      EtatLedVerte = ETAT_STOP;
    }
     
     
    // Callback --> marche avant petite vitesse
    void clickMarche()
    {
      switch (EtatLedVerte) {
        case ETAT_STOP: // on était a arret et on a un appui, on allume la verte
          digitalWrite(pinLedVerte, HIGH); // LED verte alimentée
          EtatLedVerte = ETAT_MAVPV; // on note le nouvel état de notre système
          Top();
          break;
        default: break; // on ne fait rien dans les autres cas
      }
    }
     
     
    // Callback Bouton arret
    void clickArret()
    {
      switch (EtatLedVerte) {
        case ETAT_MAVPV:
          arret();// retour a l'etat initial
          Serial.println(EtatLedVerte);
          break;
        default: break; // on ne fait rien dans les autres cas
      }
    }
     
     
    // On initialise notre système dans le setup
    void setup()
    {
      Serial.begin(115200);
      pinMode (pinLedVerte, OUTPUT);
     
      //conditions Initiales
      arret();
     
      // On attache la fonction simpleClick() comme callBack
      boutonMarche.attachClick(clickMarche);
      boutonArret.attachClick(clickArret);
    }
     
     
    void loop() {
      // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
      boutonMarche.tick();
      boutonArret.tick();
    }
    mais comme vous ne donnez pas d'objectif de position à votre moteur, il n'y a pas de raison qu'il bouge... et même avec un objectif il faut appeler constamment run() ou runSpeed() dès qu'un mouvement en en cours --> donc à mettre dans la loop, séparément des callbacks.

  3. #3
    Nouveau Candidat au Club
    Homme Profil pro
    elctricien interim
    Inscrit en
    Décembre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vaucluse (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : elctricien interim

    Informations forums :
    Inscription : Décembre 2019
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Merci pour les réponses; c'est vrai que c'est plus parlant et clair de nommé ses boutons et callback, mais ce qui me parait pas évident sur la forme , pour exemple mon bouton marche qui s’appelle en fait "BoutonMarcheAvantPetiteVitesse" . Il est long parce que mon code n'est pas complet ici .
    Je n'ai pas mis la marche arrière , la moyenne vitesse et la grande ect .....
    Malgres tout , es ce pas trop ? J'ai modifier mon code si dessous . Vous pouvez me dire ?

    Pour le const byte au lieu de const int j'ai trouvé . C'est pour allégé .

    Mais cette ligne , c'est pas clair : default: break; // on ne fait rien dans les autres cas

    Pour ce code avec ses 2 boutons , mon objectif c'est que le moteur tourne ( a la vitesse et sens de rotation comme il est paramétré sur le code) quand j'appuis sur marche et qu'il s’arrête quand j'appuis sur arrêt .Je me suis dit que si j'arrive à faire cela je vais trouver pour faire changer la vitesse et le sens pour les futurs boutons et même pour un , il me faudra compter les pas .
    Bon une chose après l'autre . Demain je vais essayé de comprendre et de le faire marcher ce code .




    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    #include <OneButton.h>
    #include <AccelStepper.h>
     
     
     
    const byte pinBoutonMarcheAvantPetiteVitesse = A0; // mon bouton est sur la pin A0
    OneButton BoutonMarcheAvantPetiteVitesse(pinBoutonMarcheAvantPetiteVitesse, true); // true pour le mettre en INPUT_PULLUP
     
    const byte pinBoutonArret = A4; // mon bouton est sur la pin A4
    OneButton boutonArret(pinBoutonArret, true); // true pour le mettre en INPUT_PULLUP
     
    AccelStepper moteurPaP(1, 8, 4);
     
     
     
    // la pins utilisées pour la LED
    const int PinLedVerte = 11;
     
    // Etats possible du système ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
    enum {ETAT_STOP, ETAT_MAVPV} EtatLedVerte;
     
     
     
     
     
    void Top () { // Ce qui me permet de faire tourner mon moteur
     
      moteurPaP.setMaxSpeed(4000);
      moteurPaP.setSpeed(1000);
      moteurPaP.runSpeed();
    }
     
     
     
     
    void arret()// Ce qui initialise ma variable sur ETAT_STOP;
    {
      digitalWrite(PinLedVerte,  LOW);
      EtatLedVerte = ETAT_STOP;
    }
     
    void clickMarcheAvantPetiteVitesse()//marche avant petite vitesse
    {
      switch (EtatLedVerte) {
        case ETAT_STOP: // on était a arret et on a un appui, on allume la verte
          digitalWrite(PinLedVerte, HIGH); // LED verte alimentée
     
          EtatLedVerte = ETAT_MAVPV; // on note le nouvel état de notre système
          Top ();
          break;
        default: break; // on ne fait rien dans les autres cas
      }
    }
     
     
     
    void clickArret()// Callback Bouton arret
    {
      switch (EtatLedVerte) {
        case ETAT_MAVPV:
          arret();// retour a l'etat initial
          Serial.println(EtatLedVerte);
          break;
        default: break; // on ne fait rien dans les autres cas
      }
    }
     
     
    // On initialise notre système dans le setup
    void setup() {
     
      Serial.begin(9600);
     
      pinMode (PinLedVerte, OUTPUT);
     
      //conditions Initiales
      arret();
     
      // On attache la fonction simpleClick() comme callBack
      BoutonMarcheAvantPetiteVitesse.attachClick(clickMarcheAvantPetiteVitesse);
      boutonArret.attachClick(clickArret);
    }
     
     
    void loop() {
      // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
      BoutonMarcheAvantPetiteVitesse.tick();
      boutonArret.tick();
    }

  4. #4
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 809
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 809
    Points : 5 665
    Points
    5 665
    Par défaut
    OK "BoutonMarcheAvantPetiteVitesse" c'est un peu long à taper (une fois compilé ça ne prend pas plus de place cela dit) - un petit commentaire aiderait alors à comprendre

    Pour le const byte au lieu de const int j'ai trouvé . C'est pour allégé .
    C'est surtout parce qu'un byte ne prend qu'un octet alors qu'un int va en prendre 2 (ou 4 sur ESP/MKR)... (même si l'optimiseur va virer le byte pour remplacer directement dans le binaire)


    Mais cette ligne , c'est pas clair : default: break; // on ne fait rien dans les autres cas
    dans un case c'est bien de montrer qu'on a prévu tous les cas. ça rassure le compilateur et celui qui relira le code --> en pratique l'optimiseur va virer cette partie qui ne sert à rien.

    Un moteur pas à pas comme son nom l'indique va faire des pas. Si vous ne lui dites pas combien de pas faire, vous aurez beau avoir défini une vitesse, une accélération etc, il ne bougera pas. Regardez les exemples AccelStepper pour voir comment on donne une position absolue à rejoindre ou un nombre de pas relatif à effectuer. Et une fois que c'est fait, comme je l'ai dit ci dessous, il faut appeler SOUVENT run() ou runSpeed() qui ne font qu'un pas par appel au plus, au moment opportun.

  5. #5
    Nouveau Candidat au Club
    Homme Profil pro
    elctricien interim
    Inscrit en
    Décembre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vaucluse (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : elctricien interim

    Informations forums :
    Inscription : Décembre 2019
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Je pense utiliser cet exemple de accel stepper ci dessous parce qu'il est simple il faut le dire . Et probablement un autre exemple parce à un moment suivant le bouton, il me faudra compter les pas .
    Je trouve ça très complexe . Ça va fait deux heures pour pas dire plus que je tourne et je vois pas comment mettre le run speed dans le loop et qu'il soit déclencher par la variable EtatLedVerte = ETAT_MAVPV de mon switch case .
    Bon je vais prendre l'air parce que je suis trés embrouillé .

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // ConstantSpeed.pde
    // -*- mode: C++ -*-
    //
    // Shows how to run AccelStepper in the simplest,
    // fixed speed mode with no accelerations
    /// \author  Mike McCauley (mikem@airspayce.com)
    // Copyright (C) 2009 Mike McCauley
    // $Id: ConstantSpeed.pde,v 1.1 2011/01/05 01:51:01 mikem Exp mikem $
    #include <AccelStepper.h>
    AccelStepper stepper; // Defaults to AccelStepper::FULL4WIRE (4 pins) on 2, 3, 4, 5
    void setup()
    {  
       stepper.setMaxSpeed(1000);
       stepper.setSpeed(50);        
    }
    void loop()
    {  
       stepper.runSpeed();

  6. #6
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 809
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 809
    Points : 5 665
    Points
    5 665
    Par défaut
    Citation Envoyé par ylfylf Voir le message
    Bon je vais prendre l'air parce que je suis trés embrouillé .
    Restez confiné c'est la consigne si vous n'avez pas vraiment besoin de sortir. (bon si vous avez un Jardin ou un balcon ça va)

    vous pourriez déclarer une variable de type booléen globale que vous mettez à vrai quand le moteur doit être en marche (quels que soient les paramètres ou la consigne qui auront été donnés lors d'une transition d'état) et ensuite tester cela dans la loop après avoir testé vos boutons.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    bool moteurEnMarche = false; // par défaut à l'arrêt. état maintenu dans les callbacks
    ...
    void loop() {
      // On vérifie l'état des boutons, ce qui déclenche l'appel des callBacks si besoin
      BoutonMarcheAvantPetiteVitesse.tick();
      boutonArret.tick();
      // si on doit bouger, on fait un pas
      if (moteurEnMarche) moteurPaP.runSpeed();
    }

  7. #7
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 015
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 015
    Points : 2 350
    Points
    2 350
    Par défaut
    Bonjour ylfylf et Jay M

    Faire tourner un moteur pas à pas (MPAP) en continu, commandé par un bouton ON et OFF c'est pas vraiment sa vocation, d'où les problèmes rencontrés par @ylfylf.
    Normalement, le MPAP on "l'envoie" à une position, puis à une autre et ainsi de suite.
    La commande moteurPaP.runSpeed(); doît être répétée en continu pour un fonctionnement "pseudo" continu, à voire les explications ici et l'exemple de la bibliothèque AccelStepper ConstantSpeed.
    Quels carte Arduino et quel contrôleur de MPAP utilises-tu?

    D'autre part, je ne comprend pas l'usage Switch case alors qu'un if avec un éventuel else sont suffisants et plus simples. J'ai, ainsi, retouché ton programme et le MPAP fonctionne, c'est testé aven un contrôleur A4988. J'ai mis quelques Serial.println pour mieux voire "vivre" ton programme, à virer après!
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    // https://www.pjrc.com/teensy/td_libs_AccelStepper.html
    #include <OneButton.h>
    #include <AccelStepper.h>
     
     
     
    const byte pinBoutonMarcheAvantPetiteVitesse = A0; // mon bouton est sur la pin A0
    OneButton BoutonMarcheAvantPetiteVitesse(pinBoutonMarcheAvantPetiteVitesse, true); // true pour le mettre en INPUT_PULLUP
     
    const byte pinBoutonArret = A4; // mon bouton est sur la pin A4
    OneButton boutonArret(pinBoutonArret, true); // true pour le mettre en INPUT_PULLUP
     
    AccelStepper moteurPaP(1, 8, 4);  // Mode, Step, Dir
     
     
     
    // la pins utilisées pour la LED
    const int PinLedVerte = 11;
     
    // Etats possible du système ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
    enum {ETAT_STOP, ETAT_MAVPV} EtatLedVerte;
     
    void moteurDemarrage () { // Ce qui me permet de faire tourner mon moteur
     
    	digitalWrite(PinLedVerte,  HIGH);
    	EtatLedVerte = ETAT_MAVPV;
    }
     
    void moteurArret()// Ce qui initialise ma variable sur ETAT_STOP;
    {
    	digitalWrite(PinLedVerte,  LOW);
    	EtatLedVerte = ETAT_STOP;
    }
     
    void clickMarcheAvantPetiteVitesse()//marche avant petite vitesse
    {
    	Serial.println("clickMarcheAvantPetiteVitesse");
    	if (EtatLedVerte != ETAT_MAVPV)
    	{
    		Serial.println("\tMoteur démarre");
    		moteurDemarrage();
    	} 
    	else
    	{
    		Serial.println("\tMoteur déjà en marche");
    	}
    }
     
     
     
    void clickArret()// Callback Bouton arret
    {
    	Serial.println("clickArret");
    	if (EtatLedVerte != ETAT_STOP)
    	{
    		Serial.println("\tMoteur Stop");
    		moteurArret();
    	}
    	else
    	{
    		Serial.println("\tMoteur déjà arrêté");
    	}
    }
     
     
    // On initialise notre système dans le setup
    void setup() {
     
    	Serial.begin(9600);
     
    	pinMode (PinLedVerte, OUTPUT);
     
    	moteurPaP.setMaxSpeed(4000);
    	moteurPaP.setSpeed(500);
     
    	//conditions Initiales
    	moteurArret();
     
    	// On attache la fonction simpleClick() comme callBack
    	BoutonMarcheAvantPetiteVitesse.attachClick(clickMarcheAvantPetiteVitesse);
    	boutonArret.attachClick(clickArret);
    }
     
     
    void loop() {
    	// On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
    	BoutonMarcheAvantPetiteVitesse.tick();
    	boutonArret.tick();
     
    	if (EtatLedVerte == ETAT_MAVPV)
    	{
    		moteurPaP.runSpeed();                    // Le moteur tourne
    	}
    }
    Pour ce qui est de l'exemple d'Accel stepper, n'oublies pas qu'il faut l'adapter à ta configuration:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    AccelStepper stepper(1, 8, 4); // Defaults to AccelStepper::FULL4WIRE (4 pins) on 2, 3, 4, 5
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    // ConstantSpeed.pde
    // -*- mode: C++ -*-
    //
    // Shows how to run AccelStepper in the simplest,
    // fixed speed mode with no accelerations
    /// \author  Mike McCauley (mikem@airspayce.com)
    // Copyright (C) 2009 Mike McCauley
    // $Id: ConstantSpeed.pde,v 1.1 2011/01/05 01:51:01 mikem Exp mikem $
    #include <AccelStepper.h>
    AccelStepper stepper(1, 8, 4); // Defaults to AccelStepper::FULL4WIRE (4 pins) on 2, 3, 4, 5
    void setup()
    {  
       stepper.setMaxSpeed(1000);
       stepper.setSpeed(50);        
    }
    void loop()
    {  
       stepper.runSpeed();
    }
    Bonne après-midi
    Cordialement
    jpbbricole

  8. #8
    Nouveau Candidat au Club
    Homme Profil pro
    elctricien interim
    Inscrit en
    Décembre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vaucluse (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : elctricien interim

    Informations forums :
    Inscription : Décembre 2019
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Bonjour Mr jpbbricole , pour tout vous dire , Mr Jay à tenté de me le faire comprendre dés le début mais je suis un peu tétu.
    J’espère vraiment trouver la solution et vos commentaires m'aident beaucoup .
    Je n'ai que l'envie de bien faire et mes choix dans l’immédiat c'est d'avoir un accès direct aux boutons pour connaitre les meilleurs réglages et aussi faire des choix mécaniques . Cela devrai aussi me permettre de mieux adapter mes prochains codes et apprendre à coder en restant proche de mes besoins . Le switch case en fait partie .
    C'est fou les possibilités avec arduino , c'est trop bien ! mais je gère pas .

    Il me faut mettre le moteur en route avec le switch case , puis rajouter quelques boutons de façon cohérentes . Si j'arrive à cela , je serai mieux ou je vais .

    J'ai suivi au mieux les explications , mais j'ai pas tout compris . Mon code est modifié .Mon moteur ne s'arrete pas mais il se met en marche .

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    #include <OneButton.h>
    #include <AccelStepper.h>
     
     
     
    const byte pinBoutonMarcheAvantPV = A0; // mon bouton est sur la pin A0 .PV pour dire petite vitesse
    OneButton BoutonMarcheAvantPV(pinBoutonMarcheAvantPV, true); // true pour le mettre en INPUT_PULLUP
     
    const byte pinBoutonArret = A4; // mon bouton est sur la pin A4
    OneButton boutonArret(pinBoutonArret, true); // true pour le mettre en INPUT_PULLUP
     
    bool moteurMarcheAvantPV = false;
     
     
    AccelStepper moteurPaP(1, 8, 4);
     
     
    // Etats possible du système ainsi qu'une variable EtatLedVerte prenant une de ces valeurs
    enum {ETAT_STOP, ETAT_MAVPV} etatMoteur; // MAVPV veut dire marche avant petite vitesse
     
     
     
    void Top () { // Ce qui me permet de faire tourner mon moteur
     
      moteurPaP.setMaxSpeed(6000);
      moteurPaP.setSpeed(6000);
    }
     
     
    void arret()// Ce qui initialise ma variable sur ETAT_STOP;
    {
      moteurPaP.stop();
      moteurMarcheAvantPV = false;
      etatMoteur = ETAT_STOP;
    }
     
    void clickMarcheAvantPV()//marche avant petite vitesse
    {
      switch (etatMoteur) {
        case ETAT_STOP: // on était a arret et on a un appui, on met en marche avant PV (petite vitesse)
          etatMoteur = ETAT_MAVPV; // on note le nouvel état de notre système
          moteurMarcheAvantPV = true ;
          Top();
          break;
        default: break; // on ne fait rien dans les autres cas
      }
    }
     
    void clickArret()// Callback Bouton arret
    {
      switch (etatMoteur) {
        case ETAT_MAVPV:// on était en marche et on a un appui
          void arret();// retour a l'etat initial
          etatMoteur = ETAT_STOP;
          moteurMarcheAvantPV = false;
          break;
        default: break; // on ne fait rien dans les autres cas
      }
    }
     
     
    // On initialise notre système dans le setup
    void setup() {
     
      Serial.begin(9600);
     
      //conditions Initiales
      arret();
     
      // On attache la fonction simpleClick() comme callBack
      BoutonMarcheAvantPV.attachClick(clickMarcheAvantPV); // PV pour dire petite vitesse
      boutonArret.attachClick(clickArret);
    }
     
     
    void loop() {
      // On vérifie l'état des boutons, ce qui déclenche l'appel de la fonction callBack si nécessaire
      BoutonMarcheAvantPV.tick(); // PV pour dire petite vitesse
      boutonArret.tick();
     
      if (moteurMarcheAvantPV = true ) {
        moteurPaP.runSpeed();
      }
    }

  9. #9
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 809
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 809
    Points : 5 665
    Points
    5 665
    Par défaut
    Salut... je ne vois toujours pas dans votre dernier code un objectif de nombre de pas à effectuer / position à atteindre pour votre moteur...

  10. #10
    Membre émérite
    Avatar de jpbbricole
    Homme Profil pro
    Retraité des réseaux informatiques
    Inscrit en
    Février 2013
    Messages
    1 015
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Retraité des réseaux informatiques
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2013
    Messages : 1 015
    Points : 2 350
    Points
    2 350
    Par défaut
    Bonjour ylfylf
    Citation Envoyé par ylfylf Voir le message
    Mr Jay à tenté de me le faire comprendre dés le début mais je suis un peu tétu.
    Et il avait raison, on peut être têtu, c'est une qualité, mais pas entêté, du moins pas trop longtemps.
    Utiliser switch case quand c'est nécessaire, quand il y a plusieurs choix, OK, sinon if et else, c'est mieux.

    Citation Envoyé par ylfylf Voir le message
    Mon moteur ne s'arrete pas mais il se met en marche
    L'erreur est ici:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    	if (moteurMarcheAvantPV == true ) {
    		moteurPaP.runSpeed();
    	}
    A+
    Cordialement
    jpbbricole

  11. #11
    Nouveau Candidat au Club
    Homme Profil pro
    elctricien interim
    Inscrit en
    Décembre 2019
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vaucluse (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : elctricien interim

    Informations forums :
    Inscription : Décembre 2019
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Mon code actuel me permet de mettre en route le moteur mais pas de l’arrêter .

    Il y a pas de soucis pour rajouter des boutons , mais pas tout de suite . Comprendre déjà avec deux boutons c'est pas simple pour moi . Vraiment désolé . Je vois bien que je pose mal mes questions.

    Je vais essayer différemment :

    1* Peut on dans un premier temps faire tourner le moteur PaP quand j' appuis sur le bouton marche et l’arrêter quand j' appuis sur le bouton stop . Mon matériel est un moteur nema 17 , un pilote DM 332T et une carte uno ?

    2* Une fois arrêter est il possible de le faire repartir dans l'autre sens avec un bouton supplémentaire et de l'arreter avec le bouton arrêt ?

    3* Une fois arrêter à nouveau , est il possible de le mettre en marche dans une vitesse et un sens différent avec un bouton supplémentaire et de l’arrêter toujours avec le même bouton arrêt ?

    4* Une fois arrêter à nouveau , est il possible de le mettre en marche dans une vitesse et un sens toujours différent avec un bouton supplémentaire et de l’arrêter toujours avec le même bouton arrêt ?

    Pourquoi ces questions parce que je ne connais pas de combien de pas il me faut faire tourner le moteur dans un premier temps . Si il doit dans en premier tourner dans un sens et ensuite dans l'autre . Changer de vitesse . Il me faut le réaliser d'une façon manuelle dans un premier temps pour connaitre la séquence .

    C'est peut être plus compliqué que je ne pense ou peux être je ne peux pas avec le choix de matériel que j'ai fait tout simplement ?

  12. #12
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 809
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 809
    Points : 5 665
    Points
    5 665
    Par défaut
    C’est tout possible

    Faut juste le coder et donc avoir une bonne petite machine à états bien définie et changer d’état dans les callbacks des boutons

Discussions similaires

  1. switch case, include : ne fonctionne pas
    Par FraK dans le forum Langage
    Réponses: 13
    Dernier message: 02/07/2008, 11h50
  2. Piloter un moteur pas à pas
    Par moukah2 dans le forum Débuter
    Réponses: 4
    Dernier message: 02/02/2008, 11h36
  3. Switch Case joli ou pas ?
    Par gifffftane dans le forum Design Patterns
    Réponses: 3
    Dernier message: 09/08/2007, 12h09
  4. [Use case] extend ou pas
    Par *alexandre* dans le forum Cas d'utilisation
    Réponses: 2
    Dernier message: 04/03/2007, 21h48
  5. Réponses: 27
    Dernier message: 25/08/2004, 22h30

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo