Bonjour à tous,
Je souhaiterais me lancer dans la conception d'un stabilisateur gimbal avec des moteurs brushless comme ceux-ci : https://goo.gl/ApBNTs
On m'a donc conseillé d'utiliser cette carte qui possède un module gyroscope 6050MPU : https://goo.gl/SBcDok
Voilà qu'arrive ma question, n'ayant aucune connaissance de programmation, existe-t-il des codes "tout prêt", pour les cartes de gyro-stabilisation ?
Bonjour,
Ça me fait un peu mal de te dire çamais tu peux essayer de voir des projet quadrivalent développé avec Arduino.
Les développeurs postent souvent leur codes.
Il faudra tout de même mettre un peux les mains dans le cambouis.
Oui, j'y ai penser à utiliser un Arduino, car visiblement il y a plus de facilité à l'utilisation
Salut!
C'est vrai que la programmation sur STM32 (et autre processeurs ARM) n'est pas ce qui est de plus simple pour débuter! Les stabilisateurs sont des systèmes qui doivent être réactifs, et il faut un microcontrôleur conséquent. Oublie donc les petits Arduino à base d'ATmega328 ou 32U4, peut-être qu'un Arduino Mega peut convenir.
En faisant une petite recherche je suis tombé sur ce lien avec un projet Arduino qui met en œuvre le même capteur que toi, mais le système est à base de servomoteur et non de brushless. Mais tu devrais pouvoir t'en inspirer!
Il te faudra aussi l'interface de puissance avec les moteurs, sur la carte que tu as donné en photo on voit très clairement les DRV8313 de chez Texas Instruments.
Il existe des drivers équivalents chez d'autres fabricants mais je te conseille de rester sur une architecture proche de la carte existante
Bonne chance!
A+!
Merci beaucoup SportsEngine pour tes conseils qui devraient bien me servir.
Mais de rien!
Je ne suis pas très familier avec l'environnement de programmation Arduino ni les processeurs Atmel. Je ne sais pas si l'ATmega2560 (Arduino Mega) sera le plus adapté à cette application, mais il semble être le plus "performant" des microcontrôleurs intégrés sur une carte Arduino avant de passer sur un processeur ARM (Atmel SAM3X intégré sur la carte Arduino Due), et donc peut-être plus abordable en terme de difficulté que ce dernier.
Comme je ne suis pas familier avec cet environnement de développement je ne sais pas si il y a une réelle différence entre le développement sur Arduino Mega et sur Arduino Due, mais ce que je te conseille avant d'envisager tout achat de matériel, c'est de regarder des exemples de projets qui ont été réalisés pour l'Arduino Due et de voir si ça te semble clair. Ne cherche pas de programmes complexes d'asservissement de moteur ou autres, mais plutôt des petits projet "blink led" ou "hello world", qui mettent en œuvre des configurations basiques autour desquelles tu pourras évoluer : les programmes simples permettent de mieux identifier les fonctions essentielles au fonctionnement du système, dites bas-niveau (configuration de l'oscillateur, PLL de l'horloge système, et éventuellement certains périphériques) et les fonctions propres au projet (configuration d'un port en sortie pour commander une LED et d'un timer pour la faire clignoter par exemple).
A ce moment là deux choix s'offrent à toi :
- soit tu parviens à comprendre le fonctionnement de quelques programmes et tu te sens prêt à développer sur cette plateforme, dans ce cas tu peux investir dans l'Arduino Due (je parle d'un point de vue technique, mais ton budget est aussi un critère à prendre en compte). Ce sera un plus en terme de performances et de possibilité d'évolutions.
- soit ça te semble un peu trop compliqué pour le moment, et tu passes sur l'Arduino Mega qui te permettra de te faire la main sur une architecture moins complexe, mais qui offre toutefois un large choix d'applications.
Petite parenthèse : Je sais que beaucoup ont une dent contre l'Arduino, Pour rester objectif je dirais qu'il faut savoir différencier langage de programmation et matériel ciblé. Le langage Arduino est une méthode de programmation adaptée pour débuter la programmation ou pour mettre en place un prototype assez rapidement, je n'ai pas assez d'expérience pour dire si c'est optimal ou non pour des projets complexes (temps réel, etc). Du point de vue matériel, ça reste un processeur sur un PCB, donc rien n'empêche par la suite de configurer une autre toolchain pour programmer la bête en C, C++, Python...
A+!
Salut SportsEngine, (au risque de passer pour un flemmard ^^) si j'achète une nacelle toute prête (comme sur les miniature de mon premier message) qui ont une interface BGC2.2, est-ce qu'il y a moyen en la reliant à l'ordi, de pouvoir récupérer le code qui est dessus ? De façon à m'en servir pour essayer de comprendre son architecture (qui ne dois pas être la même que sous arduino), mais au moins pour avoir une base !?
Encore merci pour tes réponses.
Salut,
Je ne sais pas si le code est open source ou non, mais dans tous les cas tu ne pourras pas récupérer le code C depuis la carte. Au meilleur des cas, si le processeur n'est pas protégé en lecture, tu pourras récupérer le code binaire (en gros le .hex que tu obtiens après compilation). Pratique si tu veux dupliquer la carte, mais quasi impossible à modifier (il faudrait le désassembler, et le code assembleur qui en ressort, s'il est correct, risque d'être compliqué à comprendre sans connaître l'architecture du processeur, les instructions...)
Si par chance le code est open source, il y a certainement un lien vers github ou une autre plateforme de partage de code source, et là tu auras accès à toutes les informations. Mais tu risques de vite être bloqué sans connaître le processeur (les registres ne sont pas les mêmes, et quand le programme est complexe c'est long de faire le tri dans les fonctions utiles...).
Clairement dans certains cas il vaut mieux partir de 0, ou presque (tu as déjà accès à un code pour lire ton capteur). Si ça te tente toujours, tu apprendras bien plus de choses en essayant de programmer par toi-même.
Les fonctions "bas niveau" existent déjà dans des lib Arduino (SPI, PWM, UART, GPIO, Timers...). Lire les données de ton capteur devrait être assez simple, le plus compliqué sera de bien interpréter les données reçues.
Pour piloter les moteurs avec les DRV8313 tu auras besoin de PWM et GPIO (vitesse de rotation par PWM, direction/enable par GPIO), et de coder un asservissement. Le mot fait un peu peur, mais il n'y a rien de compliquer à l'implémenter :
Code:/*** Déclaration de la fonction "getPIDcommand" ***/ double getPIDcommand(double Kp, double Ki, double Kd, double consign, double measure, double *errorSum, double *errorOld) { double command = 0; double error = 0; double deltaError = 0; error = consign - measure; *errorSum += error; deltaError = (error - *errorOld); command = (Kp * error + Ki * *errorSum + Kd * deltaError); *errorOld = error; return command; }Code:/*** Déclaration de la fonction "motorConrol" ***/ int motorConrol(void) { double Kp = 1.0; double Ki = 0.1; double Kd = 0.5; double positionConsign= 0; double actualPosition= 0; double positionError= 0; double previousError= 0; double pwmValue= 0; positionConsign = 30; // consigne : position 30° actualPosition = sensorRead(); pwmValue = getPIDcommand(Kp, Ki, Kd, positionConsign, actualPosition, &positionError, &previousError); if (pwmValue<0) { motorDirection=0; pwmValue=pwmValue*(-1); } else motorDirection=1; setMotorDir(motorDirection); setPWM(pwmValue); return 0; }Ici j'ai donné l'exemple d'un PID, mais tu peux partir sur un autre type de correcteur.Code:/*** Implémentation périodique ***/ int main(void) { bool timer1_interrupt=FALSE; setupTimer1(100us_period); void _Timer1_ISR(void) { timer1_interrupt=TRUE; T1IF=0; } while (1) { if(timer1_interrupt==TRUE) { motorConrol(); timer1_interrupt=FALSE; } } }
Biensur le programme n'est pas fonctionnel tel quel mais ça te donne une petite idée du principe, j'ai mis des noms de fonction qui me semblent assez compréhensibles pour que tu puisses trouver des équivalents (PWM, configuration d'un timer avec une interruption toutes les N µs, fonction "main"...)
La clé pour un asservissement c'est de trouver la bonne période d'acquisition (interruption d'un timer) et de trouver les bons paramètres Kp, Ki, et Kd. Tu remarqueras d'ailleurs que la fonction n'est pas appelé dans le vecteur d'interruption du timer (ISR) car c'est mal, mais dans la fonction main (c'est pour cette raison qu'il faut éviter au maximum les fonctions delay).
Tu auras besoin de faire un peu de traitement de données pour récupérer les bonnes info de ton capteur, pour les envoyer ensuite aux PID de tes 2 ou 3 moteurs. Vu que tu veux maintenir une position fixe (par exemple horizontale) ta consigne est fixe. Ici j'ai mis 30 mais c'est totalement arbitraire, d'ailleurs tu devras faire la relation entre le paramètre physique mesuré (angle en °) et la valeur de ton capteur.
Si tu veux pouvoir tourner la caméra tu peux très bien mettre la consigne en paramètre d'entrée de la fonction
A+!
Salut SportsEngine, un grand merci pour toutes tes réponses et conseils qui vont bien me servir.
Etant toujours en phase recherche, je tâcherais de poster sur ce message l'avancement du projet.
Encore merci !
