Problème d'activation d'un sous programme avec un bouton

Bonjour,

Voila j’ai creer un programme ou il y a 2 sous programmes activé par un bouton poussoir.
Le problème étant que je suis obligé de rester appuyer sur le bouton pour l’activation de mon sous programme.

Quelqu’un peut il m’aider ?

voila le code

const int led2R = 9 ;
const int led2V = 8 ;
const int led2B = 6 ;

const int led1R = 4 ;
const int led1V = 5 ;
const int led1B = 7 ;

const int bouton = 10;

int memoire_bouton = 0 ;
long selection;

int relais = 2;

//int LedC = 5;
//int LedS = 6;

float VCPOTa=0;//variables pour filtrage entrée analogique A1
float VCPOTb=0;//variables pour filtrage entrée analogique A1
float VCPOT1b=0;//variables pour filtrage entrée analogique A1
float VCPOT1a=0;//variables pour filtrage entrée analogique A1

long tempsReference;
int prelais =0;
int nrelais =0;
int charge = 0;
int top = 0;

long VCPOT = 0;
long VCPOT1 = 0;


unsigned long duree =0;
unsigned long tinit =0;
unsigned long tfin =0;





void setup() {

pinMode (led2R,OUTPUT);
pinMode (led2V,OUTPUT);
pinMode (led2B,OUTPUT);

pinMode (led1R,OUTPUT);
pinMode (led1V,OUTPUT);
pinMode (led1B,OUTPUT);


pinMode(bouton, INPUT);


Serial.begin (9600);
selection = millis();
digitalWrite (led2B,255);

}

void loop() {

digitalRead(memoire_bouton);
//Serial.print(memoire_bouton);


if ((digitalRead (bouton)==1) && (memoire_bouton<2)) {

digitalWrite (led2R,102);
digitalWrite (led2V,0);
digitalWrite (led2B,153);
bigbop ();
memoire_bouton=1;
//Serial.print(memoire_bouton);

 
 }
else
{

digitalRead(memoire_bouton);
if (((millis() - selection) > 10000) && (memoire_bouton==0))
{
digitalWrite (led2R,HIGH);
digitalWrite (led2V,HIGH);
digitalWrite (led2B,0); 
minibop ();

memoire_bouton=2;
selection = millis();

}
}
}

 
 
 
 
 
 
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                       BIG BOP PROGRAMME                                                        ///
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  
 
 
 
 
 
 
 
 
 
 
 void bigbop () {

  //filtrage de l'entrée analogique A1
 
  VCPOT = (analogRead(A1) * ( 500000 / 1023)/100);// * 6.16);// calculs tension en mV
  //float VCPOTb = VCPOTa - (VCPOTa-VCPOT)/1;
  //VCPOTa=VCPOTb;
 
  
  
  Serial.println("-----------------------------");
  
  Serial.println("Tension Batterie : " + String(VCPOT) + "V");
  
  Serial.println("-----------------------------");
  
  if (VCPOT <=1700 ) {    
      
    digitalWrite(relais, HIGH);  // la charge demarre
  }
  nrelais = digitalRead(relais);
  Serial.print (prelais);
  Serial.println (nrelais);
  
  //digitalWrite(LedS,1-nsw1);
  //digitalWrite(LedC,charge);
  
  
    if (nrelais==0 && prelais==1) {  // detection passage relais départ à 1
    prelais=nrelais; 
    charge = 1;  // flag depart charge à 1
    
    
    digitalWrite(led1R,LOW);
    digitalWrite(led1V,LOW);  
  }
  //VCPOT1 = (analogRead(A0) * ( 5000 / 1023));// * 6.16); // calculs tension en mV
  VCPOT1 = (analogRead(A1) * (500000/1023))/100; // calculs tension en mV
  
 // float VCPOT1b = VCPOT1a - (VCPOT1a-VCPOT1)/1;
  //VCPOT1a=VCPOT1b;
  
  
  
  
  
  Serial.println ("Tension Batterie : " + String(VCPOT1) + "mV");
  tinit = millis(); // initialisation chrono
  
  
  while (charge == 1 && VCPOT1 > 1400 ) {       // boucle attente fin de charge    
    
     
    
    //VCPOT = (analogRead(A0) * ( 5.0 / 1023));// * 6.16);
    VCPOT1 = (analogRead(A1) * (500000/1023))/100; // calculs tension en mV
    //float VCPOT1b = VCPOT1a - (VCPOT1a-VCPOT1)/1;
    //VCPOT1a=VCPOT1b;
    
    
    
    
    Serial.print ("  duree : " + String(millis()-tinit));
    Serial.println ("  aVCPOT : " + String(VCPOT1));
   
    if (VCPOT1 > 4690.00) { // detection fin de charge          
      prelais=1;         // reinitialisation des flags
      nrelais=1;
      charge=0;
      
      duree = millis()-tinit;  // calcul de la durée de charge
      Serial.println ("duree de charge: " + String(duree));
      
      
      if (duree > 16200000) {
        digitalWrite(led1V,HIGH);
        digitalWrite (led1R,LOW);
      }
      else {
        digitalWrite(led1R,HIGH); 
        digitalWrite (led1V,LOW);
      
      }
       
    }
  }
  
 }


 
 
 
 
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
//                                                       MINI BOP PROGRAMME                                                        //
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////  
 
 
 
 
 
 
 
 
 void minibop (){
    //filtrage de l'entrée analogique A1
  VCPOT = (analogRead(A1) * ( 500000 / 1023)/100);// * 6.16);// calculs tension en mV
  //float VCPOTb = VCPOTa - (VCPOTa-VCPOT)/1;
  VCPOTa=VCPOTb;
 
  
  
  Serial.println("-----------------------------");
  
  Serial.println("Tension Batterie : " + String(VCPOT) + "V");
  
  Serial.println("-----------------------------");
  
  if (VCPOT <= 1700) {    
      
    digitalWrite(relais, HIGH);  // la charge demarre
  }
  nrelais = digitalRead(relais);
  Serial.print (prelais);
  Serial.println (nrelais);
  
  //digitalWrite(LedS,1-nsw1);
  //digitalWrite(LedC,charge);
  
  
    if (nrelais==1 && prelais==0) {  // detection passage relais départ à 1
    prelais=nrelais; 
    charge = 1;  // flag depart charge à 1
    
    
    digitalWrite(led1R,LOW);
    digitalWrite(led1V,LOW);  
  }
  //VCPOT1 = (analogRead(A0) * ( 5000 / 1023));// * 6.16); // calculs tension en mV
  VCPOT1 = (analogRead(A1) * (500000/1023))/100; // calculs tension en mV
  
  //float VCPOT1b = VCPOT1a - (VCPOT1a-VCPOT1)/1;
  //VCPOT1a=VCPOT1b;
  
  
  
  
  
  Serial.println ("Tension Batterie : " + String(VCPOT1) + "mV");
  tinit = millis(); // initialisation chrono
  
  
  while (charge == 1 && VCPOT1 > 1400 ) {       // boucle attente fin de charge    
    
     
    
    //VCPOT = (analogRead(A0) * ( 5.0 / 1023));// * 6.16);
    VCPOT1 = (analogRead(A1) * (500000/1023))/100; // calculs tension en mV
    //float VCPOT1b = VCPOT1a - (VCPOT1a-VCPOT1)/1;
    //VCPOT1a=VCPOT1b;
    
    
    
    
    Serial.print ("  duree : " + String(millis()-tinit));
    Serial.println ("  aVCPOT : " + String(VCPOT1));
   
    if (VCPOT1 > 4690.00) { // detection fin de charge          
      prelais=1;         // reinitialisation des flags
      nrelais=1;
      charge=0;
      
      duree = millis()-tinit;  // calcul de la durée de charge
      Serial.println ("duree de charge: " + String(duree));
      
      
      if (duree > 9000000) {
        digitalWrite(led1V,HIGH);
        digitalWrite (led1R,LOW);
      }
      else {
        digitalWrite(led1R,HIGH); 
        digitalWrite (led1V,LOW);
      
      }
       
    }
  }
 }

je vous remercie par avance

Fabien

Salut

Il y a un soucis ici je pense :

digitalRead(memoire_bouton);
//Serial.print(memoire_bouton);


if ((digitalRead (bouton)==1) && (memoire_bouton<2)) {

digitalWrite (led2R,102);
digitalWrite (led2V,0);
digitalWrite (led2B,153);
bigbop ();
memoire_bouton=1;

Le digitalRead(memoire_bouton) et le test digitalRead(bouton) …

D’ailleurs le digitalRead(memoire_bouton) doit avoir un fonctionnement bizarre car c’est une I/O que tu n’as pas déclaré .

j'ai bien déclaré mémoire_bouton regarde au debut!
ducoup je ne sais pas ducoup d'ou vient le problème de mon programme

Pour faire simple j'aimerai juste qu’après la décision avec mon bouton celui-ci se désactive pour laisser place à mon sous programme grande bop ou mini bop

Il n'y a pas de pinMode(memoire_bouton,INPUT) ...

Il y a confusion avec l'appel de la fonction pour lire le bouton et l'état du bouton.

Je pense que tu dois faire un truc comme ça :

memoire_bouton = digitalRead(bouton) ;

et selon sa valeur tu lances tes fonctions .

Justement j'ai mis mémoire bouton pour bloquer ma boucle et gros si j'appuie sur mon bouton la valeur de cette mémoire change pour bloquer ma boucle sur la décision prise avec l'actionnement de celui-ci.

Tu ne peux pas utiliser digitalRead() avec mémoire_bouton comme argument :wink:

byte incr = 0;

memoire_bouton = digitalRead(bouton);

// gestion des rebonds

if (memoire_bouton == 1)
{
incr = incr +1;
if(incr>2){incr=0;}
}

if (incr == 1){ fonction1();}
if (incr == 2){ fonction2();}

Il y a confusion entre une variable et un I/O.
Concernant le fonctionnement de ton programme (vu qu'il y a zéro commentaire dans le code), quelle comportement attends-tu?

bonjour,
essayons d'expliquer les choses différemment ...

tu déclares

fabienrvl:

const int bouton = 10;

et

int memoire_bouton = 0 ;

donc je suppose que ton bouton est sur la broche 10, et en plus tu affectes la valeur 0 à la variable memoire_bouton.

tu peux faire

if ((digitalRead (bouton)==1)

car ainsi tu vérifies si le bouton, câblé sur la broche 10, te provoque un état haut (dans ton montage, je suppose que ça veut dire "appuyé"),

mais en faisant

digitalRead(memoire_bouton);

tu lis l'état logique de la broche dont le numéro correspond à la valeur contenue dans la variable memoire_bouton.

as-tu bien saisi la nuance ?