Skip to main content

Arroseur automatique de plante


Informations

  • Sean RAMS
  • ramsean2001@gmail.com
  • Master informatique : SESI
  • 02/06/2023 - 20/06/2023
 

Contexte

Afin de préserver les plantes du fablab, je me suis vu attribué la création d'arroseur automatique pour les diverses plantes du fablab.

Objectifs

Réaliser des arroseurs automatique pour diverses plantes 

Matériel

  • Arduino mega
  • Pompe ( nombre dĂ©pendant du nombre de plante) 
  • Capteur d'humiditĂ© sol  ( nombre  dĂ©pendant du nombre de plante) 

Machines utilisées

Aucune 

Construction

(Fichiers, photos, code, explications, paramĂštres d'usinage, photos, captures d'Ă©cran...)

Étape 1

----

Étape 2

----

Étape 3

----

 

Journal de bord

02/06 Premier pas dans le projet: 

int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;


void setup() {
    Serial.begin(9600);
    pinMode(PinR,OUTPUT);
    pinMode(PinV,OUTPUT);
    pinMode(PinB,OUTPUT);
    }
void loop() {
    // read the value from the sensor:
    sensorValue = analogRead(sensorPin);
    Serial.print("Moisture = " );
    Serial.println(sensorValue);
    if (sensorValue < 300){
      digitalWrite(PinV,HIGH);    
      digitalWrite(PinR,LOW);
    }
    else {
      digitalWrite(PinR,HIGH);    
      digitalWrite(PinV,LOW);
    }
    delay(1000);
}

15/06 Test d'utilisation de la pompe.


int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;
int pompe = 2;
int serial = 101;

void setup() {
    Serial.begin(9600);
    pinMode(PinR,OUTPUT);
    pinMode(PinV,OUTPUT);
    pinMode(PinB,OUTPUT);
    pinMode(pompe,OUTPUT);
    }
void loop() {
    // read the value from the sensor:
   /* sensorValue = analogRead(sensorPin);
    Serial.print("Moisture = " );
    Serial.println(sensorValue);
    if (sensorValue < 300){
      digitalWrite(PinV,HIGH);    
      digitalWrite(PinR,LOW);
    }
    else {
      digitalWrite(PinR,HIGH);    
      digitalWrite(PinV,LOW);
    }*/

    if (serial >'5' ){
      digitalWrite(pompe,HIGH);
    }else{
      digitalWrite(pompe,LOW);
    }
    if(Serial.available() > 0)  {
      serial= Serial.read();
    }
    Serial.println(serial);
    delay(1000);
}

L'idée est de combiner la pompe et le capteur pour alimenter la plante lorsque la terre est séche.

Code fonctionnel pour arroser une plante en fonction de l'humidité de sa terre.

int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;
int pompe = 2;
void setup() {
    Serial.begin(9600);
    pinMode(PinR,OUTPUT);
    pinMode(PinV,OUTPUT);
    pinMode(PinB,OUTPUT);
    pinMode(pompe,OUTPUT);
    
     digitalWrite(pompe,LOW);
    }
void loop() {
    // read the value from the sensor:
    sensorValue = analogRead(sensorPin);
    Serial.print("Moisture = " );
    Serial.println(sensorValue);
    if (sensorValue > 300){
      
      digitalWrite(PinV,HIGH);    
      digitalWrite(PinR,LOW);
    }
    else {
      
      digitalWrite(PinR,HIGH);    
      digitalWrite(PinV,LOW);
      digitalWrite(pompe,HIGH);
      delay(3000);

    }
    
    digitalWrite(pompe,LOW);
    delay(3000);
}

DĂ©but de la programmation en tache distincte pour essayer d'utiliser plusieurs capteur/pompe sur une Arduino.

/*
int sensorPin = A0;
int sensorValue = 0;
int PinR = 7;
int PinV = 8;
int PinB = 4;
int pompe = 2;
*/

#define MAX_WAIT_FOR_TIMER 4

unsigned int waitFor(int timer, unsigned long period){
  static unsigned long waitForTimer[MAX_WAIT_FOR_TIMER];  // il y a autant de timers que de tùches périodiques
  unsigned long newTime = micros() / period;              // numéro de la période modulo 2^32 
  int delta = newTime - waitForTimer[timer];              // delta entre la période courante et celle enregistrée
  if ( delta < 0 ) delta = 1 + newTime;                   // en cas de dépassement du nombre de périodes possibles sur 2^32 
  if ( delta ) waitForTimer[timer] = newTime;             // enregistrement du nouveau numéro de période
  return delta;
}

enum {EMPTY, FULL};

struct mailbox_s {
  int state;
  int val;
};

struct mailbox_s mb = {.state = EMPTY};

//tache pour la lecteur d'un des capteurs.


struct CaptHum{
  int timer;
  unsigned long period;
  int pin;  
}

void setup_hum( struct CaptHum * ctx,struct mailbox_s * mb, int timer, unsigned long period, byte pin){
  ctx->timer = timer;
  ctx->period = period;
  ctx->pin = pin;
  pinMode(ctx->pin,INPUT);
}

void loop_lum( struct CaptLum * ctx,struct mailbox_s * mb) {
  if (!waitFor(ctx->timer, ctx->period)) return;          // sort s'il y a moins d'une période écoulée
  if (mb->state != EMPTY) return;  
  mb->val = analogRead(ctx->pin);
  mb->state=FULL;      
}  

//Tache d'activation de l'arosage

struct Active{
  int timer;
  unsigned long period;
  int pinpompe;
  int pinledR;
  int pinledV;  
}

void setup_active( struct CaptHum * ctx,struct mailbox_s * mb, int timer, unsigned long period, byte pin){
  ctx->timer = timer;
  ctx->period = period;
  ctx->pin = pin;
  pinMode(ctx->pin,INPUT);
}

void loop_active( struct CaptLum * ctx,struct mailbox_s * mb) {
  if (!waitFor(ctx->timer, ctx->period)) return;          // sort s'il y a moins d'une période écoulée
  if (mb->state != EMPTY) return;  
  mb->val = analogRead(ctx->pin);
  mb->state=FULL;      
}  

//tache qui desactive la pompe

struct Desactive{
  int timer;
  unsigned long period;
  int pinpompe;
  int pinledR;
  int pinledV;  
}

void setup_active( struct CaptHum * ctx,struct mailbox_s * mb, int timer, unsigned long period, byte pin){
  ctx->timer = timer;
  ctx->period = period;
  ctx->pin = pin;
  pinMode(ctx->pin,INPUT);
}

void loop_active( struct CaptLum * ctx,struct mailbox_s * mb) {
  if (!waitFor(ctx->timer, ctx->period)) return;          // sort s'il y a moins d'une période écoulée
  if (mb->state != EMPTY) return;  
  mb->val = analogRead(ctx->pin);
  mb->state=FULL;      
} 


void setup() {
    /*
    Serial.begin(9600);
    pinMode(PinR,OUTPUT);
    pinMode(PinV,OUTPUT);
    pinMode(PinB,OUTPUT);
    pinMode(pompe,OUTPUT);
    digitalWrite(pompe,LOW);    
    */
    }
void loop() {
    /*
    // read the value from the sensor:
    sensorValue = analogRead(sensorPin);
    Serial.print("Moisture = " );
    Serial.println(sensorValue);
    if (sensorValue > 300){
      
      digitalWrite(PinV,HIGH);    
      digitalWrite(PinR,LOW);
    }
    else {
      
      digitalWrite(PinR,HIGH);    
      digitalWrite(PinV,LOW);
      digitalWrite(pompe,HIGH);
      delay(3000);

    }
    
    digitalWrite(pompe,LOW);
    delay(3000);
    */
}

16/06 : Code pouvant utiliser plusieurs capteur et pompe sur un seul arduino (pour seulement deux dans ce code)

/*
Ne pas modifier cette partie du code
*/

#define MAX_WAIT_FOR_TIMER 16

unsigned int waitFor(int timer, unsigned long period){
  static unsigned long waitForTimer[MAX_WAIT_FOR_TIMER];  // il y a autant de timers que de tùches périodiques
  unsigned long newTime = millis() / period;              // numéro de la période modulo 2^32 
  int delta = newTime - waitForTimer[timer];              // delta entre la période courante et celle enregistrée
  if ( delta < 0 ) delta = 1 + newTime;                   // en cas de dépassement du nombre de périodes possibles sur 2^32 
  if ( delta ) waitForTimer[timer] = newTime;             // enregistrement du nouveau numéro de période
  return delta;
}

enum {EMPTY, FULL};
//Structure mail box servant au tache Ă  communiquer.
struct mailbox_capteur {
  int state;
  int val;
};

struct mailbox_timer {
  int state;
  unsigned long time_stop;
};

//tache pour la lecteur d'un des capteurs.

struct CaptHum{
  int timer;
  unsigned long period;
  int pin;  
};

void setup_hum( struct CaptHum * ctx,struct mailbox_capteur * mb_cap, int timer, unsigned long period, int pin){
  /*
  	Fonction permetant d'initialiser une tache qui va périodiquement effectuer des messures d'humidité. 
    
    ctx : Pointeur vers la suctruture qui va ĂȘtre initialiser 
    mb_cap: pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre Ă  la tache d'activation de la pompe
    timer : Identifier UNIQUE permetant à wait timer d'excuter la messure périodiquement.
    period : Indique le temps d'attente minimal entre deux messure (malereusement en unitĂ© inconnue mais suposser ĂȘtre des millisecondes)
    pin : Pin ANALOGIQUE utiliser pour prendre la messure.
  */
  //Initialisation des timer et period pour le waitfor permetant d'organiser les taches.
  ctx->timer = timer;
  ctx->period = period;
 
  ctx->pin = pin;
}

void loop_hum( struct CaptHum * ctx,struct mailbox_capteur * mb_cap, struct mailbox_timer *mb_time ) {
    /*
  	Fonction permetant effectuer des messures d'humidité périodiquement sur un capteur donné. 
    
    ctx : Pointeur vers la suctruture qui a été initialiser 
    mb_cap : pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre Ă  la tache d'activation de la pompe
   	mb_time : pointeur vers la mailbox permetant d'ùrréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
  */
  if (mb_cap->state != EMPTY) return;
  if (mb_time->state != EMPTY) return;
  if (!waitFor(ctx->timer, ctx->period)) return;          // sort s'il y a moins d'une période écoulée
    
  
  mb_cap->val = analogRead(ctx->pin);

  Serial.print(String("Moisture ")+String(ctx->timer)+String(" = ") );
  Serial.println(mb_cap->val);

  mb_cap->state=FULL;      
}  

//Tache d'activation de l'arosage

struct Active{
  int pinpompe;
  int pinledR;
  int pinledV;
  int seuil;
  int time_active;  
};

void setup_active( struct Active * ctx, int pinpompe, int pinledR, int pinledV, int seuil, unsigned long time_active){
   /*
  	Fonction permetant d'initialiser une tache qui va si la meussure reçu est trop faible activer la pompe. 
    
    ctx : Pointeur vers la suctruture qui va ĂȘtre initialiser 
    pinpompe : Pin controlant la pompe.
    pinledR : Pin controlant la  led rouge.
    pinledV : Pin controlant la led vert.
    seuil : Seuil pour lequel la terre est considére comme trop séche.
    time_active : temps d'activation de la pompe en milliseconde (environ) 
  */
  //Initialisation des pin de la pompe, des led rouge et vert pour une tache active 
  ctx->pinpompe = pinpompe;
  ctx->pinledR = pinledR;
  ctx->pinledR = pinledR;
  
  //Setup des différente pin utiliser.
  pinMode(ctx->pinpompe,OUTPUT);
  pinMode(ctx->pinledR,OUTPUT);
  pinMode(ctx->pinledV,OUTPUT);
  
  //Initialisation des variable pour activer la pompe et sa durée
  ctx->seuil = seuil;
  ctx->time_active = time_active;

  //DĂ©sactive la pompe dans son setup
  digitalWrite(ctx->pinledR,LOW);    
  digitalWrite(ctx->pinledV,HIGH); 
  digitalWrite(ctx->pinpompe,LOW);
}

void loop_active( struct Active * ctx, struct mailbox_capteur * mb_cap, struct mailbox_timer * mb_time) {
     /*
  	Fonction permetant d'activer la pompe pour un temps donné. 
    
    ctx : Pointeur vers la suctruture de la tache qui a été initialiser 
    mb_cap : pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre Ă  la tache d'activation de la pompe
   	mb_time : pointeur vers la mailbox permetant d'ùrréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
  */
  //Test des différentes condiction avant d'activer la pompe  
  if (mb_cap->state != FULL) return;
  if (mb_cap->val <= ctx->seuil ) {
    //Alumage de la led rouge et de la pompe (+ Ă©tient la led vert) pour signaler que la plante est arroser 
    digitalWrite(ctx->pinledR,HIGH);    
    digitalWrite(ctx->pinledV,LOW);
    digitalWrite(ctx->pinpompe,HIGH);  
    
    //Initialise la mailbox pour Ă©tiendre la pompe    
    mb_time->time_stop =  millis() + ctx->time_active;
    mb_time->state=FULL;
    Serial.println(String("Pompe active ")+ctx->pinpompe);
  }
  mb_cap->state = EMPTY;       
}  

//tache qui desactive la pompe

struct Desactive{
  int pinpompe;
  int pinledR;
  int pinledV; 
};

void setup_desactive( struct Desactive * ctx, int pinpompe, int pinledR, int pinledV){
   /*
  	Fonction permetant d'initialiser une tache qui va si la meussure reçu est trop faible activer la pompe. 
    
    ctx : Pointeur vers la suctruture qui va ĂȘtre initialiser 
    pinpompe : Pin controlant la pompe. (doit ĂȘtre la mĂȘme que celle de la tache d'activation de la pompe associĂ©)
    pinledR : Pin controlant la  led rouge.(doit ĂȘtre la mĂȘme que celle de la tache d'activation de la pompe associĂ©)
    pinledV : Pin controlant la led vert.(doit ĂȘtre la mĂȘme que celle de la tache d'activation de la pompe associĂ©)
  */
  ctx->pinpompe = pinpompe;
  ctx->pinledR = pinledR;
  ctx->pinledV = pinledV;
  
  pinMode(ctx->pinpompe,OUTPUT);
  pinMode(ctx->pinledR,OUTPUT);
  pinMode(ctx->pinledV,OUTPUT);

  
  digitalWrite(ctx->pinledR,LOW);    
  digitalWrite(ctx->pinledV,HIGH); 
  digitalWrite(ctx->pinpompe,LOW);
}

void loop_desactive( struct Desactive * ctx, struct mailbox_timer * mb_time) {
  /*
  	Fonction permetant de desactiver la pompe apres un temps donné par la mailbox timer. 
    
    ctx : Pointeur vers la suctruture de la tache qui a été initialiser
   	mb_time : pointeur vers la mailbox permetant d'ùrréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
  */
  Serial.println(String("mb time desa = ")+mb_time->state+" "+mb_time->time_stop);
  Serial.println(String("millis = ")+millis());
  if (mb_time->state != FULL) return;  
  if( millis()>= mb_time->time_stop){
    digitalWrite(ctx->pinledR,LOW);    
    digitalWrite(ctx->pinledV,HIGH); 
    digitalWrite(ctx->pinpompe,LOW);
    Serial.println("Pompe desactive "+ctx->pinpompe);
    mb_time->state = EMPTY;  
  }      
} 

// Declaration des tache et des mailbox (si ajout de capteur et/ou pompe Ă  faire Ă  partir d'ici)

//mail box
struct mailbox_capteur mb_cap0 = {.state = EMPTY};
struct mailbox_timer mb_time0 = {.state = EMPTY};

struct mailbox_capteur mb_cap1 = {.state = EMPTY};
struct mailbox_timer mb_time1 = {.state = EMPTY};

//tache
struct CaptHum Hum0;
struct Active acti0;
struct Desactive desa0;

struct CaptHum Hum1;
struct Active acti1;
struct Desactive desa1;

void setup() {
  Serial.begin(9600);

  setup_hum(&Hum0, &mb_cap0, 0, 1000, A0);  
  setup_active(&acti0, 2, 7, 8, 400, 2000);
  setup_desactive(&desa0, 2, 7, 8);
  
  setup_hum(&Hum1, &mb_cap0, 1, 1000, A1);  
  setup_active(&acti1, 12, 13, 22, 400, 2000);
  setup_desactive(&desa1, 12, 13, 22);
}
void loop() {
  loop_hum(&Hum0, &mb_cap0, &mb_time0);  
  loop_active(&acti0, &mb_cap0, &mb_time0);
  loop_desactive(&desa0, &mb_time0);

  
  loop_hum(&Hum1, &mb_cap1, &mb_time1);  
  loop_active(&acti1, &mb_cap1, &mb_time1);
  loop_desactive(&desa1, &mb_time1);
}

19/06:

Pour ajouter des nouveaux capteurs, il faut crĂ©Ă© deux nouvelles mail box de chaque type ( mailbox_capteur et mailbox_timer), une nouvelle tĂąche de chaque type (CaptHum, Active et Desactive).Il faut ensuite les setups de la mĂȘme maniĂšre que sur le code dĂ©jĂ  prĂ©sent chaque variable est expliquĂ© dans les commentaire de chaque fonction. Il est important de d'avoir en commun sur active et desactive les pin pour la pompe et led. Les leds servent pour le dĂ©bug est ne sont pas nĂ©cessaire Ă  brancher.  Puis il faut ajouter les fonction loop avec les tache et les mail crĂ©er.  

Schéma des connexions pour faire fonctionner le code au dessus (sans certaine led).


image-1687211675146.png

Il faut noté que le capteur à 4 pin cependant la pin non labéliser (entre VCC et SIG) ne sert a rien et donc nécessite aucune connexion. 

23/06:

On a supprimé les paramÚtres LED (gauche et droite) dans les fonctions hum, setup et desactive, puis a créé des nouvelles fonctions pour les autres pompes qu'on va installer sur la carte (un total de 7 pompes).

/*
Ne pas modifier cette partie du code
*/

#define MAX_WAIT_FOR_TIMER 16

unsigned int waitFor(int timer, unsigned long period){
  static unsigned long waitForTimer[MAX_WAIT_FOR_TIMER];  // il y a autant de timers que de tùches périodiques
  unsigned long newTime = millis() / period;              // numéro de la période modulo 2^32 
  int delta = newTime - waitForTimer[timer];              // delta entre la période courante et celle enregistrée
  if ( delta < 0 ) delta = 1 + newTime;                   // en cas de dépassement du nombre de périodes possibles sur 2^32 
  if ( delta ) waitForTimer[timer] = newTime;             // enregistrement du nouveau numéro de période
  return delta;
}

enum {EMPTY, FULL};
//Structure mail box servant au tache Ă  communiquer.
struct mailbox_capteur {
  int state;
  int val;
};

struct mailbox_timer {
  int state;
  unsigned long time_stop;
};

//tache pour la lecteur d'un des capteurs.

struct CaptHum{
  int timer;
  unsigned long period;
  int pin;  
};

void setup_hum( struct CaptHum * ctx,struct mailbox_capteur * mb_cap, int timer, unsigned long period, int pin){
  /*
  	Fonction permetant d'initialiser une tache qui va périodiquement effectuer des messures d'humidité. 
    
    ctx : Pointeur vers la suctruture qui va ĂȘtre initialiser 
    mb_cap: pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre Ă  la tache d'activation de la pompe
    timer : Identifier UNIQUE permetant à wait timer d'excuter la messure périodiquement.
    period : Indique le temps d'attente minimal entre deux messure (malereusement en unitĂ© inconnue mais suposser ĂȘtre des millisecondes)
    pin : Pin ANALOGIQUE utiliser pour prendre la messure.
  */
  //Initialisation des timer et period pour le waitfor permetant d'organiser les taches.
  ctx->timer = timer;
  ctx->period = period;
 
  ctx->pin = pin;
}

void loop_hum( struct CaptHum * ctx,struct mailbox_capteur * mb_cap, struct mailbox_timer *mb_time ) {
    /*
  	Fonction permetant effectuer des messures d'humidité périodiquement sur un capteur donné. 
    
    ctx : Pointeur vers la suctruture qui a été initialiser 
    mb_cap : pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre Ă  la tache d'activation de la pompe
   	mb_time : pointeur vers la mailbox permetant d'ùrréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
  */
  if (mb_cap->state != EMPTY) return;
  if (mb_time->state != EMPTY) return;
  if (!waitFor(ctx->timer, ctx->period)) return;          // sort s'il y a moins d'une période écoulée
    
  
  mb_cap->val = analogRead(ctx->pin);

  Serial.print(String("Moisture ")+String(ctx->timer)+String(" = ") );
  Serial.println(mb_cap->val);

  mb_cap->state=FULL;      
}  

//Tache d'activation de l'arosage

struct Active{
  int pinpompe;
  int seuil;
  int time_active;  
};

void setup_active( struct Active * ctx, int pinpompe, int seuil, unsigned long time_active){
   /*
  	Fonction permetant d'initialiser une tache qui va si la meussure reçu est trop faible activer la pompe. 
    
    ctx : Pointeur vers la suctruture qui va ĂȘtre initialiser 
    pinpompe : Pin controlant la pompe.
    seuil : Seuil pour lequel la terre est considére comme trop séche.
    time_active : temps d'activation de la pompe en milliseconde (environ) 
  */
  //Initialisation des pin de la pompe pour une tache active 
  ctx->pinpompe = pinpompe;
  
  //Setup des différente pin utiliser.
  pinMode(ctx->pinpompe,OUTPUT);
  
  //Initialisation des variable pour activer la pompe et sa durée
  ctx->seuil = seuil;
  ctx->time_active = time_active;

  //DĂ©sactive la pompe dans son setup
  digitalWrite(ctx->pinpompe,LOW);
}

void loop_active( struct Active * ctx, struct mailbox_capteur * mb_cap, struct mailbox_timer * mb_time) {
     /*
  	Fonction permetant d'activer la pompe pour un temps donné. 
    
    ctx : Pointeur vers la suctruture de la tache qui a été initialiser 
    mb_cap : pointeur vers la mailbox permetant d'enregistrer la messure du capteur et la transmetre Ă  la tache d'activation de la pompe
   	mb_time : pointeur vers la mailbox permetant d'ùrréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
  */
  //Test des différentes condiction avant d'activer la pompe  
  if (mb_cap->state != FULL) return;
  if (mb_cap->val <= ctx->seuil ) {
    //Alumage de la led rouge et de la pompe (+ Ă©tient la led vert) pour signaler que la plante est arroser 
    digitalWrite(ctx->pinpompe,HIGH);  
    
    //Initialise la mailbox pour Ă©tiendre la pompe    
    mb_time->time_stop =  millis() + ctx->time_active;
    mb_time->state=FULL;
    Serial.println(String("Pompe active ")+ctx->pinpompe);
  }
  mb_cap->state = EMPTY;       
}  

//tache qui desactive la pompe

struct Desactive{
  int pinpompe;
};

void setup_desactive( struct Desactive * ctx, int pinpompe){
   /*
  	Fonction permetant d'initialiser une tache qui va si la meussure reçu est trop faible activer la pompe. 
    
    ctx : Pointeur vers la suctruture qui va ĂȘtre initialiser 
    pinpompe : Pin controlant la pompe. (doit ĂȘtre la mĂȘme que celle de la tache d'activation de la pompe associĂ©)
  */
  ctx->pinpompe = pinpompe;
  
  pinMode(ctx->pinpompe,OUTPUT);

  digitalWrite(ctx->pinpompe,LOW);
}

void loop_desactive( struct Desactive * ctx, struct mailbox_timer * mb_time) {
  /*
  	Fonction permetant de desactiver la pompe apres un temps donné par la mailbox timer. 
    
    ctx : Pointeur vers la suctruture de la tache qui a été initialiser
   	mb_time : pointeur vers la mailbox permetant d'ùrréter la pompe, présente pour eviter de prendre des messure lorsque la pompe est active.
  */
  Serial.println(String("mb time desa = ")+mb_time->state+" "+mb_time->time_stop);
  Serial.println(String("millis = ")+millis());
  if (mb_time->state != FULL) return;  
  if( millis()>= mb_time->time_stop){
    digitalWrite(ctx->pinpompe,LOW);
    Serial.println("Pompe desactive "+ctx->pinpompe);
    mb_time->state = EMPTY;  
  }      
} 

// Declaration des tache et des mailbox (si ajout de capteur et/ou pompe Ă  faire Ă  partir d'ici)

//mail box
struct mailbox_capteur mb_cap0 = {.state = EMPTY};
struct mailbox_timer mb_time0 = {.state = EMPTY};

struct mailbox_capteur mb_cap1 = {.state = EMPTY};
struct mailbox_timer mb_time1 = {.state = EMPTY};

struct mailbox_capteur mb_cap2 = {.state = EMPTY};
struct mailbox_timer mb_time2 = {.state = EMPTY};

struct mailbox_capteur mb_cap3 = {.state = EMPTY};
struct mailbox_timer mb_time3 = {.state = EMPTY};

struct mailbox_capteur mb_cap4 = {.state = EMPTY};
struct mailbox_timer mb_time4 = {.state = EMPTY};

struct mailbox_capteur mb_cap5 = {.state = EMPTY};
struct mailbox_timer mb_time5 = {.state = EMPTY};

struct mailbox_capteur mb_cap6 = {.state = EMPTY};
struct mailbox_timer mb_time6 = {.state = EMPTY};

//tache
struct CaptHum Hum0;
struct Active acti0;
struct Desactive desa0;

struct CaptHum Hum1;
struct Active acti1;
struct Desactive desa1;

struct CaptHum Hum2;
struct Active acti2;
struct Desactive desa2;

struct CaptHum Hum3;
struct Active acti3;
struct Desactive desa3;

struct CaptHum Hum4;
struct Active acti4;
struct Desactive desa4;

struct CaptHum Hum5;
struct Active acti5;
struct Desactive desa5;

struct CaptHum Hum6;
struct Active acti6;
struct Desactive desa6;

void setup() {
  Serial.begin(9600);

  setup_hum(&Hum0, &mb_cap0, D2, 1000, A0);  
  setup_active(&acti0, D2, 400, 10000);
  setup_desactive(&desa0, D2);
  
  setup_hum(&Hum1, &mb_cap1, D3, 1000, A1);  
  setup_active(&acti1, D3, 400, 10000);
  setup_desactive(&desa1, D3);

  setup_hum(&Hum2, &mb_cap2, D4, 1000, A2);
  setup_active(&acti2, D4, 400, 10000);
  setup_desactive(&desa2, D4);

  setup_hum(&Hum3, &mb_cap3, D5, 1000, A3);
  setup_active(&acti3, D5, 400, 10000);
  setup_desactive(&desa3, D5);

  setup_hum(&Hum4, &mb_cap4, D6, 1000, A4);
  setup_active(&acti4, D6, 400, 10000);
  setup_desactive(&desa4, D6);

  setup_hum(&Hum5, &mb_cap5, D7, 1000, A5);
  setup_active(&acti5, D7, 400, 10000);
  setup_desactive(&desa5, D7);

  setup_hum(&Hum6, &mb_cap6, D8, 1000, A6);
  setup_active(&acti6, D8, 400, 10000);
  setup_desactive(&desa6, D8);
}

void loop() {
  loop_hum(&Hum0, &mb_cap0, &mb_time0);  
  loop_active(&acti0, &mb_cap0, &mb_time0);
  loop_desactive(&desa0, &mb_time0);

  
  loop_hum(&Hum1, &mb_cap1, &mb_time1);  
  loop_active(&acti1, &mb_cap1, &mb_time1);
  loop_desactive(&desa1, &mb_time1);

  loop_hum(&Hum2, &mb_cap2, &mb_time2);  
  loop_active(&acti2, &mb_cap2, &mb_time2);
  loop_desactive(&desa2, &mb_time2);

  loop_hum(&Hum3, &mb_cap3, &mb_time3);  
  loop_active(&acti3, &mb_cap3, &mb_time3);
  loop_desactive(&desa3, &mb_time3);

  loop_hum(&Hum4, &mb_cap4, &mb_time4);  
  loop_active(&acti4, &mb_cap4, &mb_time4);
  loop_desactive(&desa4, &mb_time4);

  loop_hum(&Hum5, &mb_cap5, &mb_time5);  
  loop_active(&acti5, &mb_cap5, &mb_time5);
  loop_desactive(&desa5, &mb_time5);

  loop_hum(&Hum6, &mb_cap6, &mb_time6);  
  loop_active(&acti6, &mb_cap6, &mb_time6);
  loop_desactive(&desa6, &mb_time6);
}
Back to top