Problème code arduino compteur de personnes

[invite7bb156f3]

Bonjour à tous,
Fan d'électronique arduino, j'aimerai avoir un peu d'aide sur un de mes projets.

Pour faire simple :
- J'aimerais compter le nombre de personnes présentes dans une pièce.
- Mais je ne dispose seulement que d'une plaquette arduino, de deux capteurs TOR infrarouges et de mon afficheur à cristaux liquides.
- Bien sur, je préfère rester très simple, garder les capteurs au niveau du bassin (pas de jambes, bras, un seul passage...)

Là où je bloque c'est sur comment prévoir tout les cas possibles (aller/retour/j'y vais puis j'y vais pas...) sur mon programme sans avoir ni des "if" ou des "break" à rallonge.
Est-ce que l'un d'entre vous aurait déjà un programme de ce type que je puisse modifier à mon aise (monde d'arduino), ou quelqu'un de mieux calé que moi pour m'aiguiller sur cette question épineuse. D'ailleurs, j'ai cherché partout sur le net et je ne sais même pas si ce système à un nom.

En tout cas, merci beaucoup de me donner un coup de main, c'est vraiment un projet qui me tient à coeur.
-----

[invite1d577638]

Salut et bienvenue à toi,

Le problème dans ton cas va être effectivement de différentier la personne entrante de la personne sortante, et du cas complexe ou 2 personnes marchent cote à cote. Ton capteur va te renvoyer "j'ai détecté que quelqu'un à passé la porte", mais il ne va pas pouvoir t'aiguiller plus.

Trouve une autre solution de capteur pouvant résoudre cela. En attendant, pas la peine de sortir l'éditeur... La à froid, je vois pas de dispositif permettant de faire ça simplement. Attendons d'autres avis...

[invite62b75242]

Bonjour et bienvenue,

Il y a quelques années (+20 ans), j'avais réalisé un système de ce type basé sur 2 faisceaux infrarouges situés à une dizaine de centimètres l'un de l'autre.
En se basant sur le temps et l'ordre de rupture on peut avoir un système plus ou moins fiable, mais pas parfait.
L'inconvénient est la personne qui fait demi-tour au niveau des faisceaux et les groupes compacts.
L'idéal est de mettre ce système au niveau d'un passage étroit, ou il n'est possible que de passer à une personne de front.

[inviteede7e2b6]

et un "tourniquet" genre métro ?

[A voir en vidéo sur Futura]

[invite7bb156f3]

Merci à tous de vous intéresser à mon problème.
Pour ce qui est du passage de deux personnes en même temps, le passage sera réduit de façons à n'en laisser passer qu'une à la fois. J'ai travailler sur toutes les possibilités d'aller et venus devant les capteurs (sur structure type grafcet pour y voir un peu plus clair). Maintenant, ce qui me reste à faire, c'est à transcrire ça en arduino. Le problème, c'est que ya plein de retour, d'actions à faire en même temps, c'est compliqué, ce qui augmente le risque d'erreur, de bugs... Vous avez pas une solution ?? ou déjà un programme tout fait que je puisse modifier ???

[invitee05a3fcc]

En fait, avec deux barrières infrarouges, tu es un peu dans la même problématique que pour un codeur incrémental
Regarde ce tuto http://forums.futura-sciences.com/pr...cremental.html

[invite1d577638]

sur structure type grafcet pour y voir un peu plus clair.

Montre nous... Une bonne base de G7 peut aider à bien structurer un programme.

[invite7bb156f3]

j'y travaille, il arrive au propre.

[invite7bb156f3]

Voilà après un petit coup de G7 (sur Automgen8) on y voit plus clair :

Capteur 1 = état du signal du capteur 1
Capteur 2 = état du signal du capteur 2
Nbrepers = Nombre de personnes dans la pièce

Maintenant, y' a plus qu'à convertir ça en langage Arduino. J'ai essayer de demander au logiciel de passer du langage G7 au langage C, mais ça sort un code capable d'envoyer une fusée sur la lune !! Et comme on voit sur le G7, c'est une tout une succession de "if".

Bon, j'ai plus qu'a essayer de décrypter le code et à en extraire ce que je peut. Si ça intéresse quelqu'un, pour un autre projet ou pour me donner un coup de main :

// AUTOMGEN LANGAGE C - IRAI
#define PC32       // Cible g‚n‚rique PC 32 bits sous WINDOWS 32 bits

#include "stdlib.h"
#include "dos.h"
#include "math.h"
#ifdef PC32
#include "windows.h"
#else
#if defined(__BORLANDC__) || defined(__TURBOC__)
#include "mem.h"
#else
#define peek(s,o) (*(unsigned far *)(_MK_FP(s,o)))
#include "memory.h"
#endif
#endif
// contient la d‚finition du type de cible : PC16 ou PC32 ou LT LEROY ou FEC FESTO,
// le nombre de variables et le param‚trage du mode de debug … distance
#define NINPUT 128
#define NOUTPUT 128
#define NBIT 1024
#define NWORD 1024
#define NDWORD 1024
#define NFLOAT 1024
#define RDEBUG_COM 1
#if defined(FEC) || defined(HC01)
#define RDEBUG_BAUDRATE 9600l           // la vitesse en bauds
#define RDEBUG_PARITY 'N'               // 'E'ven (paire), 'O'dd (impaire), ou 'N'o (sans)
#define RDEBUG_STOPBIT 1                // 1 ou 2
#else
#define RDEBUG_BAUDRATE 115200l         // la vitesse en bauds
#define RDEBUG_PARITY 'O'               // 'E'ven (paire), 'O'dd (impaire), ou 'N'o (sans)
#define RDEBUG_STOPBIT 1		// 1 ou 2
#endif
#ifdef HC01
#define HC01_IO_MASK 0xf0 // ici 0 … 3 en entr‚e, 4 … 7 en sortie (… modifier suivant besoins)
#define HC01_FIRSTI 1
#define HC01_NI 1
#define HC01_FIRSTO 2
#define HC01_NO 1
#endif
// Pour l'automate FEC de FESTO
#ifdef FEC
#include "c:\automv6\c\bc01.h"
#endif
// Pour l'automate HC01 de FESTO
#ifdef HC01
#include "c:\automv6\c\plc_lib.h"
// D‚finitions pour les adresses des cartes d'E/S TOR HC01
unsigned hc01_adio[9]={0x110,0x112,0x210,0x212,0x310,0x312,0x170,0x172,0x270};
#endif
// Pour l'automate LT de LEROY
#ifdef LT
#include"c:\lt_prog\include\time2.h"
#include"c:\lt_prog\include\periodi.h"
#include"c:\lt_prog\include\cdg.h"
#include "c:\lt_prog\include\gesc2.h"
#include "c:\lt_prog\include\gesc1230.h"
#include "c:\lt_prog\include\ges32et.h"
#include "c:\lt_prog\include\ges32st.h"
// Configuration de l'automate
TC1230 BlocAlimUC;
T32ET Carte2;
T32ST Carte3;
void SetUCLed(unsigned led)
{
BlocAlimUC.Led|=led;
}
void ResetUCLed(unsigned led)
{
BlocAlimUC.Led&=~led;
}
#endif
#ifdef RDEBUG
void rdebug_init(void);
void rdebug_process(void);
#endif
#ifdef LT
TTime lt_tempo;
#endif

// R‚servation d'espace m‚moire pour les variables
unsigned char in[NINPUT];
unsigned char out[NOUTPUT];
unsigned char bit[NBIT];
unsigned short word[NWORD];
unsigned long dword[NDWORD];
float real[NFLOAT];


void prog(void);

// Gestion des temporisations
unsigned curtime;	
unsigned etime;
unsigned atime;
unsigned long dsltime;
unsigned dstime;
unsigned rtime;

// Fonction ATB
void atb(unsigned char *p)
{
unsigned count;
for(count=0;count<16;count++)
	{
	p[count]=(word[0]&(1<<count))?1:0;
	}
}
// Fonction BTA
void bta(unsigned char *p)
{
unsigned count;
word[0]=0;
for(count=0;count<16;count++)
	{
	if(p[count]) word[0]|=(1<<count);
	}
}
// Pour l'automate LT d‚marrage en RUN
#ifdef LT
int run=1;
#else
// Si le mode debug … distance est activ‚e d‚marrage en STOP
// autrement d‚marrage en RUN
#ifdef RDEBUG
int run=0;
#else
int run=1;
#endif
#endif
int step=0;
int init=0;
// Traitement cyclique
void cycleprocess(void)
{
#ifdef FEC
// Pour l'automate FEC de FESTO demarrage en run
//si l'interrupteur run/stop de l'automate est sur run
int switchrun;
static int lastswitchrun;
switchrun= BC01_RunStop_Read();
if(switchrun)
	{
	if(!lastswitchrun) run=1;
	}
else
	{
	run=0;
	}
lastswitchrun=switchrun;
if(run)
	{

	BC01_Led_Write(LED_GREEN);
	}
else
	{
	BC01_Led_Write(LED_OFF);
	}
#endif
#ifdef HC01
// Pour l'automate HC01 de FESTO demarrage en run
//si l'interrupteur run/stop de l'automate est sur run
int switchrun;
static int lastswitchrun;
switchrun= PLC_RunStop_Read();
if(switchrun)
	{
	if(!lastswitchrun) run=1;
	}
else
	{
	run=0;
	}
lastswitchrun=switchrun;
if(run)
	{

	PLC_Led_Write(LED_GREEN);
	}
else
	{
	PLC_Led_Write(LED_OFF);
	}
#endif
#ifdef LT
if(run)
	{
	BlocAlimUC.Led|=1;
	}
else
	{
	BlocAlimUC.Led&=~1;
	}
if (!run)
        {
	RafraichissementEntree();
	RafraichissementSortie();
	}
#endif
}
// Acquition des entr‚es
void getinputs(void)
{
// Ecrire ici la lecture des entr‚es physiques
#ifdef BECK
unsigned count;
unsigned char i;
i=inportb(0x600);
for(count=0;count<8;count++)
	{
	in[count]=(i<(1<<count))?1:0;
	}
#endif
#ifdef FEC
unsigned count;
WORD InWord;
#ifdef FECEXT
WORD InWord2;
#endif
// l'automate FEC de FESTO comporte 12 entr‚es
BC01_Inputs_Read(&InWord,2);  
for(count=0;count<12;count++)
	{
	in[count]=(InWord&(1l<<count))?1:0;
	}
#ifdef FECEXT
if(word[42]==1)
	{
	BC01_Inputs_ReadRemote(&InWord2,2,1);
	for(count=0;count<12;count++)
		{
		in[12+count]=(InWord2&(1l<<count))?1:0;
		}
	}
#endif
#endif
#ifdef HC01
unsigned count;
WORD InWord;
unsigned posi=0;
#ifdef HC01EXT
WORD InWord2;
#endif
// l'automate HC01 de FESTO comporte 8 entr‚es (module de base)
PLC_Inputs_Read(&InWord,2);  
for(count=0;count<8;count++)
	{
	in[count]=(InWord&(1l<<count))?1:0;
	}
posi=8;
for(count=0;count<HC01_NI;count++)
	{
	unsigned val;
	unsigned count2;
	val=inportb(hc01_adio[HC01_FIRSTI-1+count]);
	for(count2=0;count2<8;count2++)
		{
		in[posi+count2]=(val&(1<<count2))?1:0;
		}
	posi+=8;
	val=inportb(hc01_adio[HC01_FIRSTI-1+count]+1);
	for(count2=0;count2<8;count2++)
		{
		in[posi+count2]=(val&(1<<count2))?1:0;
		}
	posi+=8;
	}
#ifdef HC01EXT
if(word[42]==1)
	{
	PLC_Inputs_ReadRemote(&InWord2,2,1);
	for(count=0;count<12;count++)
		{
		in[posi+count]=(InWord2&(1l<<count))?1:0;
		}
	posi+=12;
	}
#endif
#endif
#ifdef LT
unsigned count;
RafraichissementEntree();
Carte2.Led=Carte2.Entree;
for(count=0;count<32;count++)
	{
	in[count]=(Carte2.Entree&(1l<<count))?1:0;
	}
#endif
}
// Ecriture des sorties
void setoutputs(void)
{
// Ecrire ici l'accŠs aux sorties physiques
#ifdef BECK
unsigned char o=0;
unsigned count;
for(count=0;count<8;count++)
	{
	if(out[count]) o|=1<<count;
	}
outportb(0x600,o);
#endif
#ifdef FEC
unsigned count;
WORD OutWord;
#ifdef FECEXT
WORD OutWord2;
#endif
// l'automate FEC de FESTO comporte 8 sorties
if(run)
	{
	for(count=0;count<8;count++)
		{
		if(out[count]) OutWord|=(1<<count);
		else OutWord&=~(1<<count);
		}
        }
else
	{
	OutWord=0;
	}
BC01_Outputs_Write(&OutWord,1);
#ifdef FECEXT
if(word[42]==1)
	{
	if(run)
		{
		for(count=0;count<8;count++)
			{
			if(out[count+8]) OutWord2|=(1<<count);
			else OutWord2&=~(1<<count);
			}
        	}
	else
		{
		OutWord2=0;
		}
	BC01_Outputs_WriteRemote(&OutWord2,1,1);
	}
#endif
#endif
#ifdef HC01
unsigned count;
WORD OutWord;
unsigned poso=0;
#ifdef HC01EXT
WORD OutWord2;
#endif
// l'automate HC01 de FESTO comporte 8 sorties
if(run)
	{
	for(count=0;count<8;count++)
		{
		if(out[count]) OutWord|=(1<<count);
		else OutWord&=~(1<<count);
		}
        }
else
	{
	OutWord=0;
	}
poso=8;
PLC_Outputs_Write(&OutWord,1);
for(count=0;count<HC01_NO;count++)
	{
	unsigned count2;
	unsigned char val;
	val=0;
	if(run)
		{
		for(count2=0;count2<8;count2++)
			{
			if(out[poso+count2]) val|=(1<<count2);
			}
		}
	outportb(hc01_adio[HC01_FIRSTO-1+count],val);
	poso+=8;
	val=0;
	if(run)
		{
		for(count2=0;count2<8;count2++)
			{
			if(out[poso+count2]) val|=(1<<count2);
			}
		}
	outportb(hc01_adio[HC01_FIRSTO-1+count]+1,val);
	poso+=8;
	}
#ifdef HC01EXT
if(word[42]==1)
	{
	if(run)
		{
		for(count=0;count<8;count++)
			{
			if(out[count+poso]) OutWord2|=(1<<count);
			else OutWord2&=~(1<<count);
			}
        	}
	else
		{
		OutWord2=0;
		}
	PLC_Outputs_WriteRemote(&OutWord2,1,1);
	}
#endif
#endif
#ifdef LT
unsigned count;
// La carte de 32 sorties TOR
for(count=0;count<32;count++)
	{
	if(out[count]) Carte3.Sortie|=(1<<count);
	else Carte3.Sortie&=~(1l<<count);
	}
Carte3.Led=Carte3.Sortie;
RafraichissementSortie();
#endif
}
void apisleep(int ms)
{
asm mov ax,900h
asm mov bx,ms
asm int 0ach
}
void main(void)
{
#ifdef RDEBUG
rdebug_init();
#endif
// Temps initial pour les temporisations
#ifdef LT
// Initialise la configuration du LT100
InsertionC2((unsigned int *)&BlocAlimUC,C1230,0);
// Allumer la led correspondant au port utilis‚
switch(RDEBUG_COM)
	{
	case 0 : SetUCLed(0x100); break;
	case 1 : SetUCLed(0x200); break;
	case 2 : SetUCLed(0x100); break;
	case 3 : SetUCLed(0x200); break;
	case 4 : SetUCLed(0x100); break;
	case 5 : SetUCLed(0x800); break;
	}
InsertionC2((unsigned int *)&Carte2,C232ET,2);
InsertionC2((unsigned int *)&Carte3,C232ST,3);
InitChrono(&lt_tempo,&CompteurMilliseconde,0,0);
TimePreset(&lt_tempo,100);
TimeRestart(&lt_tempo);
curtime=TimeState(&lt_tempo);
EcrCdg(0);
#else
#ifdef PC32
curtime=GetTickCount();
#else
curtime=peek(0x40,0x6c);
#endif
#endif
#ifdef FEC
#ifdef FECEXT
switch(BC01_Remote_Installed())
	{
	case -1 :
		{

		if(!BC01_Remote_Init(1))
			{
			word[42]=-1;
			}
		else
			{
			word[42]=-1; break;
			}
		} break;
	case -2 :
		{
		word[42]=-2;
		} break;
	case 0 :
		{

		word[42]=1;
		} break;
	case 1 :
		{

		word[42]=-3;
		} break;
	}
#endif
#endif
#ifdef HC01
// Initialiser le type E ou S des E/S de la CPU
	{
	unsigned char hc01_io_mask=HC01_IO_MASK;
	PLC_IO_SetMask(&hc01_io_mask);
	}
#ifdef HC01EXT
switch(PLC_Remote_Installed())
	{
	case -1 :
		{

		if(!PLC_Remote_Init(1))
			{
			word[42]=-1;
			}
		else
			{
			word[42]=-1; break;
			}
		} break;
	case -2 :
		{
		word[42]=-2;
		} break;
	case 0 :
		{

		word[42]=1;
		} break;
	case 1 :
		{

		word[42]=-3;
		} break;
	}
#endif
#endif
bit[20]=1;
do
	{
	if(init)
		{

		memset(in,0,sizeof(unsigned char)*NINPUT);
		memset(out,0,sizeof(unsigned char)*NOUTPUT);
		memset(bit,0,sizeof(unsigned char)*NBIT);
		memset(word,0,sizeof(unsigned)*NWORD);
		memset(dword,0,sizeof(unsigned long)*NDWORD);
		memset(real,0,sizeof(float)*NFLOAT);
		bit[20]=1;
		init=0;
		}
	#ifdef RDEBUG
	rdebug_process(); 		// Appel du systŠme de communication pour la mise au point … distance
	#endif
	cycleprocess();
	if(run||step)
		{
		getinputs();
		prog();
		setoutputs();
		bit[20]=0;
		step=0;
		}
	else
		{

		setoutputs();
		}
#ifdef BECK
  apisleep(10);
#endif
	}
while(1);
}

void prog(void)
{
bit[1]=0;
if(bit[20]) bit[1]=1;
if(bit[16]) bit[1]=1;
bit[21]=!in[0]&in[1];
bit[22]=in[0]&!in[1];
if(bit[21]|bit[22]) bit[3]=0;
if(bit[0]) bit[3]=1;
bit[21]=in[0]&in[1];
bit[22]=!in[0]&!in[1];
if(bit[21]|bit[22]) bit[5]=0;
if(bit[2]&in[0]&!in[1]) bit[5]=1;
bit[21]=!in[0]&!in[1];
bit[22]=in[0]&in[1];
if(bit[21]|bit[22]) bit[7]=0;
if(bit[2]&!in[0]&in[1]) bit[7]=1;
bit[21]=in[0]&!in[1];
bit[22]=!in[0]&in[1];
if(bit[21]|bit[22]) bit[9]=0;
if(bit[4]&in[0]&in[1]) bit[9]=1;
bit[21]=in[0]&!in[1];
bit[22]=!in[0]&in[1];
if(bit[21]|bit[22]) bit[11]=0;
if(bit[6]&in[0]&in[1]) bit[11]=1;
bit[21]=!in[0]&!in[1];
bit[22]=in[0]&in[1];
if(bit[21]|bit[22]) bit[13]=0;
if(bit[8]&!in[0]&in[1]) bit[13]=1;
bit[21]=in[0]&in[1];
bit[22]=in[0]&!in[1];
if(bit[21]|bit[22]) bit[15]=0;
if(bit[10]&in[0]&!in[1]) bit[15]=1;
bit[21]=!ERR!bit[21];
if(bit[12]&!in[0]&!in[1]) bit[17]=1;
bit[21]=!ERR!bit[21];
if(bit[14]&in[0]&!in[1]) bit[19]=1;
if(bit[17]) word[1]++;
if(bit[19]) word[1]--;
bit[0]=bit[1];
bit[2]=bit[3];
bit[4]=bit[5];
bit[6]=bit[7];
bit[8]=bit[9];
bit[10]=bit[11];
bit[12]=bit[13];
bit[14]=bit[15];
bit[16]=bit[17];
bit[18]=bit[19];
// Gestion du temps ‚coul‚ pour les temporisations
#ifdef LT
etime=TimeState(&lt_tempo);
atime=(etime-curtime)+rtime;
curtime=etime;
dsltime=atime;
dstime=dsltime;
atime-=(unsigned)dsltime;
rtime=atime;
#else
#ifdef PC32
etime=GetTickCount();
atime=(etime-curtime)+rtime;
curtime=etime;
dsltime=atime;
dstime=dsltime;
atime-=(unsigned)dsltime;
rtime=atime;
#else
etime=peek(0x40,0x6c);
atime=(etime-curtime)+rtime;
curtime=etime;
dsltime=atime;
dsltime*=100;
dsltime/=182;
dstime=dsltime;
dsltime*=182;
dsltime/=100;
atime-=(unsigned)dsltime;
rtime=atime;
#endif // !PC32
#endif // !LT
}

Merci à tous pour votre aide.

Euh, une petite question, comme barrière infrarouge, c'est quoi le mieux : un ensemble émetteur-récepteur ou un émetteur et un récepteur séparé ??

[invite1d577638]

Hmmm... Du coup, c'est quoi capteur 1 et capteur 2 ? J'ai du mal à comprendre ton G7...

[invite7bb156f3]

Ah, euh...

Capteur_1, c'est l'entrée digitale (1/0) du premier capteur (sensé) être branché sur l'entrée 0 de l'Arduino
et Capteur_2, c'est l'entrée digitale (1/0) du second capteur branché sur l'entrée 1 de l'Arduino

[invite1d577638]

Nan je veux dire, chaque capteur correspond à quoi dans la réalité ? Il mesure quoi ?

[invite7bb156f3]

Ah, et bien chaque capteur correspond à une barrière infrarouge qui mesure un passage si le signal infrarouge est coupé par le passage d'une personne. Pour simplifier, dans le G7, quand le capteur est activé ( c'est à dire que son état est 1) c'est qu'une personne passe devant.

[invite1d577638]

D'accord. Et si tu testes ce code sur une carte, il se passe quoi ? ça fonctionne ?