Maxi Servo-Moteur I2C

Présentation de mon servo-moteur "Maison" commandé en I2C par une Raspberry PI.

Les sources et documentations complètes de ces programmes sur GitHub:
- Firmeware Arduino: https://github.com/Nao974/M-BOXE
- M-BOXE Manager GUI: https://github.com/Nao974/M-BOXE_MANAGER_TK
- M-BOXE Manager CL: https://github.com/Nao974/M-BOXE_MANAGER_CL

NEW! Le détail du montage de la V1 en bas de page.

Dans la suite de ce tutoriel, notre Servo-Moteur sera nommé M-BOXE (M comme Moteur, Mobile, Mouvement, ...).
  

• Comme tout servo-moteur, notre M-Boxe devra se positionner à un angle donné et le tenir (c'est un minimum pour un servo-moteur :) ),
• Nous pourrons paramétrer les limites gauche et droite, la position de départ, etc...
• Sauvegarder ces paramètres même après arrêt de l'arduino (sans Carte SD),
• Nous souhaitons également lire sa position, pour par exemple apprendre des mouvements à notre robot,
• Avoir la consommation du moteur, pour savoir si elle force (bloquée par un obstacle ?),
• Puisque nous remontons déjà certaines informations, pourquoi ne pas faire également remonter les entrées analogiques et numériques disponibles sur l'arduino, cela permettra de libérer la carte centrale de notre robot, 
• Nous utiliserons une Raspberry PI pour commander notre M-Boxe,
• Avec éventuellement plusieurs M-Boxe à commander et les informations ci dessus à faire remonter vers la Pi, nous utiliserons le protocole I2C pour faire communiquer tout le monde.

Il n'y a pas de difficulté particulière à sa fabrication, il suffit de suivre le schéma de câblage et récupérer les différentes sources, mais je vous préconise la lecture de ce Tutoriel et des liens connexes afin de comprendre et améliorer le montage et les programmes. 

Pour faire simple, nous avons notre M-BOXE à une certaine position (angle réel) , nous souhaitons qu'elle se place à un angle donné (notre consigne), l'arduino devra commander le moteur afin que l'angle réel se rapproche le plus possible de notre consigne.
A lire: Un moteur qui a de la tête

Nous effectuerons donc dans une boucle les opérations suivantes qui seront détaillées par étape plus bas:

   - lecture de la position actuelle
   - comparaison avec la consigne
   - calcul de la commande moteur en fonction de la différence
   - commande du moteur

   - lecture de la position actuelle
   - comparaison avec la consigne
   - calcul de la commande moteur en fonction de la différence
   - commande du moteur

   - etc...

Cela s'appelle un Asservissement (détail dans les étapes suivantes).

Afin de connaitre l'angle actuel de notre M-Boxe, nous allons monter un potentiomètre sur l'arbre du moteur et lire sa valeur à partir d'un port analogique de notre Arduino.

Avant tout, à lire:  Lire la valeur de la tension aux bornes d'un potentiomètre

Il vous faut:
   - un potentiomètre linéaire à rotation avec un diamètre central correspondant à votre arbre moteur
   - un morceau de plaque perforée,
   - un peu d'astuce pour le montage.

Des potentiomètres avec un trou central à la place de la tige existent mais je n'en ai pas trouvé.

=> Bricolage:
   - démonter le potentiomètre,
   - souder le socle avec la piste résistive sur la plaque perforée, cette plaque vous servira à fixer ce socle dans la M-Boxe afin qu'il reste fixe,
   - monter le curseur métallique (sur une pièce en plastique si nécessaire) , il devra être fixe sur l'axe du moteur,

ATTENTION, les parties métalliques du potentiomètre ne doivent pas être en contact avec l'arbre du moteur.

Si vous avez suivi le lien de l'étape précédente, vous êtes en mesure le lire la valeur du potentiomètre que vous avez monté sur l'axe de votre moteur.
Avant de s'attarder sur les calculs d'asservissement, voyons comment piloter le moteur à partir de notre Arduino.

La carte de commande doit être en accord avec la puissance de votre moteur. Le moteur MFA 950D1481 correspond à mes besoins en terme de taille, de vitesse (85 rpm sous 12v) et de puissance (18 kg/cm).

J'ai opté pour la carte MC33926 de chez Polulu car elle permet de commander un moteur à CC dans les deux sens jusqu'à 3A en continue et 5A en pic, elle se commande par PWM, elle est protégée contre les surintensités et la surchauffe, une sortie analogique permet d'avoir la consommation du moteur.

Je n'ai pas trouvé de librairie Arduino spécifique à cette carte, j'ai donc adapté  la librairie de la carte DUALMC33926. Vous la trouverez dans le dépôt du code source (ref. en fin du tuto), il vous suffit de l'importer dans votre IDE: cliquer sur Croquis-> importer Bibliothèque-> ajouter Bibliothèque.

A lire: Pont en H et commande PWM

exemple de code source:

include <Ah_MC33926MotorDriver.h>

Ah_MC33926MotorDriver md;

void stopIfFault()
{
  if (md.getFault()==1)
  {
    Serial.print("\n !!! fault !!!");
    //while(1);
  }
}

void setup()
{
  Serial.begin(115200);
  Serial.print(" MC33926 Motor Driver:");
  md.init();
}

void loop()
{
  Serial.print("\n0=>400:   Current= ");
  for (int i = 0; i <= 400; i++)
  {
    md.setSpeed(i);
    stopIfFault();
    if (abs(i) 0 == 100)
    {
      Serial.print(md.getCurrentMilliamps());
      Serial.print(", ");
    }
    delay(2);
  }
 }

OK, on sait lire l'angle actuel, faire tourner notre moteur; mais à gauche ou à droite ? pendant combien de temps ? à quelle vitesse ? le but est d'arriver à l'angle de consigne et y rester.

Nous parlons bien ici d'Asservissement.

Pour cela, nous devons lire l'angle actuel et le comparer à la consigne toutes les x ms, qu'importe ce que fait l'Arduino à ce moment précis. Nous allons donc utiliser les ....... Interruptions.

 Nous paramétrons le TIMER2 (je vous laisse chercher ce que font les autres TIMERs) afin qu'il génère une interruption toutes les 1 ms qui appellera notre fonction de correction PID.

Correction PID... c'est quoi ?
   Proportionnel
   Intégral
   Dérivé

C'est une formule qui va nous permettre de calculer le mouvement à effectuer par le moteur afin d'arriver à la consigne.

A lire: Asservissement d’un moteur à courant continu qui vous détail la formule et le fonctionnement.
Le code source est documenté et les coefficients paramétrables.

Pour le réglage de vos coefficients PID, la fonction debug (define DEBUG true) permet de récupérer les données afin de les importer sous Excel et faire un graphique, vous permettant ainsi de visualiser vos différents essais.

Yes, we can ! certains vous dirons la Pi fonctionne en 3,3V et mon Arduino en 5V, je vais griller ma Pi... C'est pas faux.... si c’était l'Arduino le Maître et la Pi l’esclave, mais nous allons faire l'inverse :) 

D'abord, si la notion de maître // esclave en I2C vous est étrangère, merci de lire Un tutoriel I2C pour Arduino

Donc puisque la Pi est le maître, elle fournit d'une part le signal d’horloge SCL et place la ligne de donnée SDA à l'état haut, c'est à dire 3,3V. L'arduino bien que travaillant en 5V reconnait l'état haut à 3,3V et donc peut suivre le signal d'horloge.
Concernant les données, elles sont transmises par le passage à l'état bas de la ligne SCL donc pas de problème de voltage, lire Wikipédia pour les détails sur le protocole I2C.

Le tutoriel suivant: Raspberry Pi – Arduino – Lier les deux via le bus I2C décrit le paramétrage et le fonctionnement coté Pi, et la librairie <Wire.h> coté Arduino.

Le code source est bien documenté, et l'ensemble des commandes I2C implémentées sont détaillées sur le wiki du dépôt. (voir étape Ressources).

A l'étude du fichier source, vous verrez qu'un certains nombres de paramètres sont modifiables afin d'adapter au mieux votre M-Boxe à votre robot (offset, borne gauche, borne droite, coefficients du PID, etc..). 

Malheureusement, une fois l'alimentation coupée de votre Arduino, Pshiiit tout s'efface. Nous pourrions ajouter un lecteur de carte SD pour sauvegarde notre configuration... mais une autre solution existe... 

Elle s'appelle <EEPROM.H>

Cette librairie Arduino permet de sauvegarder des données dans la mémoire réservée au stockage des programmes, elle permet également de les relire ( c'est bien aussi :) )

A lire: Forum EEPROM.H

Comme indiqué dans ma présentation, la structure de ma M-Boxe fait partie intégrante du squelette de mon robot, ses mensurations sont donc calculées suivant la taille finale du bras robotique et non à minima pour faire rentrer l'ensemble des composants.

Mon prototype est en cornière plastique.... j'avais dans l'idée d'utiliser des cornières en fer ajourées qui servent normalement au montage d'étagère, mais l’avènement des imprimantes 3D me font pencher vers cette nouvelle solution.

Soyez ingénieux et indiquez moi vos idées en commentaires.

En photo le câblage complet. Il est important de séparer l'alimentation de puissance du moteur de la partie électronique, j'utilise une alimentation de PC afin d'avoir du 12V pour le moteur et du 5V pour l'Arduino et la carte de commande du moteur.

Code source Arduino + Librairie de commande I2C en Python: https://github.com/Nao974/M-BOXE
M-BOXE Manager GUI: https://github.com/Nao974/M-BOXE_MANAGER_TK
M-BOXE Manager CL: https://github.com/Nao974/M-BOXE_MANAGER_CL

De nombreux documents sont disponibles dans la section fiches techniques.

Merci d'avoir suivi ce tutoriel et n'hésitez pas à me laisser un commentaire et faire évoluer les codes sources.

Présentation du montage de la V1 de notre M-Boxe.