Moteur 4 pôles double rotor

Voici une version double rotor avec commutateur à 8 plots. Les plots « rouges » alimentent les deux bobines situées devant la plaque jaune 5×9, les plots « bleus » alimentent les 2 autres bobines.

Les points sensibles :

– faire la chasse aux frottements (tout en maintenant des contacts électriques : d’où le réglage par tiges filetées)

– faire attention aux plots : ils sont tellement proches sur la roue barillet qu’ils peuvent entrer en contact.

Fichier hébergé par Archive-Host.com

L’alimentation se fait à partir de 14 v (les bobines sont montées en série par groupe de 2 : chaque bobine ne reçoit alors que 7v).

Couronne et démultiplication

Dans le montage précédent, la vitesse de sortie est supérieure à la vitesse d'entrée , V = (1 +  95  /  57 ) x Ve    et  plus généralement, V = (1 +  Zc / Zp ) x Ve , si Zc  est le nombre de dents de la couronne et Zp le nombre de dents du planétaire

On voit donc que,  quelque soit le choix du nombre de dents et de la couronne, la vitesse de sortie sera supérieure à la vitesse d'entrée…

Comment faire pour obtenir une réduction ? La solution est d'inverser l'entrée et la sortie. Dans ce nouveau montage, l'entrée sera le planétaire et la sortie sera le porte-satellite.

 

Fichier hébergé par Archive-Host.com

Dans la vidéo ci-dessous la poulie jaune à droite est solidaire de l'arbre d'entrée qui porte le planétaire. La poulie grise est solidaire du porte-satellite qui constitue la sortie.  La sortie tourne 2,666 fois moins vite que l'entrée.

 

 

Couronne dentée

Voici un nouveau montage de démonstration utilisant une couronne dentée.

En rouge, le porte-satellite sur lequel est fixé un pignon de 19 dents. En jaune, le planétaire, roue dentée de 57 dents. La couronne dentée a une denture intérieure de 95 dents.

Dans ce montage, l'entrée est le porte-satellite et la sortie le planétaire. On remarque que l'axe d'entrée et l'axe de sortie ont le même centre.

Quand on tourne la manivelle (le porte-satellite), le satellite tourne sur lui même et tourne autour du planétaire  qui est entraîné. Dans le montage ci-dessous, il tourne 2,666 fois plus vite que le porte-satellite.

Le rapport de transmission vaut :  1+ 95/57  

Pour les amateurs de calculs, voici comment on peut  retrouver ce rapport  : epicyclic2

Dans un prochain article, nous verrons comment utiliser un montage semblable pour obtenir une démultiplication, donc un axe de sortie tournant moins vite que l'axe d'entrée.

Meccano trains épicycloïdaux … la suite

Le montage précédent est complété d’une partie droite, la partie gauche inchangée :

La partie droite est composée d’une 57 dents fixe en plastique jaune ; une 50 dents est reliée à la sortie. Les satellites ont 19 et 25 dents.
Le moteur entraîne le porte-satellite.

Si l’on applique la relation de l’article précédent, on trouve que la vitesse de sortie est (1 – (25/50 x 57/19)) fois la vitesse d’entrée soit – 0,5 fois la vitesse d’entrée.

La sortie (poulie grise à droite) de cette partie du mécanisme tourne à la moitié de la vitesse de l’entrée et dans le sens inverse (signe moins).

Meccano trains épicycloidaux : calcul

Comment calculer le rapport de démultiplication d’un train épicycloïdal ?

On peut appliquer des formules mais c’est pas évident de ne pas se planter. Je préfère essayer de retrouver le résultat. Voici un « schéma » du train présenté dans l’article précédent.

Fichier hébergé par Archive-Host.com

Voici un document, pour ceux qui aiment les calculs, expliquant comment on peut trouver la vitesse de sortie en connaissant la vitesse d’entrée et les différents nombres de dents des roues et pignons.

epicyclic1

Meccano engrenages epicycloidaux

Bon voilà la maquette :

– le moteur entraîne le porte satellites (15 dents et 19 dents)
– la roue de 57 dents en plastique jaune est fixe et elle engrène sur les 19 dents
– la roue de 60 dents, au milieu du porte satellite, est reliée à la sortie (poulie jaune), elle engrène sur les 15 dents

Le moteur fait tourner le porte satellites, au même rythme que la poulie grise. Les 19 dents sont bien obligés de tourner sur eux-mêmes car la roue de 57 dents est fixe. Du coup les 15 dents tournent également sur eux-mêmes. Ils entraînent la roue de 60 dents tout en tournant autour d’elle.

En sortie on voit que la poulie jaune tourne nettement moins vite que la grise. Il semble qu’elle tourne 4 fois moins vite.

A suivre …

Meccano moteur courant continu 4 poles

Fichier hébergé par Archive-Host.com

J’ai trouvé l’idée d’un petit moteur courant continu 4 pôles très compact dans le numéro de juillet 1945 des Meccano Magazine. Je n’ai pas réussi à faire fonctionner le modèle des MM, j’ai alors gardé l’idée du rotor mais changé la partie stator.

Voici comment se passe l’alimentation des bobines : une bague d’arrêt porte 4 vis sans tête qui soulèvent un balai meccano elec ; celui-ci vient faire contact au bon moment sur un plot de contact. La croix formée par les 4 pôles du rotor est décalée de 45 degés par rapport à la croix formée par les 4 vis.

Fichier hébergé par Archive-Host.com

Delay() et les interruptions

C’est presque une question philosophique !

Est-ce-que pendant que l’Arduino est occupé à attendre qu’une instruction delay() s’éxécute, il s’occupe quand même de gérer les interruptions ? La doc officielle dit oui mais un commentaire sur le site officiel français dit le contraire… Qui a raison ?

Voici un petit programme qui va nous permettre de le savoir :


/*

Les interruptions sont-elles actives quand delay s'éxécute ???

réponse oui !

Quand on appuie sur le bouton :

- on change d'état la Pin 2 (elle passe à bas)
- la fonction d'interruption se déclenche
- etat change
- la led change d'état

Quand on relache le bouton :

- on change d'état la Pin 2 
(elle passe à haut sous l'effet du rappel au plus, le pull-up)
- la fonction d'interruption se déclenche
- etat change
- la led change d'état

*/

// Pin correspondant au bouton

int Bzero = 2; // la Pin 2 correspond au bouton 

// Pin correspondant à la led

int ledPin = 4; 

// la variable de type volatile qui communique entre la
// fonction d'interruption et la boucle principale (loop)

volatile int etat = HIGH;      

void setup() {
  
  // La pin reliée au bouton est mise en mode INPUT
  
 pinMode(Bzero, INPUT); // Pin en mode entrée
 
  // Activation de la resistance interne pull-up 
    
 digitalWrite(Bzero, HIGH); 
  
 // La pin est mise en OUTPUT pour pouvoir allumer la led
  
 pinMode(ledPin, OUTPUT);  

// l'interruption 0 surveille les changements d'état de la pin 2
 
 attachInterrupt(0, inter0, CHANGE); 
  
  } // setup
  
void loop() {
  
  // on ne fait rien d'autre que d'attendre...

  delay(30000);
     
} // loop


void inter0() 

// s'execute quand on détecte un changement d'état de la Pin 2

{

etat = ! etat; // on change d'état : 
// si on était à haut on passe à bas et si on était à bas on passe à haut

digitalWrite(ledPin, etat);  // allumer ou eteindre la led

} // inter0

Le montage comporte deux résistances de 270 ohms, une du côté du bouton poussoir (ainsi si, on met par erreur la pin2 en OUTPUT, il n’y aura pas de catastrophe), l’autre résistance est en série avec la led lui permettant de fonctionner à la bonne tension. Les fils verts sont reliés à la masse (GND).

Fichier hébergé par Archive-Host.com

Mesure vitesse moteur

Voici un premier montage réalisé avec un Arduino. J’ai regardé le cours « Broches numériques en entrée : utiliser les capteurs numériques ON/OFF avec une carte Arduino » sur www.mon-club-elec.fr J’ai suivi le schéma et réalisé le montage qui utilise une fourche opto-electronique fournie avec le kit à moins de 10 euros chez Gotronic qu’ils conseillent sur ce site. Et j’ai eu l’idée de mesurer avec ce montage la vitesse d’un moteur synchrone meccano. La carte Arduino est placée sous la breadboard. Et on trouve bien pour ce moteur 8 pôles alimenté en 50 Hz, 750 tours/min, c’est chouette !

Fichier hébergé par Archive-Host.com

Fichier hébergé par Archive-Host.com

Un premier exemple de code pour arriver progressivement à ce qu’on veut faire :


//
//
// Chapitre 5 P2

int pinOpto= 2;

int etat = 0;

int ancien_etat = 0;

int nb_chgt = 0;

void setup () {
  
  Serial.begin (19200);
  
  pinMode(pinOpto,INPUT);
}

void loop() {
  
  etat = digitalRead(pinOpto);
   
  if (etat != ancien_etat) {
      
      nb_chgt = nb_chgt + 1 ;
      
      Serial.print ("nb chgt");
  
      Serial.println  (nb_chgt);
             
      ancien_etat = etat;
      
     }  
   
     
}

un second exemple :


//
//
// Chapitre 5 P3

int pinOpto= 2; // Pin reliée à l'opto coupleur

int etat = 0; // etat Pin 

int ancien_etat = 0; ancien etat Pin

long chrono = 0; // valeur courante du chrono

long chrono_depart = 0; // valeur de départ du chrono

long duree_test = 15000; // test sur 15 secondes

int nb_chgt = 0; // nb de changement etat Pin

boolean affiche = 1;

// pour afficher une seule fois la vitesse

void setup () {
  
  Serial.begin (19200);
  
  pinMode(pinOpto,INPUT);
  
  chrono_depart = millis();
}

void loop() {
  
  etat = digitalRead(pinOpto);
  
  chrono = millis ();
  
  if (chrono - chrono_depart < duree_test) { 

// est-ce qu'on peut encore continuer le test ?
   
  if (etat != ancien_etat) { 

// est-ce que l'etat de la Pin a changé ?
      
      nb_chgt = nb_chgt + 1 ;
      
      Serial.println("####################");
      
     Serial.println  (nb_chgt);
             
      ancien_etat = etat;
      
     }  
  } else {
    
  if (affiche == 1) {
  
  Serial.print  ("Vitesse : ");
  Serial.println (nb_chgt);    
// petite ruse : il y a 4 changements d'état par tour 
// en faisant un test sur 15 secondes le nb de chgt
// a la meme valeur que le nombre de tours par minute
  Serial.println (" trs/min"); 

  affiche=0;
  
  }
  
  }
  
}

Ca fonctionne !

Fichier hébergé par Archive-Host.com

Voir le chapitre 5 dans « Introduction Arduino » pour aller plus loin en utilisant les interruptions…

Moteur meccano-elec mono-cylindre à courant continu

Voici un petit modèle de moteur qui fonctionne très bien

 

On utilise des pièces meccano-elec (Electrikit) en particulier une tringle qui comporte un méplat. Lorsque la tringle tourne le balai en cuivre monte et descend faisant ou non contact.

Le moteur fonctionne dès 9v ; il y a un petit réglage à faire : il faut que le contact se fasse quand le noyau commence à remonter dans la bobine.

Le moteur doit généralement être lancé à la main mais en choisissant bien la position de démarrage, il peut démarrer seul.