aide programmation uno r3 distributeur croquette

Bonjour,

je souhaiterai fabriquer un distributeur de croquettes .
Pour la partie mécanique, j'entrainerai une vis sans fin sous forme de ressort.

Pour cela, j'ai acheté une carte arduino uno R3, un moteur pas à pas avec son driver uln2003.

Le but étant d'activer la vis sans fin pendant un certain moment (je pense en tour) puis après un délai de 6heures, recommencer l'étape etc etc

j'ai trouvé un bout de code, par contre étant complétement néophyte en la matière, j'ai besoin de votre aide pour pouvoir le terminer.

merci d'avance pour votre aide.

 //**************************************************************
   //Commande de moteur pas-à-pas unipolaire 4 fils
   //tiptopboards.com 05/12/2013
   // Driver ULN2003 et moteur réducté au 1:64
   //
   //**************************************************************
   //Inclure la librairie stepper.h
    #include <Stepper.h>
    #define STEPS 100
    
     //Créer une instance de la classe stepper
     //Le moteur (fils 1 2 3 4) est branché sur les sorties 8 9 10 11 de l'Arduino (et sur GND, +V)
     Stepper small_stepper(STEPS, 8, 10, 9, 11);     // Sens horaire
    
     //Stepper small_stepper(STEPS, 11, 10, 9, 8);  // Sens anti-horaire en inversant 8 et 11 (si on préfère)
     int  Steps2Take = 0;  //Nombre de pas de rotation demandé au moteur
     long temps =0;          //Durée de rotation pour un tour
     //************************************************************
     // Pour un moteur de ce type : http://tiptopboards.com/151-moteur-pas-%C3%A0-pas-r%C3%A9duct%C3%A9-de-5v-4-fils-driver-.html
     // 64 pas par tour, 4 phases, angle de 5.625° selon les spécifications du moteur
     // Démultiplication 1:64 pour ce moteur réducté mécaniquement
     //   360° / 5.625° * 64 = 4096 angles avec la démultiplication
     //   360° / 5.625° * 64  * 4 bobines / 2 bipolaire = 2048 step / tour
    

   void setup()
    {               
     Serial.begin(9600);     // 9600 bps
     Serial.println("Test de moteur pas a pas"); 
     }

   void loop()
     {
     Serial.println("Moteur en marche "); 
     //Faire tourner le moteur
     small_stepper.setSpeed(10); //Vitesse de 300 (max) réduire ce chiffre pour un mouvement plus lent
     //100 permet d'éavoir un couple élevé >300 le moteur vibre sans tourner
    
     Steps2Take  = 2048;  // Une rotation complète avec 2048 pas (1 tour environ 4.5sec)
     //Pour tourner à l'envers de 6 fois 1/30eme de tour, simplement multiplier Steps2Take par 6/30 et mettre un moins pour inverser le sens
     // Exemple  Steps2Take  = -6*2048/30;
     temps = millis();
     small_stepper.step(Steps2Take);  //Ca tourne
     temps =  millis()- temps ;  //Chronomètre un rour complet  6.236 sec par tour à vitesse 200
     Serial.println(temps);      //Affiche le temps (en ms) pour un tour complet
     delay(21600000);  //pause
    }

Salut,

Pour t’aider faudrait déjà connaitre le problème …

pas faux, en fait je ne sais pas comment recommencer l'étape .

faut-il ajouter une boucle ou autre ?

merci

Bin ça va recommencer la, t'es dans la loop()

donc en laissant le code tel quel, je suis capable de lui faire faire un tour et ensuite d'attendre 21600 secondes puis recommencer etc etc ?

robix62:
donc en laissant le code tel quel, je suis capable de lui faire faire un tour et ensuite d’attendre 21600 secondes puis recommencer etc etc ?

bonsoir
à priori c’est ça :grin:

ceci etant utiliser un moteur PAP avec un driver specialisé “juste pour faire ça” = verifier un simple tour de vis , c’est plus que du luxe 8)

au prix auquel je l'ai non :slight_smile:
pis il faut bien débuter par quelque chose :wink:

ensuite pourquoi ne pas lui adjoindre un écran avec bouton pour modifier la quantité etc mais ça c'est encore une autre histoire

merci de votre aide en tout cas

robix62:
au prix auquel je l'ai non :slight_smile:
pis il faut bien débuter par quelque chose :wink:

ensuite pourquoi ne pas lui adjoindre un écran avec bouton pour modifier la quantité etc mais ça c'est encore une autre histoire

merci de votre aide en tout cas

Voilà , ça c'est que je considère comme une bonne reponse 8)

maintenant :
pourquoi dans ton code tu utilise millis() pour gerer la rotation
et delay() pour la tempo ?
utilise aussi millis() pour la tempo , ne serait ce que pour faire simplement clignoter "une led" d'activité/boucle
ça ne pourra qu’être bénéfique pour tes éventuels développements futurs :grin:

alors google a été sympa et m'a proposé ce tuto

http://tiptopboards.free.fr/arduino_forum/viewtopic.php?t=41&p=43

j'ai carrément copié-collé le code

la led ne clignoterai uniquement pendant la tempo puis cesserai de clignoter lorsque le moteur fonctionnerai ?

robix62:
alors google a été sympa et m'a proposé ce tuto

regarde plutot ça

désolé mais je n'ai pas assez d'expérience pour maîtriser le sujet lol

robix62:
désolé mais je n'ai pas assez d'expérience pour maîtriser le sujet lol

ça viendra (ou pas) 8)
et lorsque le moment sera venu , tu lira tranquillement l'article de B@tto qui est très didactique

je l'ai mis en marque page :wink:

ya plus qu'à !

Artouste:
8)
Voilà , ça c'est que je considère comme une bonne reponse 8)

maintenant :
pourquoi dans ton code tu utilise millis() pour gerer la rotation
et delay() pour la tempo ?
utilise aussi millis() pour la tempo , ne serait ce que pour faire simplement clignoter "une led" d'activité/boucle
ça ne pourra qu’être bénéfique pour tes éventuels développements futurs :grin:

au lieu d'utiliser delay pour ne pas que l'arduino se tourne les pouces, plutôt utiliser millis() pour faire clignoter une led c'est ça ?

En utilisant bien millis() on libère simplement énormément d’activité sur son CPU. Quand tu utilises delay() ton µC ne peut rien faire d'autre. Alors qu'avec millis() il ne fera ce qu'il faut faire que quand c'est le moment de le faire.

Donc ici l'exemple "simple" qui démontre la différence, c'est que tu pourras faire clignoter une led en permanence, et quand ton temps sera écoulé il distribuera des croquettes puis recommencera à clignoter. Et si on faisait un bref calcul de tout ça, ça donnerait une mobilisation du CPU inférieure à 0.01% ... Alors qu'avec delay tu es quasiment à 100% :wink:

Alors on est d'accord que pour le moment, tel que ton code est, millis() ou delay() ça ne changera rien car tu n'as rien d'autre à executer. Maintenant quand tu vas vouloir ajouter un écran et des boutons pour gérer la quantité distribuée ça sera une autre histoire

merci bcp pour toutes ces infos !

je préfère faire la modif tout de suite, il n’y a bien que comme ça qu’on progresse

je suis d’ailleurs entrain de bucher les cours sur coursera :slight_smile:

j’ai mis à jour le code. pas sur du tout que ce soit fonctionnel en l’état j’ai pas la carte sous la main pour tester

    //**************************************************************
    //Commande de moteur pas-à-pas unipolaire 4 fils
    //tiptopboards.com 05/12/2013
    // Driver ULN2003 et moteur réducté au 1:64
    //
    //**************************************************************
    //Inclure la librairie stepper.h
     #include <Stepper.h>
     #define STEPS 100
     
      //Créer une instance de la classe stepper
      //Le moteur (fils 1 2 3 4) est branché sur les sorties 8 9 10 11 de l'Arduino (et sur GND, +V)
      Stepper small_stepper(STEPS, 8, 10, 9, 11);     // Sens horaire
     
      //Stepper small_stepper(STEPS, 11, 10, 9, 8);  // Sens anti-horaire en inversant 8 et 11 (si on préfère)
      int  Steps2Take = 0;  //Nombre de pas de rotation demandé au moteur
      long temps =0;          //Durée de rotation pour un tour
      //************************************************************
      // Pour un moteur de ce type : http://tiptopboards.com/151-moteur-pas-%C3%A0-pas-r%C3%A9duct%C3%A9-de-5v-4-fils-driver-.html
      // 64 pas par tour, 4 phases, angle de 5.625° selon les spécifications du moteur
      // Démultiplication 1:64 pour ce moteur réducté mécaniquement
      //   360° / 5.625° * 64 = 4096 angles avec la démultiplication
      //   360° / 5.625° * 64  * 4 bobines / 2 bipolaire = 2048 step / tour
     
      unsigned long Depart;
 
      boolean Flag;
 
      const Led 13;
 
      const MonDelai=261000;

    void setup()
     {               
      Serial.begin(9600);     // 9600 bps
      Serial.println("Test de moteur pas a pas"); 
      pinMode(Led,OUTPUT);
 
    Depart = millis(); // Enregistrement de mon point de départ
    
      }

    void loop()
      {
      Serial.println("Moteur en marche "); 
      //Faire tourner le moteur
      small_stepper.setSpeed(10); //Vitesse de 300 (max) réduire ce chiffre pour un mouvement plus lent
      //100 permet d'éavoir un couple élevé >300 le moteur vibre sans tourner
     
      Steps2Take  = 2048;  // Une rotation complète avec 2048 pas (1 tour environ 4.5sec)
      //Pour tourner à l'envers de 6 fois 1/30eme de tour, simplement multiplier Steps2Take par 6/30 et mettre un moins pour inverser le sens
      // Exemple  Steps2Take  = -6*2048/30;
      temps = millis();
      small_stepper.step(Steps2Take);  //Ca tourne
      temps =  millis()- temps ;  //Chronomètre un rour complet  6.236 sec par tour à vitesse 200
      Serial.println(temps);      //Affiche le temps (en ms) pour un tour complet
      
      if((millis()-Depart)>=MonDelai){     // si 216000 ms se sont écoulées
 
         Flag=!Flag;    // j'inverse l'état de mon booléen
 
         digitalWrite(Led,Flag);   //  je change l'état de ma sortie
 
         Depart=millis();  // nouvelle enregistrement du point de départ
 
        }
 
// code qui s'exécutera le temps que 216000 ms se soient écoulées
 
     }

j'ai mis à jour le code, j'ai mixé deux programmes, un pour faire tourner le moteur et l'autre pour faire clignoter une led.
d'après vous ça peut fonctionner ?

salut j'ai vue ton projet et j'aimerai faire le meme style je voulais savoir si tu avais reussi ?

Bonsoir,

Déterrer un post qui date de plus de quatre ans !? :o :confused:.
Tu as peu de chance d'obtenir une réponse du demandeur qui n'a que 33 post à son actif.

Mais tu peux toujours en lancer un nouveau pour ton projet. Commence à faire un petit travail de recherche (carte arduino, moteur, drivers moteur). Des cours sont disponibles si tu ne connais pas encore le monde de l'arduino.
Et une fois que tu seras lancé, nous serons là pour répondre à tes questions et t'aider à résoudre tes problèmes ;).