Comptage par franchissement d’une barrière infrarouge



Ici nous utiliserons une carte Arduino qui pilotera une barrière infrarouge pour compter les entrées et les sorties d’un bâtiment afin de connaitre le nombres de personnes à l’intérieur.

Fabrication de la barrière infrarouge (IR)

La barrière sera réalisée avec le kit fourni par Snootlab
image du kit IR de Snootlab
Il contient :

  • Une led émettrice infrarouge
  • Un récepteur infrarouge TSOP32138 (datasheet)
  • Un condensateur de 0.1uF pour filtrer la réception
  • Une résistance de 47 ohms pour le récepteur
  • Deux résistances pour adapter la portée de l’émission : conditions peu ou très perturbées (150 ohms et 68 ohms)

D’un coté nous auront un boitier contenant la diode IR et de l’autre coté un boitier contenant deux récepteur IR, deux afin de déterminer si la barrière et coupée dans un sens ou dans l’autre.
Voici l’émetteur et son circuit :

Et voici le récepteur et son circuit :

La particularité du TSOP c’est qu’il ne réagit qu’à une fréquence IR bien particulière, le TSOP32138 passe sa sortie à l’état bas lorsqu’il reçoit un signal IR modulé à 38 KHz. Il ne sera donc pas (ou moins) perturbé par son environnement.

Ajout de la communication sans fil avec le module NRF24L01+

image du composant nrf24l01+
Le boitier contenant les récepteurs IR communiquera avec un troisième boitier connecté à un ordinateur.
Il lui dira si la connexion sans fil est établie, si la barrière est franchie et finalement dans quel sens elle l’est.
Pour ce faire j’ai utilisé la bibliothèque RF24 écrite principalement par TMRh20.

Codes et circuits

Boitier émetteur IR

boitier emetteur infrarouge

cliquez pour découvrir le code

		/*
		  Emission barrière InfraRouge
		  Emmission d'un signal IR à 38KHz capté par le programme Reception_bar_IR pour créé une barrière infrarouge.
		  http://makerspace56.org
		  Sources : https://github.com/maniacbug/RF24.git & https://github.com/TMRh20/RF24.git
		  Mise à jour : Nov 2016 by Paolo
		*/
		#include <IRremote.h>

		IRsend irsend; // déclaration de l'objet émetteur (diode IR su pin D3 obligatoirement)

		void setup() {
		  irsend.enableIROut(38); // crée une sortie modulée à 38KHz
		}

		void loop()
		{
		  irsend.mark(0); // envoi du signal pour une durée illimitée
		  delay(5);
		}
	

Boitier récepteur IR

boitier recepteur infrarouge

cliquez pour découvrir le code

		/*
		  Réception barrière InfraRouge
		  Reception du signal IR de Emission_bar_IR
		  http://makerspace56.org
		  Sources : https://github.com/maniacbug/RF24.git & https://github.com/TMRh20/RF24.git
		  Mise à jour : Nov 2016 by Paolo
		  Détecte le franchisement de la barrière infrarouge et le sens de passage gràce a deux capteur TSOP et envoie par radio:
		    - le nombre de personne dans la pièce
		    - toutes les 3 sec une info de bonne liaison radio (2000)
		    - l'info de franchissement de la barrière (3000)
		*/
		#include <SPI.h>
		#include "RF24.h"

		/* Configuration du Hardware : connectez nRF24L01 radio sur le bus SPI et sur les pins 7 & 8 */
		RF24 radio(7, 8);

		byte addresses[][6] = {"1Node", "2Node"};


		#define CAPTEURUN 2 // premier récepteur InfraRouge sur D2
		#define CAPTEURDEUX 3 // deuxième récepteur IR sur D3

		int inOut = 0;
		boolean attente = 0;


		void setup(){
		  Serial.begin(115200);
		  pinMode(CAPTEURUN, INPUT);
		  pinMode(CAPTEURDEUX, INPUT);
		  
		  radio.begin();          //configuration des radios
		  radio.setPALevel(RF24_PA_MIN);  //Puissance d'émmission (MIN, LOW, HIGH, MAX)
		  radio.setDataRate(RF24_250KBPS);
		  radio.openWritingPipe(addresses[0]);
		  radio.openReadingPipe(1, addresses[1]);
		  radio.stopListening();
		  Serial.println("Barriere infrarouge, recepteur ");


		}

		void loop(){
		  unsigned long attente_at = millis();
		  while(mesureUn() && mesureDeux()){
		    if(millis() - attente_at > 2000){
		      testCom(2000);
		    }
		    attente = 0;
		    mesureUn();
		    mesureDeux();
		    Serial.print(mesureUn());
		    Serial.print("  ");
		    Serial.println(mesureDeux());
		  }
		  testCom(3000);
		  if(!mesureUn() && !attente){
		    attente = 1;
		    unsigned long cut_at = millis();
		    boolean timeout = false;
		    while(mesureDeux()){
		      if (millis() - cut_at > 2000 ){
		        timeout = true;
		        break;
		      }
		    }
		    if(timeout){
		      inOut = 2;        
		    }
		    else inOut = 0;
		    Serial.println(inOut);
		  }
		  
		  if(!mesureDeux() && !attente){
		    attente = 1;
		    unsigned long cut_at = millis();
		    boolean timeout = false;
		    while(mesureUn()){
		      if (millis() - cut_at > 2000 ){
		        timeout = true;
		        break;
		      }
		    }
		    if(timeout){
		      inOut = 2;        
		    }
		    else inOut = 1;
		    Serial.println(inOut);
		  }
		  delay(500);
		  if(inOut!=2){
		    envoi();
		  }
		}

		boolean mesureUn(){
		  boolean mesure1 = digitalRead(CAPTEURUN); // première mesure
		  delay(5);                               // délai
		  boolean mesure2 = digitalRead(CAPTEURUN); // seconde mesure
		  boolean etat = mesure1 * mesure2;       // comparaison
		  return etat - 1;
		}

		boolean mesureDeux(){
		  boolean mesure1 = digitalRead(CAPTEURDEUX); // première mesure
		  delay(5);                               // délai
		  boolean mesure2 = digitalRead(CAPTEURDEUX); // seconde mesure
		  boolean etat = mesure1 * mesure2;       // comparaison
		  return etat - 1;
		}

		void envoi(){ // envoie 1 si entrée, -1 si sortie du batiment par radio. Attente de 2 secondes avant nouvelle mesure.
		  Serial.print("J envoie : ");
		  Serial.println(inOut);
		  Serial.print("   /   ");
		  if (!radio.write( &inOut, sizeof(inOut) )) {
		    Serial.println(F("echec de l envoi"));
		  }
		  else Serial.println("message envoye");
		  inOut = 2;
		}

		void testCom(int test){   // envoie par radion les infos de communication : 2000 attente d'un mouvement / 3000 mouvement détecté
		radio.write( &test, sizeof(test));
		}
	

Boitier connecté à l’ordinateur

boitier connecté à l'ordinateur

cliquez pour découvrir le code

		/*
		  Comptage barrière infrarouge
		  Reception du comptage du programme Reception_bar_IR via la radio nRF24L01+
		  http://makerspace56.org
		  Sources : https://github.com/maniacbug/RF24.git & https://github.com/TMRh20/RF24.git
		  Mise à jour : Nov 2016 by Paolo
		  Les yeux s'allument rouge : problème de communication
		                      vert : barrière IR franchie
		                      violet : barrière IR en attente d'un passage.
		  Le port série informe d'une entrée (1) ou d'une sortie(0)
		*/

		  #include <SPI.h>
		  #include "RF24.h"
		  #include <Adafruit_NeoPixel.h>
		  #ifdef __AVR__
		  #include <avr/power.h>
		  #endif


		  /* Configuration du Hardware : connectez nRF24L01 radio sur le bus SPI et sur les pins 7 & 8 */
		  RF24 radio(7, 8);
		  /*********************************************************************************************/

		  byte addresses[][6] = {"1Node", "2Node"};

		  int donnees = 0;
		  const int ledCom = 2;
		  const int ledMouv = 3;

		  #define PIN 6
		  #define NUM_LED 2
		  Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LED, PIN, NEO_GRB + NEO_KHZ800);
		  uint32_t magenta = strip.Color(255, 0, 255);
		  uint32_t rouge = strip.Color(255, 0, 0);
		  uint32_t vert = strip.Color(0, 255, 0);
		  uint32_t bleu = strip.Color(0, 0, 255);
		  uint8_t hbval = 128;
		  int8_t hbdelta = 8;
		  int lumval = hbval;
		  int lumdelta = hbdelta;



		  void setup() {

		    pinMode(ledCom, OUTPUT);
		    pinMode(ledMouv, OUTPUT);
		    digitalWrite(ledCom, HIGH);
		    digitalWrite(ledMouv, LOW);
		    Serial.begin(115200);
		  //Serial.println("radio reception");

		  radio.begin();
		  radio.setPALevel(RF24_PA_MIN);  //Puissance d'émmission (MIN, LOW, HIGH, MAX)
		  radio.setDataRate(RF24_250KBPS);
		  radio.openWritingPipe(addresses[1]);
		  radio.openReadingPipe(1, addresses[0]);
		  radio.startListening();

		  strip.begin();
		  strip.show();
		}

		void loop() {
		  unsigned long started_waiting_at = millis();
		  while (!radio.available()) {
		    if (millis() - started_waiting_at > 3000) {
		      colorWipe(rouge,0);
		      strip.show();
		    }
		  }
		  while (radio.available()) {
		    radio.read( &donnees, sizeof(donnees) );
		    //Serial.print("donnees : ");
		    //Serial.println(donnees);
		    switch (donnees) {
		      case 2000:
		      colorWipe(magenta,0);
		      break;
		      case 3000:
		      colorWipe(vert,0);
		      break;
		      default:
		      Serial.println(donnees);
		    }
		  }
		}

		void colorWipe(uint32_t c, uint8_t wait) {
		  for (uint16_t i = 0; i < strip.numPixels(); i++) {
		    strip.setPixelColor(i, c);
		    strip.show();
		    delay(wait);
		  }
		}
	

Laisser un commentaire