Je voudrait récupérer 1 seul données de mon interrupteur a levier.
Actuellement quand je passe mon interrupteur en position ON j'ai plein de donnés qui arrive selon le délai que j'établie.
Je voudrai que a chaque fois que je passe mon interrupteur sur 1,une seul donnée soit récupérer.
/code n°11
02.06.2015
interupteur levier/
int interrupteur = 3 ; //attribution pin 3 a l'interupteur
void setup ( ) {
Serial.begin( 9600 ) ; //initialisation de la communication
as-tu essayé un p'tit condo entre 10 et 100nF pour l' antirebond?
Sinon, tu as une accolade ouvrante de trop au dessus de ton if(ButtonState == 1)//etat du bouton
la boucle "LOOP" est exécuté indéfiniment
comme il y a un delay de 1 seconde, elle lit l'inter toutes les secondes........et par suite....................
non, utilise une variable "memoire" que tu initialises dans le setup
puis dans la boucle, tu lis l'inter et seulement si le résultat de ta lecture est différent de la mémo, tu entre dans l'affichage et là, tu affiche et tu memorises le nouvel état de l'inter.
à la boucle loop suivante, la memo sera égale à l'inter et donc tu n'entre pas dans l"affichage.
lorsque tu rebasculera l'inter, il sera different de la memo et là, tu entreras à nouveau dans l'affichage
etc...
ce n'est pas un problème de rebonds mais bien de programme.
Faudra revoir l'approche.
utilise une autre variable d'état pour indiquer que l'état on avait été détecté et traité.
Il serait bien aimable et bienvenu de lire ou relire la charte ainsi que de consulter le sujet sur la façon d'écrire les messages, ces deux éléments se trouvent en tête des messages du forum.
Ensuite, fort de ces nouvelles informations, il serait judicieux que vous éditiez, au moyen du bouton dédié à cet effet dans la fenêtre de rédaction de sujet, les messages contenant du code afin d'insérer les dits codes entre les balises idoïnes.
peux tu redéfinir ton projet
il semble que tu ai installé un clavier==>combien de touches, colonnes, lignes ?
pour ce clavier, un lien, ou une photo
tu as également plusieurs interrupteurs et tu nous parles également de colonne et de lignes ?
tu veux rajouter des encodeurs rotatifs ?
si appui sur le BP "appel de phare" et temps phares == 0 // si appui sur BP, on allume les phares
relever et memoriser dans "memo" le temps avec millis()
allumer les phares. flag phares allumés = 1
cpt appels de phares++ compteur "flip/flop" passe à 1
si flag phares allumés == 1 et cpt appels de phares =< 5 //si phares allumés, on les laisse 500ms
relever le temps avec milis et comparer avec la "memo"
si delta inf à 500ms ne rien faire
si delat sup à 500ms éteindre les phares //si 500ms passées, on éteind les phares
flag phares allumés == 0
relever et memoriser dans "memo" le temps avec millis() //c'est reparti pour 500ms
si flag phares allumés == 0 et cpt appels de phares =<5
relever le temps avec milis et comparer avec la "memo"
si delta inf à 500ms ne rien faire
si delat sup à 500ms allumer les phares.
flag phares allumés = 1
cpt appels de phares++ compteur "flip/flop" s'incremente
relever et memoriser dans "memo" le temps avec millis() //c'est reparti pour 500ms
si cpt appels de phares =<6
éteindre les phares
flag phares allumés = 0
cpt appels de phares=10 //pour ne pas entrer dans les if pour valeur inf à 5
Comment ils faisaient dans la marine pour se parler entre des bateaux à plus de 100m l'un de l'autre quand il n'y avait pas la radio ?
Il agitaient des drapeaux de différentes couleurs et motifs.
En informatique un flag c'est exactement le même esprit.
non
avec tempsphares = millis(); tu lis le temps qui s'est écoulé en millisecondes depuis le début du prg
donc, tu le lis, tu le mémorise
puis au prochain passage, tu le relis: temps actuel = millis();
et tu compares avec la mémorisation:mémorisation - temps actuel
la différence te donne le temps écoulé entre les deux lectures faites avec millis()
regardes le lien que je t'ai mis sur mon post précédent
et si tu compares avec ce que je t'ai donné comme indication, tu ne mémorises jamais.
je ne paralais pas d'écrire en eeprom, mais simplement de stocker dans un unsigned long le temps relevé avec millis()
millis() ne mémorise pas.... c'est comme si cette fonction était un passant dans la rue à qui tu demandes l'heure, il va te la dire et toi tu vas la mémoriser.
Tu vas marcher encore un moment et tu croise un autre passant ( encore la fonction millis()), tu lui redemande et tu remet l'heure mémorisée à jour.
Maintenant, à la deuxième demande, si avant de remettre ton heure stockée à jour tu compares l'ancienne valeur avec la nouvelle.... et bien tu as un différentiel de temps.
si ce différentiel est plus petit que celui que tu as déterminé pour faire ton action, tu continues à marcher jusqu'au passant suivant et tu lui demandes à nouveau l'heure... etc, etc.
tes phares sont toujours en "appel" tu initialise le BP à high comme relaché puis tu regardes aussitôt s'il est high et là, tu traite pour une demande de phares !!!!
void setup()
{
pinMode(bouton, INPUT); //le bouton est une entrée
etatBouton = HIGH; //on initialise l'état du bouton comme "relaché"
}
void loop()
{
etatBouton = digitalRead(bouton); //Rappel : bouton = 2
if ((etatBouton == HIGH) && (tempsphares == 0)) //test si le bouton a un niveau logique HAUT
{
tempsphares = millis();
memorisation = millis();
Keyboard.write(113);
etatphares = 1;
compte++;
}
voici le code, mais tu es sur Leonardo et je ne connais pas l'instruction Keyboard
alors j'ai fais pour UNO le BP est la pinoche 2 et les phares c'est la led de la pinoche 13
regarde bien le code, lis les commentaires ensuite si tu as un UNO, utilise le et ouvre ton moniteur
ensuite, un appui sur le BP et ............regarde la led 13 et le moniteur.
les appels se font toutes les 500ms, mais tu peux changer la durée ( c'est prévu)
ensuite, tu peux aussi modifier le code pour avoir des temps différents allumés 100 et éteinds 300
ou autres........
const int bouton = 2; // entrée du BP appels de phares
int compte = 0; //compteur du nombres d'appels de phares effectués
int etatBouton = 0; //pour lecture BP demande appels de phares
int etatphares = 0; //flag d'état des phares
unsigned long memorisation = 0; //pour memo temps de depart de la tempo
int interval = 0; //interval de temps
int demande_appel = 0; //memo demande appels de phares
unsigned long tempsphares = 0; //pour lecture du temps courant
int cadencement = 200; //pour 500ms
int phares=13;
int nb_appels = 2;
void setup()
{ Serial.begin(9600);
pinMode(phares, OUTPUT );
pinMode(bouton, INPUT_PULLUP ); //le bouton est une entrée et la pull up est active donc, pas de résistance extérieure
etatBouton = HIGH; //on initialise l'état du bouton comme "relaché"
}
void loop()
{
etatBouton = digitalRead(bouton); //Rappel : bouton = 2
Serial.print("BP ");Serial.println(etatBouton);
if ((etatBouton == LOW) && (compte <= nb_appels)) // si BP appuyé, appels de phares demandés
{
Serial.print("demande d'appels de phares enregistree");
tempsphares = millis(); //initialisation suite à demande appels de phares
memorisation = tempsphares; // la tempo démarre
digitalWrite(phares,HIGH);//**********************************************************
//Keyboard.write(113); // allume les phares ???
demande_appel = 1; //on memorise la demande
etatphares = 1; //on initialise l'état des phares
compte = 0; //le compteur d'appels est initialisé à zéro
}
// les phares sont allumés pour 500ms
if ((demande_appel == 1) && (etatphares == 1) && (compte <= nb_appels)) // si demande appels en cours ( pas tous faits )
{ //on controle le temps passé
Serial.print("les phares sont allumes depuis ");
tempsphares = millis(); //temps passé au moment de la lecture du temps par millis
interval = tempsphares - memorisation ; //donc la memo est plus petite, et c'est elle qui doit etre soustraite
Serial.print(interval);Serial.println(" ms");
if (interval > cadencement) //si moins de 500ms, on laisse en l'état
{
digitalWrite(phares,HIGH);//********************************************************
//Keyboard.write(113); // eteind les phares ???
tempsphares = millis(); // la tempo repart à 0 ( egalité des temps )
memorisation = tempsphares;
etatphares = 0;
}
else {}
}
//les phares vont etre éteinds pour 500ms
if ((demande_appel == 1) && (etatphares == 0) && (compte <= nb_appels)) // si demande appels et pas tous faits
{
Serial.print("les phares sont eteinds depuis ");
tempsphares = millis(); //temps passé au moment de la lecture du temps par millis
interval = tempsphares - memorisation ; //donc la memo est plus petite, et c'est elle qui doit etre soustraite
Serial.print(interval);Serial.println(" ms");
if (interval > cadencement) //si moins de 500ms, on laisse en l'état
{
digitalWrite(phares,LOW);//*********************************************************
//Keyboard.write(113); // allume les phares ???
tempsphares = millis(); // la tempo repart à 0 ( egalité des temps )
memorisation = millis();
etatphares = 1;
compte++;
}
else {}
}
if (compte >nb_appels) //si on à fait les 5 appels de phares
{
digitalWrite(phares,LOW);//**********************************************************
//Keyboard.write(113); //on éteinds les phares
demande_appel = 0; //on raz la demande d'appels
etatphares = 0; //on memorise l'état des phares ( éteinds =
compte = 0; //on neutralise le compteur d'appels de phares
}
}
