Problème file d'attente

Bonjour,

nous avons un projet à réaliser pour notre BAC qui nous donne du fil à retordre >:(
Le but de notre système et de contrôler 4 vannes à impulsions pour arroser 4 serres grâce à un arduino UNO et un shield GSM.

Nous voulons commander ces arrosages grâce à un smartphone (par SMS).
Nous avons mettre en place une file d’attente car il ne peut y avoir q’une seule vanne ouverte à la fois.
Le programme ne marche pas du au fautes que nous n’arrivons pas résoudre.

Pouvez-vous nous aider ?

Voici le code :

#include <GSM.h> // Inclure la librairie GSM
#include <QueueArray.h> // Inclure la librairie file d'attente

#define PINNUMBER "1608" // Définir ici le code PIN de la carte SIM du shield

GSM gsmAccess; // Définir les classes
GSM_SMS sms;
QueueArray <int> queue;


int vanne_1 = 4; // Variables vanne_X servant à définir les broches des vannes
int vanne_2 = 7;
int vanne_3 = 8;
int vanne_4 = 12;
int duree_vanne1 = 0; // Variables duree_vanneX servant à stocker la duree d'arrosage de chaque vanne 
int duree_vanne2 = 0;
int duree_vanne3 = 0;
int duree_vanne4 = 0;
int seuil_vanne1 = 0; // Variables seuil_vanneX servant à stocker le seuil en J/m2 de chaque vanne
int seuil_vanne2 = 0;
int seuil_vanne3 = 0;
int seuil_vanne4 = 0;

int cumul1 = 0; // Variables cumulX servant à stocker la valeur du cumul d'ensoleillement de chaque vanne
int cumul2 = 0;
int cumul3 = 0;
int cumul4 = 0;

int ticks = 0; // Variable pour le timer

const int potPin = 0; // Constante définissant la broche analogique du solarimètre

const int file_attente_vanne1 = 1; // file_attente_vanneX servant à mettre dans la file d'attente en fonction des instructions reçues
const int file_attente_vanne2 = 2;
const int file_attente_vanne3 = 3;
const int file_attente_vanne4 = 4;

/**
 *
 */
void setup() {
  
  queue.setPrinter (Serial); // Choisir le printer de la file d'attente
  
  Serial.begin(9600); // Initialiser le moniteur série à 9600 bauds
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  } 

  Serial.println("SMS Messages Receiver");
  
  pinMode(vanne_1, OUTPUT); // Choisir INPUT/OUTPUT pour les vannes
  pinMode(vanne_2, OUTPUT);
  pinMode(vanne_3, OUTPUT);
  pinMode(vanne_4, OUTPUT);
    
  boolean notConnected = true; // connection state
  
  // Start GSM connection
  while(notConnected) {
    if(gsmAccess.begin(PINNUMBER) == GSM_READY)
      notConnected = false;
    else {
      Serial.println("Not connected");
      delay(1000);
    }
  }
  
  Serial.println("GSM initialized");
  Serial.println("Waiting for messages");
  
  OCR0A = 0xAF;            // use the same timer as the millis() function
  TIMSK0 |= _BV(OCIE0A);
}


void loop() {
  
  char focus_partie; // Premier caractère du codage, a pour solarimètre, b pour journalier, c pour manuel et d pour durees
  char focus_vanne; // Deuxième caractère du codage, de a à d pour les 4 vannes
  
  if (sms.available()) {
    Serial.println("Message received");
    
    focus_partie = sms.read();
    focus_vanne = sms.read();
    
    
    Serial.println(focus_partie);
    Serial.println(focus_vanne);
    
    
    if(focus_partie == 'a') {
      char milliers = sms.read();
      char centaines = sms.read();
      char dizaines = sms.read();
      char unites = sms.read();
      
      solarimetre(focus_vanne, milliers, centaines, dizaines, unites);
    }
    else if(focus_partie == 'b') {
      char jour_h_dizaines = sms.read();
      char jour_h_unites = sms.read();
      char jour_m_dizaines = sms.read();
      char jour_m_unites = sms.read();
      
    }
    else if(focus_partie == 'c') {
      manuel(focus_vanne);
    }
    else if(focus_partie == 'd') {
      char d_min = sms.read();
      char u_min = sms.read();
      char d_sec = sms.read();
      char u_sec = sms.read();
      
      duree(focus_vanne,d_min,u_min,d_sec,u_sec);
    }
    
    sms.flush();
  }
  
  calcul_cumul();
  
  arrosage(etat_vanne1,etat_vanne2,etat_vanne3,etat_vanne4);
  
  delay(1000);
}

void manuel(char vanne) {
  
  if(vanne == 'a') {
    queue.push(file_attente_vanne1);
  }
  else if(vanne == 'b') {
    queue.push(file_attente_vanne2);
  }
  else if(vanne == 'c') {
    queue.push(file_attente_vanne3);
  }
  else if(vanne == 'd') {
    queue.push(file_attente_vanne4);
  }
}

void solarimetre(char vanne, char milliers, char centaines, char dizaines, char unites) {
  int seuil_choisi = (milliers - 48) * 1000 + (centaines - 48) * 100 + (dizaines - 48) * 10 + (unites - 48);

  Serial.println("Le seuil choisi est : ");
  Serial.println(seuil_choisi);

  if(vanne == 'a') {
    seuil_vanne1 = seuil_choisi;
  }
  else if(vanne == 'b') {
    seuil_vanne2 = seuil_choisi;
  }
  else if(vanne == 'c') {
    seuil_vanne3 = seuil_choisi;
  }
  else if(vanne == 'd') {
    seuil_vanne4 = seuil_choisi;
  }
}


void calcul_cumul() {
  if(seuil_vanne1 > 0 || seuil_vanne2 > 0 || seuil_vanne3 > 0 || seuil_vanne4 > 0) {
    int mesure_brute = analogRead(potPin);
    cumul1 = cumul1 + mesure_brute;
    cumul2 = cumul2 + mesure_brute;
    cumul3 = cumul3 + mesure_brute;
    cumul4 = cumul4 + mesure_brute;
    
    Serial.print("cumul1 = "), Serial.println(cumul1);
    
    if(cumul1 >= seuil_vanne1) {
      queue.push(file_attente_vanne1);
      cumul1 = 0;
    }
    else if(cumul2 >= seuil_vanne2) {
      queue.push(file_attente_vanne2);
      cumul2 = 0;
    }
    else if(cumul3 >= seuil_vanne3) {
      queue.push(file_attente_vanne3);
      cumul3 = 0;
    }
    else if(cumul4 >= seuil_vanne4) {
      queue.push(file_attente_vanne4);
      cumul4 = 0;
    }
  }
}

void duree(char vanne, char d_min, char u_min, char d_sec, char u_sec) {
  long duree = (((d_min - 48) * 10 + (u_min - 48)) * 60 + (d_sec - 48) * 10 + (u_sec - 48)) * 1000;
  
  Serial.print("Duree : ");
  Serial.println(duree);
   
  if(vanne == 'a') {
    duree_vanne1 = duree;
  }
  else if(vanne == 'b') {
    duree_vanne2 = duree;
  }
  else if(vanne == 'c') {
    duree_vanne3 = duree; 
  }
  else if(vanne == 'd') {
    duree_vanne4 = duree; 
  }
}

void arrosage(boolean etat_vanne1, boolean etat_vanne2, boolean etat_vanne3, boolean etat_vanne4) {
 
 if(etat_vanne1 == false && etat_vanne2 == false && etat_vanne3 == false && etat_vanne4 == false) {
   if(queue.peek() == 1) {
     etat_vanne1 = true;
     digitalWrite(vanne_1, HIGH);
     delay(duree_vanne1);
     digitalWrite(vanne_1, LOW);
     etat_vanne1 = false;
     queue.pop();
    }
    
   if(queue.peek() == 2) {
     etat_vanne2 = true;
     digitalWrite(vanne_2, HIGH);
     delay(duree_vanne2);
     digitalWrite(vanne_2, LOW);
     etat_vanne2 = false;
     queue.pop();
    }
    
   if(queue.peek() == 3) {
     etat_vanne3 = true;
     digitalWrite(vanne_3, HIGH);
     delay(duree_vanne3);
     digitalWrite(vanne_3, LOW);
     etat_vanne3 = false;
     queue.pop();
    }
    
   if(queue.peek() == 4) {
     etat_vanne4 = true;
     digitalWrite(vanne_4, HIGH);
     delay(duree_vanne4);
     digitalWrite(vanne_4, LOW);
     etat_vanne4 = false;
     queue.pop();
    }
  }
}

ISR(TIMER0_COMPA_vect){
  ticks++;
  if(ticks >= 3000) {
    ticks = 0;
    calcul_cumul();
  }
}

Le problème est que lorsque nous essayons de mettre une valeur spécifique dans la file d’attente en fonction de l’instruction reçue, (grâce à queue.push()), cela ne fonctionne pas… Avez vous une idée ?

D’avance merci

Je suis bluffé : Un lycéen qui fait des phrases presque sans faute, avec des explications, et surtout du code... Les autres, prenez en de la graine !

Désolé, je connais pas QueueArray....

Merci pour les compliments , mais on est vraiment en galère.