Je me suis finalement décidé à créer un topic sur ce forum après de longues recherches infructueuses sur le contrôle de moteur DC.
Voici mon objectif : Je voudrais contrôler un moteur DC via une carte Grove I2C Motor Driver v1.2 reliée à mon Arduino Uno.
Après avoir longtemps chercher sur la référence officielle Arduino, sur le site d'Adafruit et de Seeeedstudio et avoir comparer de nombreux codes de contrôle de moteur DC, j'en suis au même point qu'au départ : Je ne comprend pas comment contrôler le moteur en ligne de commande.
Je suis par exemple censé rattacher les bornes du moteur DC au module du moteur 1 (M1+ et M1-) et fournir une alimentation externe (ça c'est okay, l'alimentation fait tourner le moteur si je la connecte directement aux bornes de ce dernier.)
Seulement je n'ai trouver nulle part de ligne qui déclare qu'un moteur est rattaché au module M1 et que les données de contrôle doivent être envoyées à ce module.
Voici le code de démo de Seeedstudio sur lequel je me base :
#include <Wire.h>
#define MotorSpeedSet 0x82
#define PWMFrequenceSet 0x84
#define DirectionSet 0xaa
#define MotorSetA 0xa1
#define MotorSetB 0xa5
#define Nothing 0x01
#define I2CMotorDriverAdd 0x0f // Set the address of the I2CMotorDriver
void MotorSpeedSetAB(unsigned char MotorSpeedA , unsigned char MotorSpeedB) {
MotorSpeedA=map(MotorSpeedA,0,100,0,255);
MotorSpeedB=map(MotorSpeedB,0,100,0,255);
Wire.beginTransmission(I2CMotorDriverAdd); // transmit to device I2CMotorDriverAdd
Wire.write(MotorSpeedSet); // set pwm header
Wire.write(MotorSpeedA); // send pwma
Wire.write(MotorSpeedB); // send pwmb
Wire.endTransmission(); // stop transmitting
}
void MotorPWMFrequenceSet(unsigned char Frequence) {
Wire.beginTransmission(I2CMotorDriverAdd); // transmit to device I2CMotorDriverAdd
Wire.write(PWMFrequenceSet); // set frequence header
Wire.write(Frequence); // send frequence
Wire.write(Nothing); // need to send this byte as the third byte(no meaning)
Wire.endTransmission(); // stop transmitting
}
void MotorDirectionSet(unsigned char Direction) { // Adjust the direction of the motors 0b0000 I4 I3 I2 I1
Wire.beginTransmission(I2CMotorDriverAdd); // transmit to device I2CMotorDriverAdd
Wire.write(DirectionSet); // Direction control header
Wire.write(Direction); // send direction control information
Wire.write(Nothing); // need to send this byte as the third byte(no meaning)
Wire.endTransmission(); // stop transmitting
}
void MotorDriectionAndSpeedSet(unsigned char Direction,unsigned char MotorSpeedA,unsigned char MotorSpeedB) { //you can adjust the driection and speed together
MotorDirectionSet(Direction);
MotorSpeedSetAB(MotorSpeedA,MotorSpeedB);
}
void setup() {
Wire.begin(); // join i2c bus (address optional for master)
delayMicroseconds(10000); //wait for motor driver to initialization
}
void loop() {
while(1) {
MotorSpeedSetAB(100,20);
delay(10); //this delay needed
MotorDirectionSet(0b1010); //0b1010 Rotating in the positive direction
delay(1000);
MotorDirectionSet(0b0101); //0b0101 Rotating in the opposite direction
delay(500);
}
}
Si j'ai bien compris, les lignes ci-dessous établissent les adresses des modules auxquels sont rattachés les moteurs. Seul hic ? Dans le code, ces adresses ne sont pas utilisées
#define MotorSetA 0xa1
#define MotorSetB 0xa5
Donc une question que je me pose tandis que je rédige ce sujet : Ce code est-il censé fonctionner sans que je n'y apporte aucun complément ?
Voici une liste de ce que je pense avoir compris :
Les arguments 0b0101 et 0b1010 sont en fait des arguments que le moteur comprendra comme "Fais tourner le moteur dans telle direction en changeant la polarité aux bornes du moteur)
A chaque fois que je transmet des données au moteur, je suis obligé d'écrire un "Wire.beginTransmission(Adresse de ma carte)" suivi des données à transmettre, puis d'un bit nul indiquant la fin des instructions et enfin d'un "Wire.endTransmission()" pour avorter la transmission.
Les lignes ci-dessous correspondent à des entêtes à envoyer via Wire.write() afin que la carte connaisse le "rôle" des données que j'enverrais juste après.
Comment déclarer qu'un moteur est rattaché à un des modules de la carte Grove I2C. Car je peux comprendre qu'on veuille établir une connexion avec la carte, mais pourquoi ne pas préciser en plus avec quel élément de cette carte ? Le devinerait-elle toute seule ?
Qu'est ce que c'est que cette "PWM Fréquence" et à quoi sert-elle ? Suis-je obligé de l'utiliser pour contrôler mes moteurs ?
Voila voila, en espérant avoir des éclaircissement, merci d'avance les ex-zéros !
Tu as déjà presque tout compris grâce au code, les constantes MotorSetA et MotorSetB servent à commander les moteur séparément. Le code exemple utilise les constantes DirectinoSet et MotorSpeedSet qui commandent les deux moteurs simultanément.
Donc c'est en réglant la fréquence de la PWM que je peux régler la vitesse du moteur ?
J'ai par mégarde laisser branché mon petit système sans l'alimentation externe et sans faire de reset de l'arduino (Alimenté par le câble série), serait-il possible que ma carte Grove I2C soit endommagée sans que je le vois ? Car les LED d'indication de direction s'allument toujours mais le fait est qu'aucun code de contrôle de mon moteur ne passe
J'ai écris ce code en espérant avoir compris la marche à suivre. Est-il correct ? (Je précise que lorsque je le téléverse, rien ne se passe d'où mon doute quant à l'intégrité de ma carte Grove I2C) :
La vitesse n'est pas proportionnel à la fréquence de ta pwm mais à son rapport cyclique. C'est la proportion de temps pendant laquelle le signal est à l'état haut, c'est à dire alim ON. Tu règle ta vitesse en jouant sur ce rapport. Grossomodo, tu as un compteur qui compte en boucle jusqu'à 255 à une certaine vitesse(fréquence de ta PWM * 255). Quand le compteur repart à 0, ta sortie passe à 1 dans tout les cas et toi la vitesse que tu donne, c'est le moment à laquelle ta sortie redescend, c'est donc un nombre entre 0 et 255, et plus il est grand et plus ta sortie est longtemps à l'état haut.
Essaie ce code et penses à vérifier que tes switch d'adresse sont bien positionnés.
J'aimerai utiliser une carte grove i2c afin de faire tourner un moteur dans les 2 sens. Je précise que je n'ai pas besoin de modifier la vitesse de rotation ou bien de rajouter un deuxième moteur.
En cherchant sur internet, j'ai trouvé plusieurs codes mais très peu d'explications sur leur signification. Je viens donc sur ce forum en espérant trouver des réponses à mes questions.
Tout d'abord, à quoi correspondent les "0x0f, 0xa1", je me doute que c'est en base 16 mais je me demandais comment connaître le "numéro" que j'ai besoin car selon les codes, les numéros changent pour le moteur, la carte i2c...
Ensuite, est-ce que j'ai besoin de configurer la fréquence PWM pour l'utilisation écrite ci-dessus? Si oui, pouvez-vous expliquer ce que cela change concrètement au niveau du moteur.
Ce que j'avais déjà essayé avec 4 transistors était bien un pont en H, je ne savais juste pas que ça s'appelait ainsi. Après n'avoir jamais réussi à faire tourner mon moteur avec un tel schéma, mon professeur m'a dit d'utiliser un motor shield grove I2C. J'ai donc abandonné l'idée du pont en H et je me suis renseigné sur ce motor shield, ce qui m'a amené ici. Le lien de Eskimon va m'être très utile. Merci à abuche pour ces éclaircissements sur le pont en H mais je vais utiliser un grove I2C donc tout sera déjà inclus dedans. Je vous remercie pour vos réponses.
- Edité par Killluminatix 25 janvier 2014 à 20:13:56
× 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.
Retrouvez moi sur mon blog et ma chaine Youtube !