Détecter la coupure d’un faisceau infrarouge (partie 1) barrière infrarouge

Comment utiliser un émetteur et un récepteur infra-rouge pour détecter la coupure d’un faisceau ?

Fichier hébergé par Archive-Host.com

Je suis parti de cet excellent article et j’ai utilisé un émetteur IR de chez DFrobot (DFR0095) et un récepteur IR (DFR0094).

On pourrait faire des choses élaborées avec l’émetteur et le récepteur IR (sur le modèle de ce qu’on fait avec une commande infra-rouge de téléviseur) mais on va commencer ici par quelque chose de très simple : détecter une coupure du faisceau.

La première chose à comprendre, c’est que, dans cettte solution, le signal envoyé par la LED IR n’est pas continu, il est modulé selon une fréquence de 38 khz, comme le fait une télécommande. Le récepteur contient tout le matériel pour décoder ce signal. La lumière émise par la LED n’est pas visible à l’oeil nu, ni avec les appareils photos que j’ai essayés. On emploie l’infra-rouge pour que le détecteur ne soit pas sensible à la lumière ambiante, et le signal est pulsé car on se protège ainsi des interactions avec les infra-rouges ambiants.

La seconde chose à comprendre c’est que la PIN de l’Arduino à utiliser pour brancher la diode émettrice est forcément la PIN 3 si on utilise la librairie IRremote ; la PIN 3 a été choisie parce qu’elle est commandée par un des timers qui sait générer le signal PWM à la bonne fréquence. On pourrait aussi générer par programme ces signaux pulsés mais on n’aurait pas la garantie d’une parfaite régularité comme on l’a avec un timer.

A première vue, ça ne parait pas immédiat de brancher plusieurs paires émetteur/ détecteurs IR de ce type sur un même Arduino.

Dans le montage présenté, on peut suivre ce qui se passe en regardant l’affichage du moniteur série et en observant la LED intégrée à la DFRduino ; quand le faisceau est coupé la LED intégrée à la carte s’allume et le message « Coupure ! » est affiché.

Le programme fonctionne aussi bien sur un Arduino Uno mais la connectique est un peu moins évidente.

Je n’ai pas réussi à obtenir un fonctionnement fiable du programme publié sur le site indiqué en début d’article. J’ai donc fait quelques modifications pour aboutir à un programme qui fonctionne bien. Attention, il faut que l’objet placé devant le détecteur soit opaque et suffisamment étendu pour que la coupure soit détectée.

Si l’on trouve que le détecteur n’est pas assez sensible, il faut diminuer la tension d’alimentation de la LED émettrice (on peut descendre à 2 V pour une distance émetteur/récepteur de 15cm), on verra une solution dans un prochain article qui présentera aussi une façon d’installer 2 paires émetteur / recepteur IR modulées sur un Arduino ou beaucoup plus…


// IR_Beam2

#include <IRremote.h> // librairie à installer

#define PIN_IR 3 // l'emetteur IR, forcément en pin 3

#define PIN_IR_RCV 2 // le recepteur IR

#define PIN_LED 13 // la led s'allume quand coupure

#define COUPURE 1

// pour que le faisceau soit coupé, il faut un objet
// opaque et assez étendu


IRsend irsend; 

int etat = 0;

void setup()
{
  pinMode(PIN_IR_RCV, INPUT);   
  
  pinMode(PIN_LED, OUTPUT);   
 
  irsend.enableIROut(38); // crée une sortie modulée à 38 Khz  
 
  Serial.begin (19200);
}

void loop() {
  
 irsend.mark(0); // envoi signal modulé pour une durée illimitée
 
 etat = digitalRead(PIN_IR_RCV) ; // lecture 
 
 delay (5); // on fait une deuxième lecture
 
 etat = etat * digitalRead(PIN_IR_RCV) ; 

  if ( etat == COUPURE ) { // si les deux lectures voient une coupure       
    
      digitalWrite(PIN_LED, HIGH);          
          
      Serial.println( "Coupure !");          
         
  } else {
          
      Serial.println( "---------OK----------- !");     
      
      digitalWrite(PIN_LED, LOW);      
  }
 
 irsend.space(0); // arret signal modulé pour une durée illimitée

 delay(30);     
    
}

Arduino et Mosfet

Pour commander un moteur avec un Arduino, il faut un dispositif capable de générer une intensité suffisante. Les broches de l’Arduino peuvent envoyer un courant de 40mA maxi ce qui est généralement trop peu pour entraîner un moteur.

On peut bien sûr se procurer des shields ou des modules moteurs tout faits qui fonctionnent très bien, ou utiliser un DFRduino qui combine un Arduino et un module moteur.

L’objet de ce post est de montrer qu’on peut aussi utiliser un type de transistor particulier, un MOSFET, qui permet de mettre en marche et de faire varier la vitesse de moteurs à courant continu.

Ici on a utilisé un MOSFET de type IRF540N ; il en existe de très nombreux types, il ne sont pas tous compatibles avec l’Arduino. En particulier, il faut que la valeur Vgs (Gate Threshold voltage) soit en gros autour de 2 ou 4V. Il existe des Mosfet dits logiques avec des valeurs de Vgs basses (entre 1 et 2V) comme le IRL540N qui fonctionne ausi très bien. D’autres Mosfet, enfin, ont des valeurs Vgs trop élevées que ne pourrait pas atteindre directement en sortie d’une broche Arduino (Maxi 5V).

Autre paramètre important, la valeur Rds(on) que l’on souhaite basse , elle conditionne la chaleur dégagée par le composant en utilisation. Ici on a Rds=0,044 ohms, c’est pas mal mais on trouve mieux.

Le principe du fonctionnement de ce type de transistor est que lorsque la tension de la Gate atteint une valeur suffisante, le courant passe entre le Drain et la Source. (d’autres types de transistors sont commandés en courant, le Mosfet est commandé en tension).

Il existe aussi de très nombreux types de transistors utilisables qui ne sont pas des MOSFET mais ils semblent moins performants pour ce type d’application (chute de tension, chaleur dégagée). Voici un schéma de branchement pour un Mosfet de type N – Channel :

Fichier hébergé par Archive-Host.com

Ces Mosfet sont de braves transistors capables de supporter des intensités étonnantes (33A pour ce modèle !). Mais, attention, si les intensités deviennent importantes, il faut s’équiper d’un radiateur sous peine de destruction du transistor. D’autre part, pour de grosses intensités, une breadboard n’est pas une bonne solution (maxi raisonnable 1A).

Les Mosfet sont costauds ne coûtent pas cher mais sont vulnérables à l’électricité statique.

On peut, avec un potentiomètre sur une entrée analogique et une Pin capable d’envoyer du PWM reliée à la Gate, obtenir simplement une variation de vitesse d’un moteur à courant continu.

Par contre on ne peut pas gérer l’inversion de sens avec ce simple Mosfet. (une solution est de se tourner vers un pont en H). Si le but est simplement de mettre en marche est d’arrêter mais pas de faire varier la vitesse, un relais peut être une solution plus simple.

On peut bien sûr alimenter d’autres dispositifs gourmands en intensité (lampes, bandeaux de LED, solénoïdes…) avec ce montage. De même, imaginer plusieurs potentiomètres commandant la vitesse de rotation de plusieurs moteurs avec un seul Arduino et plusieurs Mosfet ne semble pas compliqué.

Voilà un exemple de code pour un potentiomètre commandant la vitesse de rotation d’un moteur :


// Controle de vitesse d'un moteur en pwm
// avec un Arduino et un Mofset IRF540N
// voir aussi http://bildr.org/2012/03/rfp30n06le-arduino/


int motorPin = 3;     // Controle de vitesse PWM vers la gate du Mofset

int potarPin=0; // on branche un potentiomètre sur la PIn A0

int sensorValue=0; // la valeur entre 0 et 1023 déduite de la position du potentiomètre

int outputValue=0; // la valeur entre 0 et 255 que l'on va utiliser pour régler la vitesse du moteur 



// Executee une seule fois

void setup() {
  
   // initialiser la communication serie 
   
   Serial.begin(19200);
   
   pinMode(motorPin, OUTPUT); // motorPin est utilisee en sortie
   
}

// executee en boucle

void loop() {
  
   // lire la valeur en entrée de la Pin A0 
   
   sensorValue = analogRead(potarPin);
   
   // afficher sur le moniteur série la valeur lue, pas obligatoire mais toujours intéressant
   
   Serial.println(sensorValue);

   // conversion de la valeur sensorvalue (qui va de 0 à 1023) en une valeur entre 0 et 255, outputvalue
   
   outputValue = map(sensorValue, 0, 1023, 0, 255);
   
   // outputvalue permet de controler la vitesse du moteur
   
   analogWrite(motorPin,outputValue );  //  valeur de 0 à 255
   
   delay(100);
}

La résistance de 10 kOhms est importante, elle est du type pull-down : elle ramène la Pin à l’état bas quand la Pin n’est pas alimentée. (risque sinon que la Pin soit dans un état incertain …).

La diode est de type 1N4007 (elle supporte 1000v et 1A) ; placée aux bornes du moteur, elle protège le transistor des tensions importantes qui naissent quand le courant est coupé, elle est indispensable.

Ici j’ai branché deux moteurs pour charger un peu la bête. Le transistor chauffe vraiment peu.(L’intensité consommée par les moteurs est modeste environ 250mA au total).

Fichier hébergé par Archive-Host.com

Remarque : sur le web on trouve plusieurs fois la suggestion de placer une petite resistance entre la Pin en Output de l’Arduino et la Gate du Mosfet. On trouve également plusieurs fois la suggestion… de ne pas utiliser cette petite resistance. Perplexité …

Du coup, j’ai essayé avec une 220 ohms (ça se voit sur la photo). Si on veut dépasser 500 mA en sortie, le transistor chauffe énormément et on ne récupère que peu de volts et d’intensité pour le moteur.
En résumé, ne pas se casser la tête et, au moins pour ce Mosfet, se conformer au schéma en début d’article avec pour seule resistance la 10 KOhms en pull-down ce qui fonctionne très bien.