Capteurs magnétiques et Arduino : un V2 en meccano-elec

Fichier hébergé par Archive-Host.com

Dans ce bi-cylindre en V, façon moteur de moto Harley Davidson, on utilise de très petits aimants, petits mais costauds ! Le programme est le même que le précédent, les branchements sont les mêmes, seuls les réglages des capteurs et aimants différent. Le volant comporte un contrepoids important pour équilibrer l’ensemble mobile.

On peut aussi utiliser le code suivant où l’on autorise les deux bobines à travailler en même temps si les deux détecteurs le commandent. Une alimentation de 12 V suffit pour entraîner l’ensemble avec allégresse quand les réglages des aimants sont effectués avec soin.


// bicylindre meccano-elec
// controle de l'alimentation de bobine
// grace à 2 mini-aimants et
// 2 capteurs magnetiques DFR0033
// special moteur "Harley"
// on autorise que les deux bobines soient actives en meme temps
 
int E1 = 5;     //M1 vitesse
 
int M1 = 4;     //M1 sens

int E2 = 6;     //M2 vitesse
 
int M2 = 7;     //M2 sens

// Quand l'aimant est détecté le signal est à l'état bas
 
int detection = 0; 
 
// signal du detecteur magnetique 1 sur Pin 8
int sensor1Pin = 8 ;
// signal du detecteur magnetique 2 sur Pin 9
int sensor2Pin = 9 ;
 
// Led qui s'allume quand la bobine1 est alimentée
int led1Pin = 11; 

// Led qui s'allume quand la bobine2 est alimentée
int led2Pin = 12; 

 
void setup(void)
{
    // controle sortie moteur M1
    // utilisée pour la bobine
    pinMode(E1, OUTPUT); 
    pinMode(M1, OUTPUT); 
    
    // controle sortie moteur M2
    // utilisée pour la bobine
    pinMode(E2, OUTPUT); 
    pinMode(M2, OUTPUT); 
    
    
    // capteurs magnetique
    pinMode(sensor1Pin,INPUT);    
    pinMode(sensor2Pin,INPUT);
    
    // led de controle
    pinMode(led1Pin,OUTPUT);
    pinMode(led2Pin,OUTPUT);
  
    digitalWrite(M1,HIGH);   // fixer sens en avant
    digitalWrite(M2,HIGH);   // fixer sens en avant    
   
}
 
void loop(void)
{  
   
  if (digitalRead(sensor1Pin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (led1Pin, HIGH); 
        digitalWrite   (led2Pin, LOW); 
       // alimenter bobine plein pot  
        analogWrite(E1,255);       
       }
  
    if (digitalRead(sensor2Pin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (led2Pin, HIGH);
        digitalWrite   (led1Pin, LOW); 
        
       // alimenter bobine 2 plein pot  
        analogWrite(E2,255);
       }
      
      if ((digitalRead(sensor1Pin) != detection ) && (digitalRead(sensor2Pin) != detection ) )
      
          {  analogWrite(E1,0);      
             analogWrite(E2,0);
             digitalWrite(led1Pin, LOW);
             digitalWrite(led2Pin, LOW); 
           }
      
}

Capteurs magnétiques et Arduino : moteur bicylindre meccano-elec

Fichier hébergé par Archive-Host.com

Fichier hébergé par Archive-Host.com


// bicylindre meccano-elec
// controle de l'alimentation de bobine
// grace à 2 mini-aimants et
// 2 capteurs magnetiques DFR0033
 
int E1 = 5;     //M1 vitesse
 
int M1 = 4;     //M1 sens

int E2 = 6;     //M2 vitesse
 
int M2 = 7;     //M2 sens

// Quand l'aimant est détecté le signal est à l'état bas
 
int detection = 0; 
 
// signal du detecteur magnetique 1 sur Pin 8
int sensor1Pin = 8 ;
// signal du detecteur magnetique 2 sur Pin 9
int sensor2Pin = 9 ;
 
// Led qui s'allume quand la bobine1 est alimentée
int led1Pin = 11; 

// Led qui s'allume quand la bobine2 est alimentée
int led2Pin = 12; 
 
void setup(void)
{
    // controle sortie moteur M1
    // utilisée pour la bobine
    pinMode(E1, OUTPUT); 
    pinMode(M1, OUTPUT); 
    
    // controle sortie moteur M2
    // utilisée pour la bobine
    pinMode(E2, OUTPUT); 
    pinMode(M2, OUTPUT); 
    
    
    // capteurs magnetiques
    pinMode(sensor1Pin,INPUT);    
    pinMode(sensor2Pin,INPUT);
    
    // leds de controle
    pinMode(led1Pin,OUTPUT);
    pinMode(led2Pin,OUTPUT);
  
    digitalWrite(M1,HIGH);   // fixer sens en avant
    digitalWrite(M2,HIGH);   // fixer sens en avant    
   
}
 
void loop(void)
{  
   
  if (digitalRead(sensor1Pin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (led1Pin, HIGH); 
        digitalWrite   (led2Pin, LOW); 
       // alimenter bobine 1 plein pot  
        analogWrite(E1,255);
        analogWrite(E2,0);
      }
  else 
    if (digitalRead(sensor2Pin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (led2Pin, HIGH);
        digitalWrite   (led1Pin, LOW); 
        
       // alimenter bobine 2 plein pot  
        analogWrite(E2,255);
        analogWrite(E1,0);
      }
      else {  analogWrite(E1,0);      
              analogWrite(E2,0);
             digitalWrite(led1Pin, LOW);
             digitalWrite(led2Pin, LOW); 
           }
      
}

On devrait pouvoir s’en sortir avec un seul capteur pour alimenter ce bicylindre en écrivant le programme adéquat mais c’est difficile car il y a des décrochages aléatoires (on pert la détection alors que l’aimant est là). En utilisant deux capteurs comme dans ce montage on obtient un fonctionnement sans souci.

Capteurs magnétiques et Arduino

Voici un montage où on a fabriqué un moteur monocylindre horizontal avec des pièces meccano-elec (Electrikit) et où on calcule sa vitesse de rotation.

Dans ce montage deux capteurs magnétiques sont utilisés :

– un capteur pour calculer la vitesse de rotation, face à un gros aimant meccano-elec

– un capteur pour déclencher l’alimentation de la bobine au bon moment, face à un minuscule aimant (fixation sécurisée sur la poulie 25mm avec de la superglue)

Fichier hébergé par Archive-Host.com

Fichier hébergé par Archive-Host.com

Côté Arduino Uno, le sketch utilisé pour faire fonctionner le tachymètre est celui de l’article précédent.

Côté DFRduino, le sketch ci-dessous est utilisé pour alimenter la bobine.

La bobine n’est pas alimentée en permanence mais seulement pendant environ 140° sur 360. Une led de contrôle permet de visualiser quand la bobine est alimentée ; cela débute quand le noyau (« le piston ») entame de rentrer dans la bobine et cela cesse quand il est complètement rentré. Il y a donc un peu de réglage à faire mais rien d’insurmontable.

L’aimant du tachymètre est disposé de façon dissymétrique volontairement afin d’équilibrer l’ensemble mobile.

Quand on fait varier la tension en entrée du DFRduino de 12 à 15V la vitesse varie de 290 à 420 tours/min. La bobine reçoit un peu moins de volts et seulement pendant une fraction du temps. Ce moteur n’est toutefois pas conçu pour fonctionner de façon continue (risque d’échauffement de la bobine).
Le moteur démarre seul mais dans certaines positions seulement.

Le mini-aimant fait son boulot de contrôle d’allumage de façon satisfaisante mais il ne peut pas être employé pour le tachymètre ; en effet le champ magnétique un peu faible que génére le mini-aimant provoque de nombreuses coupures dans la détection magnétique et rend impossible un calcul précis du nombre de tours. Ces petites coupures sont par contre mieux supportées pour la partie alimentation de la bobine.


// Monocylindre meccano-elec
// controle de l'alimentation de bobine
// grace à mini-aimant et
// capteur magnetique DFR0033

int E1 = 5;     //M1 vitesse

int M1 = 4;     //M1 sens

// Quand l'aimant est détecté le signal est à l'état bas

int detection = 0; 

// signal du detecteur magnetique sur Pin 8
int sensorPin = 8 ;

// Led qui s'allume quand la bobine est alimentée
int ledPin = 12; 

void setup(void)
{
    // controle sortie moteur M1
    // utilisée pour la bobine
    pinMode(4, OUTPUT); 
    pinMode(5, OUTPUT); 
    // capteur magnetique
    pinMode(8,INPUT);
    // led de controle
    pinMode(12,OUTPUT);
 
    digitalWrite(M1,HIGH);   // fixer sens en avant
  
}

void loop(void)
{  
  
  if (digitalRead(sensorPin) == detection )  
      { 
        // allumer Led pour controle
        digitalWrite   (ledPin, HIGH); 
       // alimenter bobine plein pot  
        analogWrite(E1,255);
      }
  else  
    {
    // eteindre led
    digitalWrite   (ledPin, LOW); 
    // ne plus alimenter bobine
    analogWrite(E1,0) ;
    }
  
}

Mesurer la vitesse d’un moteur avec un Arduino et un capteur magnétique

Fichier hébergé par Archive-Host.com

Voici un autre tachymetre utilisant un capteur magnétique de chez DFRobot (DFR0033). C’est un capteur digital donc la Pin à laquelle il est relié ne pourra être que dans deux états : 0v ou 5v. (Sur ce capteur : aimant detecté -> état bas ; aimant non détecté -> état haut).

L’aimant utilisé provient d’une boîte meccano-elec.

Côté Arduino les branchements sont très simples :

Fichier hébergé par Archive-Host.com

Le programme est ci-dessous , les résultats sont affichés sur le moniteur série. L’utilisation des interruptions dans le programme ne donnant pas de bons résultats, j’ai utilisé une méthode plus classique qui fonctionne bien.


//
//
// Tachimetre V3
// choisir un aimant suffisamment puissant
// sinon nombreux changements d'état parasites
// qui donnent des vitesses surévaluées
 
int sensorPin= 2; // Pin reliée au capateur magnétique
 
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
 
 
void setup () {
   
  Serial.begin (19200);
   
  pinMode(sensorPin,INPUT);
  
  Serial.println ("En cours de mesure ...");
   
  chrono_depart = millis();
}
 
void loop() {
   
  etat = digitalRead(sensorPin);   
 
  // est-ce qu'on peut encore continuer le test ?
   
  if (millis()- chrono_depart < duree_test) { 
 
 // est-ce que l'etat de la Pin a changé ?
    
  if (etat != ancien_etat) { 
       
      nb_chgt = nb_chgt + 1 ;
       
    // Serial.println("####################");
       
    // Serial.println  (nb_chgt);
              
      ancien_etat = etat;
       
     }  
  } else {
     
 // On est arrive au bout du test, on affiche le resultat
 // petite ruse : il y a 4 changements d'état par tour 
 // avec le type de montage de l'aimant choisi
 // en faisant un test sur 15 secondes le nb de chgt
 // a la meme valeur que le nombre de tours par minute

  Serial.print  ("Vitesse : ");
  Serial.print (nb_chgt); 
  Serial.println (" trs/min"); 
  
   // on repart pour un autre test   
  delay(1000);
  Serial.println ("En cours de mesure ...");  
  chrono_depart=millis();
  nb_chgt = 0;
   
  }
   
}

Le montage du capteur est bien plus simple qu’avec une fourche optique ; attention, si l’aimant est trop faible, les résultats sont fantaisistes. Le capteur est monté sur l’arbre de sortie d’un moteur synchrone afin d’avoir un bon étalon de vitesse (ici 750 trs/min). Le moteur synchrone est décrit ici.

Tachymetre : mesurer la vitesse d’un moteur avec un Arduino

Fichier hébergé par Archive-Host.com

Voici un tachymetre réalisé avec un Arduino Uno. Pour le monter je suis allé cherché des éléments déjà tous présents sur ce site, il a suffi de raccorder tout ça.

Pour rendre le tachymètre indépendant d’un PC, on a connecté un écran LCD. J’ai trouvé que le module DFR0063 (LCD1602) était très intéressant car pour afficher deux lignes de 16 caractères, 4 fils seulement sont nécessaires : le + le – et deux fils de signal.

Pour les branchements de l’écran, le schéma présenté sur le site de DFRobot ne correspond pas exactement à l’exemplaire d’écran LCD que j’ai sous la main (position de SCL et SDA inversée sur le schéma). Pour que cela marche, SDA doit être relié à l’entrée analogique 4 et SCL à l’entrée analogique 5. (Pour voir le nom des Pins regarder sur la face arrière de l’écran).

La partie signal de la fourche optique est reliée à la pin 2.

Voici le schéma de la fourche optique.

Il existe des fourches optiques prêtes à l’emploi, voir par exemple le kit DFrobot SEN0038, mis en oeuvre ici

Le sketch utilise les interruptions, pour plus d’informations voir le chapitre 5 de l’introduction Arduino.


// Tachymetre V0
 
 
#include <Wire.h> // librairie standard
#include <LiquidCrystal_I2C.h> // librairie à télécharger
 
// Parametrer l'adresse du LCD à 0x27 
// pour deux lignes de 16 caractères
 
LiquidCrystal_I2C lcd(0x27,16,2);  

long vitesse = 0;
 
long chrono = 0; // valeur courante du chrono
 
long chrono_depart = 0; // valeur de départ du chrono
 
long duree_test = 3000; // test sur 3 secondes
 
volatile long nb_chgt = 0; // nb de changement etat Pin
 
// Gestion de l'interruption 0
 
void gere_int0() { 
    nb_chgt = nb_chgt + 1 ;  
}
 
void setup () {

   
   lcd.init();     // initialiser le lcd 
   lcd.backlight(); // allumer écran
   lcd.print("Vitesse trs/min :    "); // affichage fixe
    
  chrono_depart = millis();
 
// l'interruption zero correspond à la pin 2 
// on enregistre tous les changements d'état
   
  attachInterrupt(0,gere_int0,CHANGE); 
   
}
 
void loop() {
 
  chrono = millis();
 
// est-ce que le test est fini ?
   
  if (chrono - chrono_depart > duree_test) { 

   lcd.setCursor(0,1); // curseur début deuxième ligne
   lcd.print("    "); // effacer la mesure précédente
   lcd.setCursor(0,1); // curseur début deuxième ligne    

  
   // la barre a deux extrémités on a donc
   // pour un tour les 4 états suivants :
   // pas de barre -> barre 
   // barre -> pas de barre
   // pas de barre -> barre
   // barre -> pas de barre
   // Il y a 4 donc changements d'état par tour

   // Mesure sur 3 secondes :
   // il faut multiplier le nb de chgt par 20
   // pour avoir le nb de changement par minute

   // Comme on a 4 changements d'état par tour
   // il suffit de multiplier par 5 le nb de chgt
   // mesuré sur 3 secondes
   // pour avoir le nombre de tours/min

   vitesse=nb_chgt*5;
   lcd.print(vitesse);            
    
   chrono_depart = millis(); 
   nb_chgt=0;
  }     
}

Pour que le résultat soit correct il faut que le dispositif qui tourne au milieu de la fourche optique (ici une barre meccano-elec trois trous dont on a bouché les deux trous libres) soit disposé avec soin et tourne bien rond.

Pour se donner une idée, un moteur « Richard » 6 vitesses alimenté en 12 V avec le rapport 1/6 tourne à environ 2000 tours/min.