Aller à une partie de programme après un GET ethernet

Bonjour,
J'ai fabriqué une fusée à eau automatisé qui lance la fusée depuis une page web en php avec un formulaire qui envoi en GET grâce à Curl. Le soucis que j'ai c'est que je voudrais créer un bouton pour stopper le lancement, je ne sais pas comment m'y prendre....

Page de lancement:

Mon code:

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0x90, 0xa2, 0xda, 0x0f, 0xe6, 0xbc};
IPAddress ip(192, 168, 1, 19);
EthernetServer serveur_HTML(80);
EthernetClient client;

const int analogInPin = A0;
const int hallsensor = 2;
const int comp = 4;
const int veau = 3;
const int vaire= 6;
const int vlaunch = 5;

boolean capteur_impulsion = true;
unsigned long temps_actuel = 0;
unsigned long temps_depart = 0;
long compteur_impulsions = 0;
float volume_eau;
float volume_total_eau;
int Requete_GET_1=0;
int Requete_GET_2=0;
int sensorValue = 0;        // value read from MPX
int offset = 0;
int coeff = 104; // coeff courbe MPX5999 selon DS
long kPa = 0;
float Bar = 0;
float calcule = 0;
float quantite = 0;
int Nbr_imp;
int pression;
boolean remplissage_ok = false;
boolean pression_ok = false;
boolean lancement_ok = false; 


void setup() {
 
  Serial.begin(9600);// Demarre liaison série entre Arduino et PC pour la console
  Ethernet.begin(mac, ip);//Initialise la librairie ethernet et les paramètres du réseau.
  serveur_HTML.begin();   //Demande au serveur de commencer à écouter les connexions entrantes.
  noInterrupts();
  attachInterrupt(0, isr_compteur_impulsion, FALLING);   // N° interruption0,routine, flanc descendant
  pinMode(hallsensor, INPUT);
  pinMode(analogInPin, INPUT);
  interrupts();
  temps_depart = millis();
  pinMode(veau, OUTPUT);
  pinMode(vaire, OUTPUT);
  pinMode(comp, OUTPUT);
  pinMode(vlaunch, OUTPUT);
  digitalWrite(veau, HIGH);
  digitalWrite(vaire, HIGH);
  digitalWrite(comp, HIGH);
  digitalWrite(vlaunch, HIGH);
  for (int i=0; i < 4; i++){ // 4 acq pour purge CAD
  delay(10);
  offset = analogRead(analogInPin); // detection offset à l'init
  Serial.println();
  }
  Serial.print("Offset= ");
  Serial.println(offset);
  delay(1000);
}


void loop() {
String HTTP_req="";  // Stock la requête HTTP reçue
 
  client = serveur_HTML.available(); // création de 'client' s'il y a des données dans 'serveur_HTML'
  if (client) {// si tu detecte q'un client est connecté (Un client HTTP est un logiciel conçu pour se connecter à un serveur HTTP.)
                                                        //(Dans le cas le plus courant, il s'agit d'un navigateur Web)
    boolean Ligne_en_cours_est_vide = true;
   
    while (client.connected()) {// tant que le client est connecté
      if (client.available()) { // si il y a des données a lire
        char c = client.read(); //Associe chaque caractere entrant à c
        Serial.write(c); // Affiche 'c' sur la console
       
        if (HTTP_req.length() < 28) { // ne conserve que les 22 premier caractere de requête HTTP
            HTTP_req += c;
        }
        if (c == '\n' && Ligne_en_cours_est_vide) { // si la ligne en cour est vide
                                                    // et que l'on commence une nouvelle ligne
                                                    // la requête HTTP est terminée
          // Vérifie si une requête GET est présente dans la requête HTTP
          Serial.println(HTTP_req);
          if (HTTP_req.substring (0,6) == "GET /?") { // si la partie entre le caractere 0 et 6 de HTTP_req est egale à : "GET /?" => une requette GET est présente
              Requete_GET_1=(HTTP_req.substring (12,16)).toInt();
              Requete_GET_2=(HTTP_req.substring (26,28)).toInt();
              Serial.println(Requete_GET_1);
              Serial.println(Requete_GET_2);
              
              quantite=Requete_GET_1;
              pression=Requete_GET_2;
              //Début rempplissage 
              
              Nbr_imp = 0;
              digitalWrite(veau, LOW);
              digitalWrite(vaire, LOW);
              
              while(compteur_impulsions<=Nbr_imp){
                temps_actuel = millis();
                if (temps_actuel - temps_depart > 1000) 
                {
                  Serial.print("nb interruptions = "); Serial.println(compteur_impulsions);
                  volume_eau = (compteur_impulsions * 4.5);
                  volume_total_eau = volume_total_eau + volume_eau;
                  Serial.print("Volume = "); Serial.print(volume_eau);Serial.println(" ml");
                  Serial.print("Volume total = "); Serial.print(volume_total_eau);Serial.println(" ml");
                  Nbr_imp = quantite/4.2;  
                  Serial.println(Nbr_imp);
                  //calcul de la fréquence ou autre...
                  delay(500);                              //on attends 5 secondes avant la nouvelle acquisition
                  temps_depart = millis();                  //avant de sortir, on initialise pour refaire une acquisition
                  //compteur_impulsions = 0;
                  //volume_eau = 0;
                }
                else 
                {
                  if (capteur_impulsion == false)          // oui, il y a eu interruption
                  {
                  compteur_impulsions++;
                  
                  capteur_impulsion = true;
                }
                }
            
            }
            digitalWrite(veau, HIGH);
            digitalWrite(vaire, HIGH);
            remplissage_ok = true;
            //delay(2000);  
            //Fin rempplissage  
            
            
            //début mise sous pression 
              digitalWrite(comp, LOW);
              Bar = 0;
              while(Bar<pression){
                   sensorValue = analogRead(analogInPin);
                   
                    kPa = sensorValue - offset;  // decomposition volontaire
                    calcule = ((kPa * coeff)/100)/100;
                    if(calcule <= Bar && Bar != 0){
                      digitalWrite(comp, HIGH);
                      delay(2);
                      digitalWrite(comp, LOW);
                    }
                    
                    if (kPa <0) kPa=0;
                    Bar = ((kPa * coeff)/100)/100;
                    
                    // print the results to the serial monitor:
                    Serial.print("sensor = " );
                    Serial.print(sensorValue);
                    Serial.print(" Bar= " );
                    Serial.println(Bar);
                    //delay(2);              
              }
              digitalWrite(comp, HIGH);
              /*if (pression > 4){
                digitalWrite(comp, HIGH);
                
              }*/
              pression_ok = true;  
            //fin mise sous pression  
            
            //début lancement 
            
            delay(10000);
            digitalWrite(vlaunch, LOW);
            delay(2000);
            digitalWrite(vlaunch, HIGH);
            /*if (pression > 4){
                digitalWrite(comp, LOW);
            }*/
            
            if(Bar <= 0){
              lancement_ok = true;
            }
            
            //fin lancement 
          }
          break;//L'instruction break est utilisée pour sortir de la boucle while
        }
      }
    }
    delay(1);// laisser le temps au navigateur Web pour recevoir les données
    client.stop(); //Déconnecte le client du serveur.
  } 
}  

void isr_compteur_impulsion()              // routine d'interruption 0
{
  capteur_impulsion = false;               //attention, plus d'anti rebonds
}                                          //il faut filtrer en hard

Merci d'avance

salut j'ai regardé brievement ton code , et je vois que tu pars deja tes requet Get pour y trouvé des données.
tu n'a donc cas ajouté une autre requette qui envoi un "stop"
ton programe la reçoi l'analyse et met fin a ton cycle de demarage, purge la pression, te fait un café, y'a pas de différence ! :slight_smile:

Bonjour,
Est-ce que Arduino vérifie tous le temps si il y a une requête?
Cordialement,

bonjour,
le truc est que tu ne vérifie rien dans tes while.
donc si tu veux envoyer une requète et que le nono est dans un while, ben il le verra pas.
il faut que tu fasse un void pour une routine des get
et dans les while tu mets une instruction qui renvoie sur ce void.

si un client se connecte durant le while, tu vas sortir de cette boucle pour lire le get.

Bonjour et merci pour votre réponse,
C'est se que je cherche à faire mais je ne voix pas comment faire, pour faire une routine des GET.

Merci d'avance de votre aide.

j'ai donné une solution juste au dessus :wink:

il faut que tu fasse un void pour une routine des get
et dans les while tu mets une instruction qui renvoie sur ce void.

Je ne sais pas comment faire cela, avez vous une petite explication pour moi.

Comment pourrais-je faire pour créer une interruption à chaque requêtes ?
Cordialement,

Salut inutil de cree des intéruption la boucle principale Loop() se répéte indéfiniment ,donc il suffie de tester s'il ya des conection ou pas .

comme te le dissait infobarquee créé toi une fonction qui analyse en cours de programe et decoupe ton programe en partie

a titre d'exemple

tu créé une fonction qui recupére les info du get et qui te revoi l'information que tu en extrai
ex: conexion();// tu créra une requete qui envoi le stop
tu créé une fonction qui parametre tes valeur de lancement
ex : setlaunch();
tu créé une fonction de lancement
ex: launch();
qui serra ta boucle while

while(compteur_impulsions<=Nbr_imp && stop==false ){
conexion();
"ici ton lancement !"
}

ensuite c'est une sorte de lego

boolean stop==false// variable d'arrét
void loop(){
conexion();
setlaunch();
launch();

voila creuse c'est juste une piste !

Merci beaucoup, c'est se que je vais faire. Mais comment le programme va faire pour voir si il y a une nouvelle entée GET un plein milieu de la fonction launch() ? Et est-ce qu'il serait possible de créer des interruption avec client.connected()?

Merci d'avance

on t'as donné la méthode, pas besoin d'interruption la dedans.
dans chaque boucle while, tu fais appel à une routine qui va vérifier si quelque chose arrive avec GET.
si un GET arrive, il suffit de lire ce qui arrive et si la variable STOP (par exemple) est dans le GET, alors tu stop.
c'est pas plus compliqué.

while condition et STOP==0
..........
vérif d'un GET avec void XXXX
fin boucle while

void XXXX
si STOP recu
on arrête tout pour ne pas retourner dans le while
STOP = 1
fin du void XXXX

Bonjour, désolé du temps de réponse mais je passais des examens.

J'ai réussi à faire quelques chose à peu près fonctionnel mais comment faire pour reset la carte Arduino avec une fonction.

EDIT: J'ai trouvé ce code, est-ce qu'il irait:

void setup(){
}

void(*resetFunc) (void) = 0; 

void loop() {
  resetFunc();
  delay(1000); 
}

Cordialement,