Partage
  • Partager sur Facebook
  • Partager sur Twitter

Projet arduino motoréducteur

Sujet résolu
    28 février 2019 à 13:26:37

    Bonjour à tous, je vous fait part de mon problème : je suis en terminal Ssi et j'ai un projet à faire. Je suis entrain de réaliser la conception sauf que j'ai un problème. Je vous met un schéma que j'ai trouver sur internet mais qui corresponds à ce que je veux faire. Voila donc mon problème ça serait de pouvoir saturé le transistor grâce à un capteur de mouvement :(le capteur de mouvement détecte une personne -> il envoie un courant au mosfet -> le mosfet actionne le système)

    Ma première poblèmatique serait de savoir ou mettre le capteur de mouvement dans le circuit. 

    ma seconde serait de créer le code qui permettra de réaliser l'action énoncée précédemment (je m'y connais pas trop en code de capteur de mouvement). 

    -
    Edité par Nilsdprl 28 février 2019 à 13:28:32

    • Partager sur Facebook
    • Partager sur Twitter
      Staff 1 mars 2019 à 6:58:35

      La première question à se poser serait de se demander si l'arduino est vraiment utile.

      En effet, si ton but est simplement de faire tourner le moteur quand le capteur détecte quelque chose et de l'arrêter quand le capteur ne détecte rien, alors l'arduino n'est pas utile, autant connecter directement le capteur au transistor.

      En revanche, si tu veux faire quelques filtrage ou action spécifique tel que faire tourner le moteur pendant 3 secondes dès qu'il y a un petit mouvement puis l'arrêter, alors l'arduino se justifie.

      Pour la détection de mouvement, je te conseille vivement de partir sur un capteur PIR.

      Ce genre de capteur renvoie une information logique (LOW ou HIGH suivant sa détection) que tu pourras lire avec la fonction digitalRead de l'arduino.

      Quand à la commande du moteur, tu peux piloter l'état de la pin et donc le moteur avec la fonction digitalWrite ou analogWrite si tu optes pour une commande linéaire en PWM.

      • Partager sur Facebook
      • Partager sur Twitter
        2 mars 2019 à 13:27:31

        Merci d'avoir répondue. J'ai décidé d'utiliser un arduino pour ralentir le moteur grâce à la PWN Cependant, ma problématique est de savoir comment contrôler le moteur. 

        Cependant voici ce que je voudrais faire exactement :

        ->Le capteur détecte quelqu'un 

        ->Pendant 30 s la broche 3 PWN va être en HIGH 

        ->Si une personne repasse devant le capteur le décompte se réinitialise (on repasse à un décompte de 30 s)

        ->Lors des 30 s le transistor est passant

        ->Le transistor va donc permettre au moteur de s'actionner 

        ->On arrive à contrôler le moteur grâce à la PWN 

        ->Toutes les 1 sec print la vitesse du moteur sur la console

        Mes problèmes

        -Je voudrais aussi ajouter quelque chose qui pourrait faire crasher tout en cas de problème visuel 

        (vitesse du moteur trop élevé), mais ou pourront on mettre une sorte de bouton d'arrêt d'urgence dans le circuit?)

        -Je n'ai pas compris comment on contrôle le moteur, de quelle pin tu parle?

        -Ou placer le capteur pour qu'il puisse réaliser l'action décrite dans mon pseudo programme?

        Merci pour avoir pris le temps de me lire

        -
        Edité par Nilsdprl 2 mars 2019 à 13:29:23

        • Partager sur Facebook
        • Partager sur Twitter
          Staff 2 mars 2019 à 17:37:56

          Pour commander le moteur en PWM, il suffit de raccorder la Gate du transistor sur une pin compatible PWM (pin avec un tild devant le numéro).

          C'est d'ailleurs le cas sur ton image où l'on voit que le transistor est connecté sur la pin D3.

          Pa commande se fait avec alors la fonction analogWrite qui prend en paramètre le numéro de pin ainsi qu'une valeur entre 0 (commande nulle, moteur à l'arrêt) et 255 (moteur à fond).

          ***

          Pour le bouton, il suffit de le câbler entre une pin de l'arduino et le GND puis d'ajouter une résistance (dite résistance de pull up) entre cette même pin et le +5V de l'arduino.

          On peut lire l'état du bouton avec la fonction digitalRead.

          Lorsque celui-ci est enfoncé, digitalRead renverra la valeur LOW.

          Libre à toi de faire un programme qui repasse la analogWrite du moteur à 0 pour arrêter celui-ci lorsque la valeur du bouton est lue à LOW.

           ***

          Si tu n'es pas à l'aise avec Arduino, je t'encourage à faire un tour sur le site de Eskimon : https://eskimon.fr/

          Il y a pleins de mini tutoriel pour découvrir arduino dans les moindres détails : les fonctions de base, les mots clefs de programmation, le câblage des boutons, des moteurs, et pleins d'autres choses !

          • Partager sur Facebook
          • Partager sur Twitter
            3 mars 2019 à 14:25:56

            Merci de ta réponse. J'ai fais des recherche sur ton modèle avec la résistance et c'est en effet exactement ce qu'il me faut c'est ingénieux et pratique !

            Cependant je ne sais pas où mettre le capteur PIR dans le circuit pour que je puisse lire sa sortie (High ou Low). Je suis conscient qu'il a 3 broche : +,- et sa sortie que l'on pourra lire mais je ne sais pas ou je vais pouvoir le brancher dans mon circuit. Enfaite mon problème c'est de savoir si on recrée un mini circuit comme avec le bouton ou qu'on arrive à le mettre dans mon schéma avec le mosfet.

            De plus j'ai fait des recherche sur les shields motors, tu pense que je peux me passer de ça ? Et que je pourrais contrôler le moteur qu'avec le pin qui est relié à mon mosfet

            (c'est quoi que t'utilise pour faire des schéma aussi bien ? Jconnais juste fritzing mais ya pas tout les composant électronique que je veux dans la banque de données initial de l'application)

            PS : c'est sur eskimon que j'ai trouvé le schéma avec le mosfet

            -
            Edité par Nilsdprl 3 mars 2019 à 14:30:28

            • Partager sur Facebook
            • Partager sur Twitter
              Staff 3 mars 2019 à 15:36:18

              Le capteur PIR a besoin d'être alimenter donc le GND du capteur va sur le GND de l'arduino et le 5V du capteur (dans le cas où il s'agit d'un capteur 5V) va sur le 5V de l'arduino.

              Quand à la sortie du capteur, il faut tout simplement la relier sur une pin de l'arduino que l'on configura en mode INPUT.

              Au final, du point de vue de l'arduino, le capteur sera vu exactement comme un bouton puisque dans les 2 cas, ce sera la fonction digitalRead qui permettra de récupérer l'état du capteur et/ou du bouton.

              ***

              Le shield moteur permet de pouvoir piloter un ou deux moteur dans les 2 sens de rotation sans avoir à faire du câblage.

              Dans ton cas, ton montage à base de Mosfet permet de faire tourner le moteur que dans un seul sens.

              Si cela te convient, c'est une solution beaucoup plus économique qu'un shield moteur.

              • Partager sur Facebook
              • Partager sur Twitter
                3 mars 2019 à 21:49:27

                Oh d'accord j'ai tout compris pour le capteur mais il va falloir que je le mette dans le sous circuit avec le bouton ?car on utilise déjà le 5v de l'arduino.

                Pour le shield je ne savais pas ça en effet mon problème est juste de piloter un moteur dans un seul sens donc pas de soucis je me tiendrais à mon schéma. 

                Je vais reétudier la partie du pilotage grâce à la pwn car j'ai encore quelque soucis de compréhension du pilotage grâce au transistor. 

                Il me restera plus qu'à faire un beau pseudo code et je le ferais vérifier avant de me lancer dans la réalisation de ce dernier.

                • Partager sur Facebook
                • Partager sur Twitter
                  Staff 4 mars 2019 à 8:30:04

                  Ce n'est pas parce qu'il y a qu'une seule pin 5V sur l'arduino que tu ne peux l'utiliser que pour un seul élément.

                  Rien ne t’empêche de brancher un fils sur ta pins puis de relier ce fils à plusieurs éléments (ton capteur ET la résistance de pull-up du bouton).

                  Au final, ton bouton, ton capteur et ton moteur seront 3 éléments indépendants.

                  C'est le code que tu développement qui fera la liaison logique entre chacun.

                  • Partager sur Facebook
                  • Partager sur Twitter
                    4 mars 2019 à 13:39:29

                    Ok merci je vois ce qu’il faut faire
                    • Partager sur Facebook
                    • Partager sur Twitter
                      6 mars 2019 à 20:30:00

                      Bonsoir/bonjour, j'ai réalisé un shéma sur fritzing. je me demandais si tu pouvais me le corriger.

                      la partie où il y a 3 fils représente les connections du capteur : au milieu la sortie input, à droite le ground et à gauche la borne positive, il n'y a pas le capteur car je ne l'ai pas trouvé dans la biblitothèque de fritzing.

                      De plus j'ai enlever le condensateur que j'avais mis au départ parallèlement au moteur

                      -
                      Edité par Nilsdprl 7 mars 2019 à 13:55:01

                      • Partager sur Facebook
                      • Partager sur Twitter
                        Staff 7 mars 2019 à 15:22:29

                        Le fils noir de la pile doit être relié au GND de l'arduino.

                        A part cette petite erreur, le reste est bon.

                        • Partager sur Facebook
                        • Partager sur Twitter
                          7 mars 2019 à 15:56:48

                          Ok, merci pour la correction.

                          Je suis entrain de faire le code mais j'ai un problème :

                          je voudrais connaitre la vitesse de mon moteur quand le mécanisme s'actionnera, cependant j'ai fais des recherches et le seul moyen que j'ai trouvé est de réaliser un capteur et de le poser sur l'arbre du moteur, tu connaitrais une manière plus simple pour connaitre la vitesse du moteur ?

                          Comme par exemple : une fonction Arduino  

                          -
                          Edité par Nilsdprl 7 mars 2019 à 16:04:18

                          • Partager sur Facebook
                          • Partager sur Twitter
                            Staff 7 mars 2019 à 18:21:51

                            Sur un moteur DC, il n'y a pas d'autre moyen que de mettre un capteur sur l'axe et de compter le nombre d'impulsions que le capteur génère chaque seconde.

                            Si tu ne veux pas de capteur, il te faut utiliser un moteur pas à pas.

                            • Partager sur Facebook
                            • Partager sur Twitter
                              14 mars 2019 à 14:29:26

                              Bonjour/Bonsoir, j'ai effectué des recherches sur les types de moteurs qui me permettrais de savoir leurs vitesse. Mon prof m'a dis qu'il existait des capteur de vitesse dans certains moteurs.

                              J'ai alors trouvé un moteur possédant un encodeur. Tu pense que je pourrais trouver sa vitesse grâce à l'IDE?

                              Voici le lien du moteur : 

                              https://www.robotshop.com/eu/fr/moteur-12v-engrenage-1001-encodeur-64-cpr.html?gclid=EAIaIQobChMI5qG_wdyB4QIVFvhRCh22ZgPXEAQYAiABEgJ-GfD_BwE

                              dalleurs il faut 5 A au démarrage du moteur tu pense que ça sera possible avec l'arduino et la pile  

                              -
                              Edité par Nilsdprl 14 mars 2019 à 15:08:42

                              • Partager sur Facebook
                              • Partager sur Twitter
                                Staff 14 mars 2019 à 20:04:43

                                L'encodeur qui équipe le moteur que tu présentes et un encodeur de quadrature 64 pas, ce qu'il signifie qu'il va envoyer 64 impulsions à chaque fois que le moteur fait un tour.

                                Vu qu'un moteur tourne quand même assez vite, ça va faire un très grand nombres d'impulsions à gérer, ce n'est pas sûre que l’Arduino arrive à suivre mais ça peut se tenter.

                                On utilise généralement ce genre de capteur sur un microprocesseur dédié au contrôle moteur qui possède des entrées dédiés à l'interconnexion de compteur de quadrature.

                                Sur un arduino, on se limite généralement à un capteur plutôt basique qui envoie une seul impulsion par tour.

                                Fais une petit recherche de arduino tachometer sur Youtube, tu trouveras pleins de méthodes intéressante ;)

                                ***

                                Pour ce qui est de l'alimentation, une petite pile 9V n'est clairement pas fait pour délivrer de fort courant.

                                Alimenter un moteur sur une pile 9V, cela va la vider en un rien de temps.

                                Quand à lui demander 5A, ce n'est même pas la peine d'y penser.

                                Tu ferais mieux d'utiliser un bloc de 6 piles 1.5V classique, type LR06.

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  17 mars 2019 à 9:59:29

                                  pour le tachymètre c’est pas vraiment ce qu’il me faut car je vais poser un engrenage sur le moteur qui va entraîner une courroie donc je ne pourrais pas me permettre d’y ajouter soit une roue codeuse soit un tachymètre.

                                  l’encodeur me paraît être le meilleur choix, j’ai donc fait des recherches un peu plus sérieuse (le moteur que je t’avais montrer était un moteur pris à la vas vite). J’ai trouvé une choses intéressantes : un motoreducteur avec encodeur un peu plus adapté à l’Arduino 

                                  https://www.robot-maker.com/shop/kits-robots/51-kit-moteur-gm25-370ca-encodeur-roue-chromee.html

                                  Il est utilisé dans le même type d’application que je souhaite ici :

                                  https://www.robot-maker.com/shop/blog/32_Utilisation-des-encodeurs.html

                                  sur le tuto on nous explique qu’il possède 6 tics par tour j'imagine que ça correspond au nombre d’impulsions (ce qui est bien plus faible qu’en le motoréducteur encodeur précédant sachant qu’en je souhaites faire tourner le moteur a une vitesse très faible (environ 50 tr min)

                                  Tu penses que je pourrais le faire tourner à cette vitesse et pouvoir vérifier son fonctionnement ?

                                  -
                                  Edité par Nilsdprl 17 mars 2019 à 10:00:01

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    Staff 17 mars 2019 à 17:50:23

                                    Quand tu dis 50 tr/min, j'espère qu'il s'agit de la vitesse en sortie d'arbre, après le réducteur de 1:34.

                                    En effet, vu qu'il s'agit d'un moteur prévue pour faire du 5000 tr/min à vide, je doute que tu parviennes à avoir quelque chose de stable avec une vitesse de seulement 50 tr/min car cela ne représente que 1% de sa vitesse nominale.

                                    En revanche, après réduction, la vitesse nominale est de 150 tr/min donc il n'y a clairement aucun problème à demander une vitesse de 50 tr/min puisque s'agit de 33% de la vitesse nominale.

                                    Le capteur quand à lui se trouve au niveau de l'axe du moteur, avant le réducteur donc si la roue tourne à 50 tr/min, alors le moteur tourne lui à 50*34 = 1700 tr/min.

                                    Avec 6 ticks par tours, cela va faire 1700*6 = 10200 ticks/min, soit 170 ticks/secondes, ce qui est largement gérable pour l'arduino.

                                    -
                                    Edité par lorrio 17 mars 2019 à 17:51:32

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      17 mars 2019 à 21:57:17

                                      Oui c'est bien la vitesse en sorti du reducteur dont je parlais, merci beaucoup pour ton aide. Ducoup comment je vais faire pour le contrôler avec les tics ? A-t-on besoin d'un driver comme le montre le tuto car je ne vois pas à quoi ça sert

                                      -
                                      Edité par Nilsdprl 17 mars 2019 à 22:05:18

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        Staff 18 mars 2019 à 8:17:09

                                        Que ce soit AVEC ou SANS tick d'encodeur, l'Arduino est incapable de piloter directement un moteur car celui-ci consomme beaucoup trop.

                                        Si ton moteur n'a besoin de tourner que dans un seul sens, alors le driver se résume à un transistor mosfet canal N et une diode de roue libre.

                                        Si tu dois pouvoir piloter ton moteur dans les 2 sens, alors il faut opter pour un pont en H ou un shield moteur.

                                        Une fois le câblage réaliser, la vitesse du moteur se commande avec la valeur du PWM transmise à analogueWrite.

                                        Plus cette valeur est élevée, plus le moteur tournera vite.

                                        A toi de faire un code qui ajuste cette valeur en fonction de ce que mesure le capteur.

                                        Par exemple, si le capteur indique 48 RPM alors que tu en veux 50, il suffit d'augmenter un peu cette valeur de PWM.

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          20 mars 2019 à 8:37:36

                                          Ok et tu sais comment je dois brancher le moteur sachant que je veux garder le schéma que je t'avais envoyé.

                                          Et tu sais si au niveau d'une pile de 9 V je pourrais le faire fonctionner sachant que pour en Courant Continu (A): 90-300mA, est-ce que je dois faire un montage de pile en parallèle afin de pouvoir le faire fonctionner

                                          *

                                          à quoi correspond l'encodeur A et l'encodeur B?

                                          -
                                          Edité par Nilsdprl 20 mars 2019 à 9:38:09

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            Staff 20 mars 2019 à 13:39:19

                                            Tu peux garder ta pile 9V si tu le souhaites, c'est juste que tu vas la vider extrêmement vite.

                                            Mettre plusieurs piles 9V en parallèle va revenir assez chère (ce n'est pas donner ces piles).

                                            Tu ferais donc mieux de mettre 6 piles 1.5V en série dans un coupleur de piles.

                                            ***

                                            Pour ce qui est de A et B, il s'agit de la sortie des codeurs sur lesquels tu vas retrouver les pulses.

                                            Les sorties A et B sont légèrement décalées, ce qui permet de connaitre le sens de rotation en fonction de qui reçoit le pulse en premier.

                                            Dans ton cas, vu que le moteur ne tourne que dans un seul sens, tu n'as besoin que d'une seule de ces 2 sorties, peu importe laquelle.

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              20 mars 2019 à 16:08:30

                                              Ok je vois mais les autres port servent à quoi ? comment je branche l'encodeur pour le faire fonctionner le moteur sachant que je voudrais placer le moteur comme sur le schéma  :

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                Staff 20 mars 2019 à 20:41:12

                                                M1 motor- et M1 motor+ sont les 2 pins d'alimentation du moteur, à brancher sur le pôle + de ta pile et le collecteur du transistor, comme sur ta photo.

                                                Si ton moteur tourne dans le mauvais sens, il suffit d'inverser les 2 fils.

                                                ***

                                                GND encoder - et 3V3 encoder + correspondent aux pins d'alimentations des encodeurs, à brancher respectivement sur le GND de l'arduino et la pin 3V3 de l'arduino.

                                                ***

                                                Quand à la pin A, il te faut brancher ça sur une pin disposant des fonctions d'interruptions.

                                                On peut par exemple utiliser la pin 2 qui correspond à INT0.

                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  21 mars 2019 à 14:57:49




                                                  J'ai fais des recherches et je suis tomber sur des code d'asservissement grâce à un encodeur.

                                                  Si j'arrive à réaliser un asservissement ça serait parfait. Cependant, j'ai vu que ça se compliquait rapidement. j'ai trouvé ces sites : https://blog.3sigma.fr/arduino/tutoriel-arduino-asservissement-en-vitesse-dun-moteur-a-courant-continu/.

                                                  Tout d'abord il compte le nbre d'impulsions qu'il faut respecter(comme ce que tu as fait), il créer un code sur le calcul de la vitesse grâce au impulsions, puis il réalise un timer pour réaliser le calcul de la vitesse, enfin, il réalise un  asservissement en vitesse du moteur. cependant j'ai beaucoup de problème à la compréhension du code pour l'asservissement. tout d'abord :

                                                  /******* Régulation PID ********/
                                                  // Ecart entre la consigne et la mesure
                                                  ecart = vref - omega;
                                                  // Terme proportionnel
                                                  P_x = Kp * ecart;
                                                  // Calcul de la commande
                                                  commande = P_x + I_x;
                                                  // Terme intégral (sera utilisé lors du pas d'échantillonnage suivant)
                                                  I_x = I_x + Ki * dt * ecart;
                                                  /******* Fin régulation PID ********/

                                                  il explique que Les gains proportionnel et l’intégral étant respectivement Kp=0.29 et Ki=8.93. Or comment il trouve ces gains et à quoi ils servent



                                                  -
                                                  Edité par Nilsdprl 27 mars 2019 à 9:10:33

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    Staff 21 mars 2019 à 20:49:06

                                                    Kp correspond au coefficient proportionnel qui permet de définir une commande de base.

                                                    Pour la déterminer, le plus simple consiste à mettre ton moteur à fond en écrivant 255 dans la fonction analogWrite.

                                                    Ce coefficient est ensuite déterminé mathématiquement avec la vitesse que tu auras mesuré.

                                                    Par exemple, si en mettant 255 tu mesure 4000 RPM, alors on a KP = 255/4000= 0.06375

                                                    Ainsi, quand tu voudras seulement 1000 RPM, il te suffira d'envoyer la valeur 1000*KP = 1000*0.06375 = 63 dans le PWM analogWrite.

                                                    Et c'est plutôt logique car si un analogWrite de 255 permet d'aller à 4000 RPM, alors un analogWrite de 63 (soit un 1/4 de de 255) a toute ses chance de donner une vitesse proche de 1000 RPM (qui correspond aussi à 1/4 de 4000 RPM).

                                                    Le problème, c'est que le KP ne fait pas tout...

                                                    Par exemple, si quelque chose vient freiner un peu le moteur, alors celui-ci va ralentir et il faudrait augmenter un peu la commande pour compenser.

                                                    Et c'est là que le KI intervient car celui-ci permet d'ajuster la commande en fonction de l'erreur mesurée.

                                                    Si le moteur tourne trop lentement, alors le KI aura tendance à augmenter la commande, ce qui aura pour effet de faire accélérer le moteur jusqu'à ce que celui-ci soit à la bonne vitesse.

                                                    Il y a pleins de façon de faire avec des calculs plus ou moins compliqués mais le plus simple reste de faire des tests en partant de KI=0 et en augmentant progressivement.

                                                    Si le KI est trop faible, alors la compensation sera très lente et le moteur mettra du temps à atteindre son régime stabilisé.

                                                    Si le KI est trop élevé, alors la compensation sera trop forte, ce qui aura tendance à faire osciller ton moteur.

                                                    En effet, une compensation trop forte fera accélérer très fortement le moteur au moindre ralentissement de celui-ci, ce qui aura pour effet de dépasser la vitesse de consigne.

                                                    Et bien sûre, en dépassant la vitesse de consigne, ce KI trop élevé va alors compenser en freinant très fortement le moteur, qui va alors revenir bien en dessous de la consigne.

                                                    Et ainsi de suite, le moteur ne va faire que accélérer et ralentir, d'où son oscillation.

                                                    Donc mieux vaut avoir un KI trop faible qu'un KI trop fort ;)

                                                    ***

                                                    Quand au coefficient KP que l'on retrouve dans une vrai régulation PID, mieux vaut ne pas en parler.

                                                    D'ailleurs, ce coefficient est très souvent à 0 dans les asservissement de base.

                                                    -
                                                    Edité par lorrio 21 mars 2019 à 20:52:27

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      25 mars 2019 à 14:02:02

                                                      D'accord, tu pense que je peut réaliser un asservissement avec mon circuit élec :

                                                      enfin ce que je veux dire c'est est-ce que je peux utiliser le code sur le site avec comme base mon circuit(bien évidemment en changeant les sorties/entrées)

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        Staff 25 mars 2019 à 18:32:03

                                                        Oui, tu peux utiliser le code proposé sur le site en adaptant un peu le code.

                                                        Il te faudra changer les entrées/sorties, les constantes d'asservissement et aussi supprimer la gestion de l'entrée B qui permet de savoir dans quelle sens tourne le moteur.

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          25 mars 2019 à 20:17:52

                                                          Ok, je vais faire des recherches sur les fonctions que je ne connais pas et sur le programme dans son ensemble en tout cas c'est super sympas de ta part de prendre du temps pour me répondre

                                                          -
                                                          Edité par Nilsdprl 25 mars 2019 à 20:36:37

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            27 mars 2019 à 9:56:06

                                                            Salut, donc voici ma question, j'ai fait des recherches sur la fonction attachInterupt : c'est un déclenchement qui arrête l'éxecution d'un programme
                                                            pour executer une autre fonction. et la fonction change qui change l'état du pin
                                                            digitalWrite(codeurPinA, HIGH);  // activation de la résistance de pullup
                                                            digitalWrite(codeurPinB, HIGH);  // activation de la résistance de pullup
                                                            attachInterrupt(codeurInterruptionA, GestionInterruptionCodeurPinA, CHANGE);
                                                            attachInterrupt(codeurInterruptionB, GestionInterruptionCodeurPinB, CHANGE);
                                                            Pourquoi utiliser la fonction attachInterupt et pourquoi ces fonctions en particuliers alors que l'on ne les a pas appelé avant la fonction attachInterupt?
                                                            De plus dans mon code je pourrais bien enlever la partie ou il active la résistance de pullup puisque j'en ai déjà une sur mon transistor
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              Staff 29 mars 2019 à 8:28:40

                                                              Pour faire ton asservissement, il te faut savoir à quel vitesse tourne ton moteur.

                                                              Pour cela, tu dois compter les impulsions de ton capteur.

                                                              Tu pourrais faire ça dans le programme principal en venant lire l'état de la pin du capteur pour vérifier si elle a changer d'état.

                                                              Le problème, c'est que tu ne peux pas faire cette lecture en permanence...

                                                              Par exemple, il y a forcément un moment où ton programme principal va faire autre chose : un calcul, un afficheur sur le Serial, la lecture d'un autre capteur ou autre...

                                                              Pendant qu'il fait autre chose, il ne scrutera pas la pin du capteur et il se pourrait qu'il rate une impulsion si celle-ci se produit pendant qu'il fait autre chose.

                                                              Si tu rates des impulsions, la mesure de vitesse sera erronée et donc asservissement sera erroné lui aussi.

                                                              La fonction attachInterupt est là pour pallier à ce problème pour traiter des évènements de façon automatique.

                                                              En effet, à chaque changement d'état de la pin, l'arduino va mettre temporairement en pause le code loop qui était en train d'exécuter pour venir exécuter le code de la fonction associée à l'interruption.

                                                              Cette mise en pause se fait automatiquement, sans avoir à lire l'état de la pin et peu importe ce que l'arduino était en train de faire.

                                                              Du coup, il suffit alors d'incrémenter le compteur dans cette fonction pour être certain de ne rater aucun pulse.

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              Projet arduino motoréducteur

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown