Bonjour à tous,
alors voila mon problème, je souhaite élaborer un système de comptage de personne avec arduino ( tout simple, pas sophistiqué). Pour cela je vais réaliser une barrière IR avec un phototransistor et une led IR, l'arduino fera office de compteur (+1 sur un afficheur des que ma main passe devant le faisceau). je dois donc integrer le code a ma carte arduino et c'est ca le problème, je suis nul en programmation. j'ai reussi a recuperer un code seulement pour la barrière IR:
Mais le problème c'est que je ne sais pas comment integrer l'incrementation +1 sur un afficheur des que ma main coupe le faisceau, au code précedent.
La demarche serait :
mise a zéro du compteur au départ A=0
début de la boucle
condition : si un signal est reçu alors on incrémente : A=A+1
sinon on fait rien
affichage de la valeur "A" sur un digit par exemple
-retour en début de boucle
Voila, j'aimerais avoir cette demarche en langage arduino (langage proche du C), merci beaucoup à l'anvance !
Bonjour,
Le hasard fait qu’il y a quelques jours je me suis amusé à réaliser un compteur qui utilisait une fourche optique. Une barrière infrarouge est un problème connexe et mon programme devrait te fournir quelques éléments de base.
La difficulté vient du fait qu’il faut compter sur les transitions, et non sur le fait que l’état de ton capteur soit « 0 » ou « 1 ». Je ne sais pas s’il y a plus élégant, mais pour ma part j’utilise un booléen qui mémorise l’état précédent. Ainsi par comparaison on détecte l’événement transition.
Voici mon petit programme expérimental :
/* Exemple simple de détection d'un front descendant sur
une entrée analogique */
int CNA; // Mesure analogique retournée par le CNA.
const byte Entree_mesuree = 0; // Mesure analogique sur A0.
boolean Etat1; // État binaire issu de la mesure analogique.
boolean Ancien_Etat; // État binaire mémorisé.
const byte LED_Arduino = 13; // Broche 13 utilisée.
const byte LED_Temoin = 10; // Broche 10 pour le témoin d'état mesuré.
void setup() {pinMode(LED_Arduino, OUTPUT);
pinMode(LED_Temoin, OUTPUT);}
void loop() {
CNA = analogRead(Entree_mesuree);
if (CNA > 563) { Etat1=true; Ancien_Etat=true;}
else {Etat1=false;};
if (Etat1) {digitalWrite(LED_Temoin, HIGH);}
else {digitalWrite(LED_Temoin, LOW);};
// ========== Gérer le front descendant. ==========
if ((Ancien_Etat) && (!Etat1))
{Ancien_Etat=false; ActionSurFrontDescendant(); } ; }
void ActionSurFrontDescendant()
{digitalWrite(LED_Arduino, HIGH); delay(100); digitalWrite(LED_Arduino, LOW);}
Ce programme est la version où chaque transition de “1” vers “0” allumait un court instant la LED d’Arduino. Mais dans la procédure void ActionSurFrontDescendant() il te suffit d’intégrer l’incrémentation d’un quelconque compteur. J’ai également expérimenté cette possibilité, mais alors il faut mettre en service la ligne série pour en visualiser la valeur.
Attention, tu risques à te heurter à un problème résultant de la lumière ambiante. Dans ce cas l’éclairage de ta cellule devra se faire avec un faisceau lumineux haché à une fréquence de ton choix, et le signal issu de ton capteur devra être passé à travers un filtre pour le « sortir » du brouillage.
J’ai ici utilisé une entrée nalogique, car le phototransistor de la fourche optique me donne une tension variant entre 0,6 et 3,1Vcc. Mais si tu le désires, naturellement une entrée binaire convient aussi. J’ai expérimenté les deux, et si tu en as vraiment besoin je peux poster également l’autre programme qui est pratiquement un clone de celui donné ci-dessus.
Amicalement : Nulentout.