Meccano + Arduino : mesurer la vitesse de rotation d'un moteur

Je possède différents modèles de moteurs Meccano, et pour savoir lesquels sont les mieux adaptés selon le montage, je voulais connaitre une de leurs caractéristiques principale : leur vitesse de rotation en tours par minute (souvent abrégé en RPM pour rotation per minute en anglais). Pour cela, il existe à ma connaissance deux méthodes : la première utilisant un phénomène physique appelé effet Hall, et basé sur la variation de tension provoqué par un courant traversant un aimant fixé sur l'arbre du moteur ; et la deuxième basée sur un faisceau infrarouge. C'est cette méthode que j'ai utilisé. Son principe est le suivant : un disque opaque pourvu de trous laissant passer la lumière est placé entre l'émetteur infrarouge et le récepteur. Lorsqu'un trou passe devant le capteur, le récepteur reçoit le signal et retourne la valeur 1, et lorsqu'une partie pleine passe, le signal est coupé et le capteur renvoie la valeur 0. De cette manière, on peut connaitre la vitesse de rotation du moteur en comptant le nombre de trous "vus" par le capteur durant un intervalle de temps donné.

Le capteur :

J'ai utilisé ce capteur trouvé sur eBay pour 1,50€ :

Une des colonnes en plastique contient l'émetteur, l'autre le récepteur. Il dispose de 3 pins : ground, +5V et out qui envoie 0 ou 1 comme dit plus haut. Il dispose en outre d'une petite LED intégrée qui s'allume si le signal passe, et qui fonctionne indépendamment du programme mis dans la carte Arduino, ce qui est pratique pour vérifier le comportement du capteur. La fourche étant petite (10mm de large sur 10mm de hauteur), il faut vraiment la positionner sur le bord de la roue perforée, et veiller à ce que celle-ci ne soit pas trop large. Dans mon cas, j'ai tout simplement utilisé une roue dentée Meccano, qui est évidemment munie de trous comme toutes les pièces Meccano (8 trous en l’occurrence).

Le moteur :

Pour ce premier test, j'ai pris un moteur 4,5V des années 70 appelé "Junior Power Drive Unit" ou plus simplement "Reversible 4,5V DC Motor". La notice d'origine indique une vitesse de 1000 tr/min, que je vais pouvoir vérifier maintenant.

Le montage :

Le montage est très simple : le moteur est alimenté par une batterie 12V à travers un abaisseur de tension pour arriver à sa tension nominale de 4,5V. Le capteur est placé devant la roue et est branché sur la carte Arduino (le shield moteur visible sur la photo n'est pas utilisé). Enfin, la carte est reliée à l'ordinateur par USB pour l'alimentation et l'envoi des données mesurées.

Le programme :

/*Code adapté de celui de CMPalmer :
 * http://www.instructables.com/id/Arduino-Based-Optical-Tachometer/step4/Programming/
 */

volatile int rpmcount;  //compte le nbre de fois où le faisceau du capteur optique est coupé
float rpm;  //la variable qui va afficher le nombre de tours, et qui sera mise à jour dans le loop()
unsigned long timeold;  //sert à enregistrer le temps écoulé depuis la dernière mise à jour du compteur
unsigned int nbTrous=8;  //le nombre de trous dans la roue fixée sur l'arbre du moteur

void rpm_counter()
{
  //A chaque rotation du moteur, cette fonction d'interruption est appelée [nbTrous] fois
  rpmcount++; //on incrémente le compteur
}

void setup()
{
  Serial.begin(9600);  //initialisation de la liaison série

  //la pin "out" du capteur doit être reliée sur une pin de l'arduino gérant les interruptions
  //sur mon Arduino Mega 2560, je l'ai branché sur la pin 21, qui correspond à Interrupt 2
  //voir http://arduino.cc/en/Reference/attachInterrupt pour plus d'infos sur les interruptions avec 
  //les pins associées suivant votre modèle de carte

  //la fonction rpm_counter sera appelée sur chaque front descendant (FALLING) de la pin 21
  attachInterrupt(2, rpm_counter, FALLING);

  //initialisation des variables
  rpmcount = 0;
  rpm = 0;  
  timeold = 0;  
}

void loop()
{
  //on met à jour le compteur toutes les 500 ms
  delay(500);

  //le traitement des interruptions est stoppé pendant les calculs
  detachInterrupt(2);

  //calcul du nombre de rotations par minute (rpm) :
  //rpm = [nbre de rotations depuis le dernier calcul]/[temps écoulé en ms]*[60000ms(=1min)]/[nbre de trous]
  rpm = (float)rpmcount/(millis() - timeold)*60000.0/nbTrous;

  timeold = millis();  //on actualise timeold pour le prochain calcul
  rpmcount = 0;  //on remet à zero le compteur avant le prochain calcul

  //on affiche la valeur sur le moniteur série
  Serial.println(rpm);

  //on rédemarre le traitement des interruptions
  attachInterrupt(2, rpm_counter, FALLING);
}

Les résultats :

J'ai fait tourner le programme pendant 50s pour avoir 100 valeurs qui m'ont permis de tracer la courbe suivante :

La moyenne est de 1656,47 tr/min, soit largement plus que les 1000 tr/min indiqués dans la notice !

Meccano : ventilateur

L'autre jour en surfant sur 9gag je suis tombé sur ce Gif montrant le fonctionnement interne du mécanisme d'oscillation de la tête d'un ventilateur (pour une fois que j’apprends quelque chose en allant sur 9gag !) :

Je ne m'étais jamais vraiment posé la question de savoir comment est gérée le va-et-vient d'un ventilateur, mais après avoir vu cette image j'ai trouvé que le principe du mécanisme est vraiment bien pensé : en effet, si l'on regarde bien on s'aperçoit que le mouvement d'entrée du système provient du même moteur que celui qui fait tourner les pales du ventilateur. Il s'ensuit un petit réducteur à deux étages (vis sans fin/roue 1 et pignon/roue 2). La partie la plus intéressante du mécanisme est la bande qui est fixée de façon excentrée sur la roue 2 et qui permet de transformer le mouvement de rotation uniforme du moteur en mouvement de va-et-vient (le Gif ci-dessus ne montre que le début du mouvement, lorsque la roue 2 finit son tour le ventilateur revient dans l'autre sens).

Mais ce qui m'a surtout attiré dans ce système c'est qu'il est très facile à reproduire en Meccano ! Après quelques tours de clé, voici le résultat :

Alors certe ce ventilateur là n'est certainement pas le plus efficace pour se rafraichir, mais en cette saison ce n'est pas vraiment un problème :)
La partie qui nous intéresse ici est bien évidemment le réducteur, qui se trouve de l'autre côté :


La seule différence notable avec le système original est le positionnement du moteur à la verticale avec un renvoi sur une roue de champ pour obtenir un axe de rotation des pales suffisamment long. Vous remarquerez aussi que pour des soucis d'encombrement la bande excentrée n'est pas fixée directement sur la roue 2 (celle située sous la vis sans fin dans mon cas), mais sur une roue à barillet solidaire du même axe de rotation. La photo ci-dessous montre plus en détail cette partie :

Pour bien comprendre le fonctionnement du système, il est important de noter les points suivants :

• La tête du ventilateur est solidaire de la poulie rouge supérieure;
• La poulie supérieure tourne librement autour de son axe;
• Cet axe ainsi que la poulie inférieure sont fixés au socle et ne peuvent donc pas bouger;
• La bande zinguée est fixée de façon excentrée sur la roue à barillet ET sur la poulie inférieure, mais n'est pas montée serrée.

Au final, ce système se comporte comme un triangle ABC où A est le centre de la poulie supérieure (et par conséquent le centre de rotation de la tête du ventilateur), B est le point de fixation de la bande métallique sur la roue à barillet et C le point d'attache de cette même bande sur la poulie inférieure. Lorsque le système est en fonctionnement la roue à barillet tourne, ce qui cause l'éloignement (ou le rapprochement dans l'autre sens) du point B par rapport au point A. Or si dans notre triangle ABC la longueur du côté AB varie, alors fatalement l'angle BÂC va lui aussi varier et causer la rotation de la poulie supérieure et donc de la tête du ventilateur.

Meccano : double train épicycloïdal

Ce montage relativement simple consiste en un réducteur épicycloïdal à 2 étages. Chaque étage est constitué de 3 pignons de 19 dents et d'une jante moderne (pièce 187C). Cette jante présente l’intérêt d'avoir une couronne de 57 dents sur l'une de ses faces (une particularité qui n'est d'ailleurs utilisée dans aucun modèle "officiel" à ma connaissance !), qui possède le diamètre exact pour contenir les 3 pignons.

L'arbre d'entrée (actionné par la poulie rouge à gauche sur la photo) est relié au pignon central du premier étage (celui de gauche donc). Ce pignon engrène sur les 2 satellites, eux mêmes fixés sur une roue à barillet. Cette roue est solidaire de l'axe de sortie de cet étage, qui est également l'axe d'entrée du second étage puisqu'il est relié au pignon central de ce dernier. Les pignons satellites engrènent bien entendu sur la couronne. Pour finir, l'axe de sortie du second étage (solidaire du deuxième porte-satellite) est fixé sur la poulie de droite, sur laquelle est vissé un pion orange afin de vérifier sa vitesse de rotation.

En bloquant les 2 pneus d'une main et en faisant tourner la poulie de droite avec l'autre, j'ai compté qu'il fallait faire tourner 16 fois la poulie d'entrée pour que la poulie de sortie fasse un tour complet. Ce résultat se vérifie facilement à partir de la formule de calcul de la réduction d'un train épi, dans la configuration où la couronne est fixe, l'entrée est le planétaire intérieur et la sortie est le porte-satellite:

r = Zpignon/(Zpignon+Zcouronne) = 19/(19+57) = 1/4

Comme ce réducteur est composé de 2 étages montés en série, le rapport final est 1/4*1/4 = 1/16.