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 !

[processing.js] Flappy Bird !

Ce que vous voyez ci-dessous est un portage du célèbre jeu mobile Flappy Bird avec Processing.js. Cliquez pour "voler" !

Modélisation 3D : Fauteuil roulant steampunk

L'été dernier, le site de partage de fichiers CAO GrabCAD avait organisé un concours pour réimaginer un fauteuil roulant à la mode steampunk, en partenariat avec ModVic. L'objectif était de concevoir un fauteuil unique pour Kyron, un jeune handicapé souffrant de dystrophie musculaire et fan de l'esthétique steampunk. Le fauteuil de départ est visible ci-dessous :


L'une des consignes à respecter était que le nouveau design conserve la même structure que le système original, car les organisateurs du concours souhaitaient pouvoir modifier ce dernier tout en gardant toutes ses fonctionnalités. A partir de ces éléments, voici le design que j'ai proposé (mais qui n'a malheureusement pas été retenu) :

Pour le siège, j'ai opté pour un fauteuil de l'époque victorienne, et les roues en plastique sont transformées en roues métalliques à rayons comme celles qui équipaient jadis les carosses et les premières automobiles. Vient ensuite un (faux) réservoir de gas à l'arrière, ainsi que des bouches d'échappement inspirées ... par le cornet d'un gramophone ! Enfin, la console de commande sur l'accoudoir se voit affublée d'un manomètre, pour contrôler la pression de la vapeur. Le tout étant réalisé en bois, cuivre et laiton, des matériaux omniprésents dans le monde du Steampunk.

Pour ceux qui voudrait en savoir plus sur ce concours, sachez que ModVic a organisé une campagne indiegogo pour financer la fabrication du design gagnant.

Modélisation 3D : Logicoma (GITS Arise)

Logicoma from Dixbit on Sketchfab.

Ce robot vient de la nouvelle saison de l'excellent anime cyberpunk Ghost in the Shell. Doté d'une intelligence artificielle primitive (primitive par rapport aux autres robots futuristes de l’univers de GITS, parce que du point de vue de la technologie actuelle ce tank sur pattes battrait à plate couture n'importe quel drone !), il aide les membres de ce qui deviendra plus tard la Section 9, dont la fameuse Motoko Kusanagi. On voit d'ailleurs les deux personnages ensemble sur l'affiche du premier épisode :

La réalisation de ce modèle 3D a été assez délicate car au moment ou je l'ai faite (à la fin du printemps dernier), le premier épisode n'était pas encore sorti (y compris au Japon) et les seules références dont je disposais au début étaient les quelques bandes annonces et artworks diffusés par le studio Production I.G. Heureusement j'ai découvert plus tard qu'une reproduction en résine grandeur nature avait été réalisée pour la promotion du film, et les nombreuses photos de cette maquette que j'ai pu trouver sur le Net m’ont beaucoup aidé ! D'ailleurs en voici quelques unes ci-dessous :

la maquette en résine

Logicoma est l'abbréviation de "Logistics Conveyer Machine" (machine de transport logistique en français)

Après avoir posté un premier rendu sur deviantART, j'ai été contacté par une fan japonaise de la série, +Motoko Kuroma (que je remercie au passage), qui m'a envoyé un dessin de préproduction (visible ci-dessous) montrant des détails non visibles sur les photos que j’avais vues jusqu'à présent (notamment l'arrière et le dessous du robot).

Cela m'a donc permis de retravailler le modèle 3D pour être le plus près possible de l'original. Voici donc les rendus de la version finale du Logicoma, réalisé avec le logiciel de CAO Solidworks :

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.