1. Ce site utilise des cookies. En continuant à utiliser ce site, vous acceptez l'utilisation des cookies. En savoir plus.

Outils Console moteur PAP

Discussion dans 'Arduino' créé par jpbbricole, 14 Juin 2016.

  1. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
    Console moteur PAP
    Bonjour à tous

    Au vu de l’usage fréquent de PAP dans ce forum, J’aimerai vous faire partager un utilitaire qui tourne dans un Arduino Nano (mais transférable dans un autre modèle).
    Le principe est, au moyen de quelques commandes, modifier les paramètres de l’interface du moteur et avec d’autres commandes, contrôler le résultat.
    Les commandes sont introduites au moyen de la ligne de commande du moniteur de l’IDE Arduino ou de tout programme d’émulation sur port série.

    Les paramètres introduits sont sauvegardés en mémoire permanente.
    Le programme n’est pas très compliqué et facilement adaptable à vos propres besoins.
    Le PAP est drivé par un A4988 et la bibliothèque AH_Pololu.h
    upload_2016-6-14_17-34-18.png
    La structure des commandes est nomParametre=valeurParametre
    Les commandes sont, pour les paramètres:
    vitesse :
    SetRpm=50 // (t/min)
    SetSpeedHz=100 // (Hz)
    Définition :
    SetMicroSteps=0 //(0-4)

    Les commandes sont, pour les essais:
    PapMove=100 // Déplacements par pas, positif ou negatif
    PapRotate=180 // Déplacements degrés, positif ou negatif
    PapRevolve=7 // Déplacements par tours, positif ou negatif

    Les commandes ne sont pas sensibles majuscule ou minuscule.
    Au démarrage ou après un reset de l’Arduino, les paramètres sauvés sont listés dans le moniteur.
    upload_2016-6-14_17-36-33.png
    Code:
    /*'****************************************************************
    '*  Name    : Console PAP (CPAP)                                  *
    '*  Author  : jpbbricole                                          *
    '*  Date    : 13.06.2016                                          *
    '*  Version : 0.1                                                 *
    '*  Notes   : Console pour tester des PAP avec interface A4988    *
    '*  https://www.pololu.com/product/1182                           *
    '*  https://github.com/laurb9/StepperDriver                       *
    '*                                                                *
    '*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
    '*  la variable scboStepmResolution doît être paramétrée          *
    '*  avant compilation en fonction du PAP                          *
    '*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*
    '*                                                                *
    '*  Utilisation du moniteur série de l'IDE Arduino                *
    '*            ou tout autre terminal sur le PC                    *
    '*                                                                *
    '* La structure des commandes est nomParametre=valeurParametre    *
    '* Les commandes sont                                             *
    '* PapMove=100          PapMove=-89 (pas)                         *
    '* PapRotate=180        PapRotate=-89 (degres)                    *
    '* PapRevolve=7         PapRevolve=-9 (tours)                     *
    '*                                                                *
    '* SetRpm=50 (t/min)  ou  SetSpeedHz=100 (Hz)                     *
    '* SetMicroSteps=0 (0-4)                                          *
    '*                                                                *
    '* Aprés le premier transfert dans l'Arduino, passer les          *
    '* commande suivantes afin de mettre des valeurs plausibles       *
    '* en mémoire : SetRpm=50  SetSpeedHz=100 SetMicroSteps=0         *
    '* et après connecter le PAP                                      *
    '******************************************************************
    */
    #include <AH_Pololu.h>                      // Bibliothèque qui gère l'interface A4988
    #define A4988enablePin 5                    // Stepper motor A4988 ENA
    #define A4988dirPin 2                       // Stepper motor A4988 DIR
    #define A4988stepPin 3                      // Stepper motor A4988 STEP
    #define A4988ms1Pin 8                       // Stepper motor A4988 MS1
    #define A4988ms2Pin 7                       // Stepper motor A4988 MS2
    #define A4988ms3Pin 6                       // Stepper motor A4988 MS3
    #define A4988sleepPin 9                     // Stepper motor A4988 Sleep
    #define A4988resetPin 10                    // Stepper motor A4988 Reset
    #define scboStepmResolution 200             // Stepper motor resolution
    
    #define A4988disabled false
    #define A4988enabled true
    
    #define papSensHoraire FORWARD
    #define papSensAntiHoraire BACKWARD
    
    enum IndexParametres{papParPapNum, papParRpm, papParSpHz, papParMicroStep, papParDernier};
    int papMemoireParametres[papParDernier+1];
    
    //AH_Pololu(int RES, int DIR, int STEP, int MS1, int MS2, int MS3, int SLEEP, int ENABLE, int RESET);
    AH_Pololu papAxeEssai(scboStepmResolution, A4988dirPin, A4988stepPin, A4988ms1Pin, A4988ms2Pin, A4988ms3Pin, A4988sleepPin, A4988enablePin, A4988resetPin);                // crélation de l'objet papAxeEssai
    
    //------------------------------------ Variables réception des commandes
    bool monCommandeNouvelle = false;                           // Si nouvelle commande reçue du moniteur
    String monCommande = "";                                    // Commande reçue
    //------------------------------------ Variables mémorisation des paramètres
    #include <EEPROM.h>
    enum SetupEepromList{eeprParRpm, eeprParSpHz, eeprParMicroStep};// Indexation des paramètres en mémoire EEPROM
    
    
    void setup()
    {
        Serial.begin(9600);                                         // Démarrage du port série
       
        papMemoireParametres[papParPapNum] = 1;                     // Numéro de moteur testé
        papMemoireParametres[papParRpm] = eeprParamGet(eeprParRpm); //60;                       // RPM , rotations par minute
        papMemoireParametres[papParSpHz] = eeprParamGet(eeprParSpHz); // 600;                     // Frequence moteur
        papMemoireParametres[papParMicroStep] =eeprParamGet(eeprParMicroStep); //0;                  // Miocrostep = 0 full step
        papAxeEssai.setSpeedRPM(papMemoireParametres[papParRpm]);             // RPM , rotations par minute
                                                                              // ou
        papAxeEssai.setMicrostepping(papMemoireParametres[papParMicroStep]);  // Microstep
    
        //----------------------------- Liste des paramètres sauvés
        Serial.println("");
        Serial.println("Parametres en memoire:");
        Serial.println("----------------------");
        Serial.println("SetRpm        = " + String(papMemoireParametres[papParRpm]));
        Serial.println("SetSpeedHz    = " + String(papMemoireParametres[papParSpHz]));
        Serial.println("SetMicroSteps = " + String(papMemoireParametres[papParMicroStep]));
        Serial.println("----------------------");
        Serial.println("");
    
        papAxeEssai.resetDriver();                                            // reset driver
        papAxeEssai.enableDriver();                                           // enable driver
        papAxeEssai.sleepON();                                                // set Sleep mode ON
    
    delay(1000);
    }
    
    void loop()
    {
        //serialEvent();                                       // Si le mode interrupt ne fonctionne pas, activer cette ligne
        if (monCommandeNouvelle)                               // Lecture du flag pour nouvelle commande
        {
            Serial.println("Echo " + monCommande);
            monCommandeTraitement(monCommande);
            monCommande = "";
            monCommandeNouvelle  = false;
        }
    }
    /*--------------------------------------------------------------------------------------
    ' commRx: papMove=nbrPas papRotate=nbrDegres papRevolve=nbrTours papSetRPM=nbRpm
    ' Il y a encore d'autres possibilité avec la bibliothèque AH_Pololu.h
    '-------------------------------------------------------------------------------------*/
    void monCommandeTraitement(String commRx)
    {
        int posEgale = commRx.lastIndexOf("=");                     // Localiser le caractère séparateur =
        commRx.trim();                                              // Suppression des espaces inutiles, éventuels aux 2 bouts
       
        if (posEgale > 0)
        {
            String commNom = commRx.substring(0,posEgale);          // Extraire le nom de la commande, de la gauche jusqu'au caractère de séparation
            commNom.toUpperCase();                                  // Mettre las valeur de la commande en majuscule pour éviter les abiguïtés
           
            String commValeurTxt = commRx.substring(posEgale+1);    //  Extraire la valeur de la commande, depuis le caractère de séparation jusqu'à droite
            int commValeurNum = commValeurTxt.toInt();              // Transformer la String commValeurTxt en int
            
            papAxeEssai.sleepOFF();
           
            if (commNom == "PAPMOVE")
            {
                papA4988move(commValeurNum);                        // PapMove=100 ou PapMove=-10
            }
            else if (commNom == "PAPROTATE")
            {
                papA4988rotate(commValeurNum);                      // PapRevolve=180 ou PapRevolve=-80
            }
            else if (commNom == "PAPREVOLVE")
            {
                papA4988revolve(commValeurNum);                     // PapRevolve=6 ou PapRevolve=-3
            }
            else if (commNom == "SETRPM")
            {
                papAxeEssai.setSpeedRPM(commValeurNum);
                eeprParamSave(eeprParRpm,commValeurNum);           // Mise en mémoire permanente du paramètre
            }
            else if (commNom == "SETSPEEDHZ")
            {
                papAxeEssai.setSpeedHz(commValeurNum);                       // Frequence moteur
                eeprParamSave(eeprParSpHz,commValeurNum);                 // Mise en mémoire permanente du paramètre
            }
            else if (commNom == "SETMICROSTEPS")
            {
                commValeurNum = constrain(commValeurNum, 0, 4);
                papAxeEssai.setMicrostepping(commValeurNum);                 // Micro Steps
                                                                             // 0 -> Full Step
                                                                             // 1 -> 1/2 microstepping
                                                                             // 2 -> 1/4 microstepping
                                                                             // 3 -> 1/8 microstepping
                                                                             // 4 -> 1/16 microstepping
                eeprParamSave(eeprParMicroStep,commValeurNum);               // Mise en mémoire permanente du paramètre                                                            
    
            }
            else
            {
                Serial.println("Commande -" + commRx + "- Inconnue!");
            }
        }
        else
        {
            Serial.println("Commande -" + commRx + "- Invalide!");
        }
       
        papAxeEssai.sleepON();                                              
    }
    //---------------------------------------------- Routines PAP A4988
    void papA4988move(int movePas)
    {
        boolean moveDir = papSensHoraire;
       
        if (movePas < 0){moveDir = papSensAntiHoraire;}
        movePas = abs(movePas);                                   // supprimer le négatif si nécessaire
       
        papAxeEssai.move(movePas, moveDir);
    }
    
    void papA4988rotate(int moveDegres)
    {
        papAxeEssai.rotate(moveDegres);
    }
    
    void papA4988revolve(int moveTours)
    {
        papAxeEssai.revolve(moveTours);
    }
    
    /*--------------------------------------------------------------------------------------
    ' https://www.arduino.cc/en/Tutorial/SerialEvent
    ' Reception des données depuis le moniteur ou le PC
    ' Cette routine, dans la pluspart des Arduino, fonctionne en mode interrupt.
    ' C'est à dire qu'elle s'occupe seule de traiter chaque caractère reçu. Pendant ce temps,
    ' votre programme peut faire autre chose.
    ' Vous devez simplement surveiller la variable monCommandeNouvelle.
    '
    ' La chaîne reçue doit se terminer par le caractère ASCII NL Nouvelle Ligne code 10
    ' En bas du moniteur, à gauche de la vitesse, mettre nouvelle ligne.
    ' Donc l'introduction de la ligne de commande doit se terminer par la touche Enter
    '---------------------------------------------------------------------------------------
    */
    void serialEvent()
    {
        while (Serial.available())                                     // Boucle tant que des caractères sont disponibles dans le buffer
        {
            char monChar = (char)Serial.read();                        // Caractère reçu du moniteur
            if (monChar == '\n')                                       // Si nouvelle ligne reçu donc fin de la ligne de commande
            {
                monCommandeNouvelle  = true;                           // monCommandeNouvelle est vraie
            }
            else
            {
                if (monChar >= ' ') {monCommande += monChar;}          // Addition de chaque carattère reçu en suppromant les caractères < espace
                // dans le tableau ASCII afin de supprimer tout les caractères de contrôle
            }
        }
    }
    //------------------------------- EEPROM Setup -----------------------------
    int eeprParamGet(int paramIndex)
    {
        return(EEPROM.read(paramIndex));
    }
    
    void eeprParamSave(int paramIndex, int paramValue)
    {
        EEPROM.write(paramIndex, paramValue);
    }
    
    A votre disposition pour toutes questions.
    Bonne soirée
    jpbbricole

    Je joins à cet article le nécessaire :
    Source Arduino USIN_Console_PAP.ino
    La bibliothèque AH_Pololu
    Le programme Terminal avec les macro nécessaires.
    Voir la pièce jointe Kit_USIN_Console_PAP.zip
     
    Dernière édition: 14 Juin 2016
  2. pinou29

    pinou29 Compagnon

    Messages:
    1 013
    Inscrit:
    18 Mars 2009
    Localité:
    Toulon ( Var )
  3. pinou29

    pinou29 Compagnon

    Messages:
    1 013
    Inscrit:
    18 Mars 2009
    Localité:
    Toulon ( Var )
  4. f6exb

    f6exb Ouvrier

    Messages:
    295
    Inscrit:
    13 Juin 2013
  5. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
  6. lion10

    lion10 Compagnon

    Messages:
    3 394
    Inscrit:
    7 Mai 2010
  7. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
    Console moteur PAP
    @lion10
    c'est aussi une alternative, à voir si c'estccompatible avec la bbibliothèque AH_pololu. A première vue les broches sont les mêmes.

    Cordialement
    jpbbricole
     
  8. lion10

    lion10 Compagnon

    Messages:
    3 394
    Inscrit:
    7 Mai 2010
    Console moteur PAP
    Bonjour
    Lorsque je vais les tester j'envisage de faire une modification au moins sur 1 afin de pouvoir piloter par logiciel le réglage du courant.
    Mais il va falloir que je parcours le datasheet pour savoir si je peux modifier ce courant en dynamique. Autrement dit le circuit mémorise -t-il la consigne de courant lors de sa mise sous tension, à priori je ne pense pas.
    L'idée ensuite est de faire une boucle de rétro-action afin de voir ce que le moteur peut tenir pour une certaine consigne de courant sans décrochage des pas et sa tenue pratique en vitesse sur un banc ou en situation sur une machine.

    cdlt lion10
     
  9. pinou29

    pinou29 Compagnon

    Messages:
    1 013
    Inscrit:
    18 Mars 2009
    Localité:
    Toulon ( Var )
    Console moteur PAP
    Bonjour.
    Pardon pour cette nouvelle question de débutant, où trouver la bibliothèque AH_Pololu et comment l'intégrer dans le programme.
    J'ai reçu ce matin la carte Nano commandée le 7 juin (8 jours seulement pour arriver de Chine) et quand je téléverse le programme de jpbbricole donné ci-dessus, j'ai une rafale d'erreurs qui s'affichent.
    Je précise que c'était juste pour voir si la carte fonctionnait, il n'y a rien d'autre de branché et avec d'autres programmes, pas de problème de téléversement.
    Merci.
    Bernard.
     
  10. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
    Console moteur PAP
    Dans le zip attaché dans le premier post
    le dossier AH_pololu est à copier dans le dossier où se trouve Arduino.exe sous dossier libraries

    Bonne soirée
    jpbbricole
     
  11. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
    Console moteur PAP
    Excellente idée, le schéma à l'air assez simple.
    upload_2016-6-15_19-35-11.png
    Mais je pense qu'il faudrai un DAC pour générer la tension assez propre sur la patte REF.
    Je vais suivre attentivement.

    Cordialement
    jpbbricole
     
  12. pinou29

    pinou29 Compagnon

    Messages:
    1 013
    Inscrit:
    18 Mars 2009
    Localité:
    Toulon ( Var )
    Console moteur PAP
    Bonjour.
    Un mystère pour moi.
    Je "bricole" avec deux ordinateurs portables, les deux sous XP Pro SP3, et lorsque je téléverse le programme ci-dessus donné par jpbbricole, sur l'un des ordinateurs, pas de problème, sur l'autre ordinateur, j'ai ce message:
    avrdude: stk500_getsync(): not in sync: resp=0x00
    J'ai cherché sur la toile, j'ai trouvé tout et son contraire, "la carte est cramée, mauvais programme, mauvais câble........."etc, etc
    Sauf que ma carte fonctionne mais seulement sur un seul micro.
    Je suis sur le bon type de carte et le bon port.
    Quelqu'un d'entre-vous a-t'il eu ce genre de problème et si oui, comment l'avez-vous réglé ?
    Merci.
    Bernard;
     
  13. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
    Console moteur PAP
    Salut pinou29
    Connecte ton Arduino sur le port USB et regarde, dans le gestionnaire de périfériques
    upload_2016-6-16_19-1-58.png
    Dans ce 2 sections s'il y a des points d'exclamation.
    au besoin poste la copie d'écran.

    jpbbricole
     
  14. pinou29

    pinou29 Compagnon

    Messages:
    1 013
    Inscrit:
    18 Mars 2009
    Localité:
    Toulon ( Var )
  15. jpbbricole

    jpbbricole Ouvrier

    Messages:
    461
    Inscrit:
    26 Mai 2016
    Localité:
    Corsier-sur-Vevey (Vaud)
    Département:
    1804
    Console moteur PAP
    Si tu as plusieurs ports USB sur ce laptop, est ce que ça fait le même problème sur les autres, attention, en changeant de port USB, il est possible que le numéro de COM change.
    Sinon, solution suivante, quand le câble est branché, dans le gestionnaire de perifériques, clic droite sur la connexion (sur l'image COM12), supprimer ou désinstaller en supprimant le driver. Ensuite déconnecter le câble, redémarrer le pc et reconnecter l'Arduino et réessayer.
    Bonne soirée.
    jpbbricole
     
Chargement...
Articles en relation
  1. jpbbricole
    Réponses:
    1
    Affichages:
    338
  2. jpbbricole
    Réponses:
    6
    Affichages:
    539
  3. Doctor_itchy
    Réponses:
    12
    Affichages:
    538
  4. pinou29
    Réponses:
    32
    Affichages:
    1 342

Partager cette page