Comptage par franchissement d’une barrière infrarouge

[code lang= »arduino »]
/*
Emission barrière InfraRouge
Emmission d’un signal IR à 38KHz capté par le programme Reception_bar_IR pour créé une barrière infrarouge.
http://makersk.cluster030.hosting.ovh.net
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);
}
[/code]

[code lang= »arduino »]
/*
Réception barrière InfraRouge
Reception du signal IR de Emission_bar_IR
http://makersk.cluster030.hosting.ovh.net
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));
}
[/code]

[code lang= »arduino »]
/*
Comptage barrière infrarouge
Reception du comptage du programme Reception_bar_IR via la radio nRF24L01+
http://makersk.cluster030.hosting.ovh.net
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);
}
}
[/code]