Porteur(s) du projet: Patrice Moustache (contact : luc@toimemetusais.com)
Arnaud Fournier (contact : arnaud.fournier1@etu.upmc.fr)

• Date de début : 10/2017
• Les autocuiseurs sous vide sont onéreux, avec de la récupération et un arduino on pense pouvoir en fabriquer un pour beaucoup moins cher.
• Date de fin estimée : 11/2017

- 1 Arduino Uno ou similaire fournisseur : Electrodragon 9.64 € -1 shield relai fournisseur : gotronic ===== Construction ===== ==== Partie 1 ==== ==== Partie 2 === e #define ENGINE_PIN A2 Courant envoye dans le fils de nichrome pour chauffer le bain marie #define WITNESS_LED_PIN A3 LED de controle #define OK_PIN 2 #define SEALER_PIN 4 Courant envoyer dans le fils de nichrome pour sceller le sac de cuisson #define HEAT_PIN 5 Ventilateur sous marin pour faire circuler leau #define SCREEN_LUMINOSITY_PIN 6 Valeur de lintensite lumineuse du retro eclairage pour lecran #define BACKLIGHT_PIN 7 Retroeclairage de lecran LCD #define LCD_RS 8 #define LCD_E 9 #define LCD_D4 10 #define LCD_D5 11 #define LCD_D6 12 #define LCD_D7 13 /* TEMPERATURE A0 SCROLLER A1 WITNESS LED 3 HEATER 1 OK BUTTON 2 SEALER 4 ENGINE 5 BACKLIGHT 7 VO 6 RS 8 E 9 D4-D7 10-13 */ #define GREETING_TEXT “Bienvenue” #define USERNAME “NoName” #define MAIN_MENU_TEXT “Cuisiner” #define PREVIOUS_MENU_TEXT “Retour” #define MEAT_MAIN_MENU_TEXT “1.Viandes” #define FISH_MAIN_MENU_TEXT “2.Poissons” #define VEGETABLES_MAIN_MENU_TEXT “4.Legumes” #define EGG_MAIN_MENU_TEXT “3.Oeuf” #define LIQUID_MAIN_MENU_TEXT “5.Boissons” #define FRUITS_MAIN_MENU_TEXT “9.Fruits” #define PASTA_MAIN_MENU_TEXT “7.Pattes” #define RICE_MAIN_MENU_TEXT “6.Riz” #define MEAT_MENU_BEEF_TEXT “Boeuf” #define FISH_MENU_WHITE_FISH_TEXT “Cabillaud” #define EGG_MENU_EGG62_TEXT “Oeuf 62C” #define VEGETABLES_MENU_HARD_TEXT “Racines” #define LIQUID_MENU_GREEN_TEA_TEXT “The vert” #define RICE_MENU_WHITE_TEXT “Riz blanc” #define PASTA_MENU_PASTA7_TEXT “Pattes 7min” #define FRUITS_MENU_CRUNCHY_TEXT “Fruits(fermes)” #define ABORT_TEXT “Abort cooking” #define COOKING_SUCCESS_TEXT “Cooking over!” #define STARTING_PREHEAT_TEXT “Preheating…” #define ENDING_PREHEAT_TEXT “Preheat over…” #define ABS(x) ¹⁾ #define CLEAR_LCD_SCREEN() lcd.setCursor(0,0);\ lcd.print(“ ”);\ lcd.setCursor(0,1);\ lcd.print(“ ”); #define CLEAR_LCD_LINE_1() lcd.setCursor(0,0);\ lcd.print(“ ”) #define CLEAR_LCD_LINE_2() lcd.setCursor(0,1);\ lcd.print(“ ”) unsigned long ticks = 0; unsigned long reference = 0; bool onCooking = true; unsigned long backLightTimer = 0; unsigned long backLightTimerUpdated = 0; volatile bool buttonPushed = false; bool insideMenu = true; float cookTimer = 0; unsigned int scroller = 0; unsigned int bufferScroller = 0; float cookingTemperature = 0; float cookingTime = 0; unsigned int tempTreshold = 0; unsigned int bufferTemperature = 0; bool endCooking = false; bool sameChoice = false; bool backLightState = true; bool wasPreheated = false; float deltaTemperature = 0; unsigned long hourTimer = 0; unsigned long minTimer = 0; unsigned long secTimer = 0; unsigned long ellapsedTime = 0; unsigned int realTimeTempInt = 0; char timeTracker[15]; char strTemperature[4]; Pour chaque aliment on stocke dans un tableau la temperature et la duree de la cuisson

unsigned int menuProgram = 0; unsigned int twoOption = 0;

unsigned int meatProgram = 0; float meatArray[NUMBER_MEAT_CHOICE*2];

unsigned int fishProgram = 0; float fishArray[NUMBER_FISH_CHOICE*2];

unsigned int vegetableProgram = 0; float vegetableArray[NUMBER_VEGETABLES_CHOICE*2];

unsigned int eggProgram = 0; float eggArray[NUMBER_EGG_CHOICE*2];

unsigned int fruitProgram = 0; float fruitArray[NUMBER_FRUITS_CHOICE*2];

unsigned int pastaProgram = 0; float pastaArray[NUMBER_PASTA_CHOICE*2];

unsigned int riceProgram = 0; float riceArray[NUMBER_RICE_CHOICE*2];

unsigned int liquidProgram = 0; float liquidArray[NUMBER_LIQUID_CHOICE*2];

LiquidCrystal lcd(LCD_RS,LCD_E,LCD_D4,LCD_D5,LCD_D6,LCD_D7);

byte degreeCharacter[8] = {

0b01000,
0b10100,
0b01000,
0b00011,
0b00100,
0b00100,
0b00100,
0b00011

};

Fonctions systeme void menuPrincipal(); void menuSelect(); Choix des differentes options de cuisson du menu

void meatMenu(); void meatSelect();

void vegeMenu(); void vegeSelect();

void eggMenu(); void eggSelect();

void fruitMenu(); void fruitSelect();

void fishMenu(); void fishSelect();

void liquidMenu(); void liquidSelect();

void pastaMenu(); void pastaSelect();

void riceMenu(); void breadMenu();

void pushButtonOK();Valider son choix void resetButtonOK(); void ledON(); Allumer une led verte lorsque la temperature est bonne void ledOFF(); Etteindre la led jusqua ce que la temperature devienne bonne void sealBag(); Sceller un sachet contenant de la nourriture unsigned int getWeight(); Poids du sachet en g void temperatureNormalise(); Uniformiser la temperature du bain marie void abortCooking(); Sortir de la sequence actuelle; void initAllPins(); unsigned char strlength(const char *str); void wait(unsigned int ms); Attendre ms millisecondes void setbackLightTimeReference(); Prendre la reference des temps pour etteindre le retro eclairage, a utiliser a chaque fois que lon a bouger un bouton void monitorCooking(); Affiche la recette en cours, le temps restant, et la temperature du bain marie void welcome(const char *username); void centerStringLCD(const char *str, bool line); void initCookingArrays(); void leaveMenu(); void enterMenu(); void resetCooking(); Fonctions de controle de la temperature void holdTemperature(); void setTemperature(unsigned char temp); float getTemperature(); void preheat();

Fonctions relatives a la cuisson void cookingSetting(unsigned char material,unsigned char recipe); void startCooking(); bool isCookingDone(); void leaveMenu() { insideMenu = false; } void enterMenu() { insideMenu = true; } void initCookingArrays() { meatArray[BEEF_INDEX_TEMPERATURE] = BEEF_TEMPERATURE; meatArray[BEEF_INDEX_COOKING_TIME] = BEEF_COOKING_TIME; fishArray[WHITE_FISH_INDEX_TEMPERATURE] = WHITE_FISH_TEMPERATURE; fishArray[WHITE_FISH_INDEX_COOKING_TIME] = WHITE_FISH_COOKING_TIME; vegetableArray[HARD_VEGETABLES_INDEX_TEMPERATURE] = HARD_VEGETABLES_TEMPERATURE; vegetableArray[HARD_VEGETABLES_COOKING_TIME] = HARD_VEGETABLES_COOKING_TIME; eggArray[EGG_62_INDEX_TEMPERATURE] = EGG_62_TEMPERATURE; eggArray[EGG_62_INDEX_COOKING_TIME] = EGG_62_COOKING_TIME; fruitArray[CRUNCHY_FRUITS_INDEX_TEMPERATURE] = CRUNCHY_FRUITS_TEMPERATURE; fruitArray[CRUNCHY_FRUITS_INDEX_COOKING_TIME] = CRUNCHY_FRUITS_COOKING_TIME; pastaArray[PASTA_7_INDEX_TEMPERATURE] = PASTA_7_TEMPERATURE; pastaArray[PASTA_7_INDEX_COOKING_TIME] = PASTA_7_COOKING_TIME; riceArray[WHITE_RICE_INDEX_TEMPERATURE] = WHITE_RICE_TEMPERATURE; riceArray[WHITE_RICE_INDEX_COOKING_TIME] = WHITE_RICE_COOKING_TIME; liquidArray[GREEN_TEA_INDEX_TEMPERATURE] = GREEN_TEA_TEMPERATURE; liquidArray[GREEN_TEA_INDEX_COOKING_TIME] = GREEN_TEA_COOKING_TIME; } void defineScreenLuminosity(unsigned char PIN,unsigned char contrast) { analogWrite(PIN,contrast); } void setbackLightTimeReference() { backLightTimer = millis(); } unsigned char strlength(const char *str) { unsigned char charlength = 0; while(*str != '\0') { charlength++; str++; } return charlength; } void centerStringLCD(const char *str, bool line) { unsigned char charlength = strlength(str); char anchor = (16 - charlength)/2.0; if(anchor < 0 ) { charlength = strlength(“error str”); anchor = (16 - charlength)/2.0; lcd.setCursor(0,line); lcd.print(“error str”); } if(anchor < 16) { lcd.setCursor(anchor,line); lcd.print(str); } if(anchor > 16) { charlength = strlength(“error str”); anchor = (16 - charlength)/2.0; lcd.setCursor(0,line); lcd.print(“error str”); } } void ledON() { digitalWrite(WITNESS_LED_PIN, HIGH); } void ledOFF() { digitalWrite(WITNESS_LED_PIN, LOW); } void abortCooking() { onCooking = false; digitalWrite(HEAT_PIN,LOW); digitalWrite(ENGINE_PIN,LOW); } void resetCooking() { endCooking = false; } void pushButtonOK() { buttonPushed = true; } void resetButtonOK() { buttonPushed = false; } void menuPrincipal() { CLEAR_LCD_LINE_1(); lcd.setCursor(0,LINE_1); lcd.print(MAIN_MENU_TEXT); Choix du programme de cuisson

menuSelect();
switch(menuProgram)
{
     case MEAT: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(MEAT_MAIN_MENU_TEXT);
              if(buttonPushed )
          { 
            resetButtonOK();
            meatMenu();
          }
          break;

     case FISH: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(FISH_MAIN_MENU_TEXT);
           if(buttonPushed)
    {
          resetButtonOK();
    fishMenu();  
    }
   
          break;

     case EGG: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(EGG_MAIN_MENU_TEXT);
           if(buttonPushed)
    {
       resetButtonOK();
   eggMenu();
    }    
          break;

     case VEGETABLES: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(VEGETABLES_MAIN_MENU_TEXT);
           if(buttonPushed)
    {
       resetButtonOK();
        vegeMenu();               
    }    
   
          break;

     case RICE: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(RICE_MAIN_MENU_TEXT);
           if(buttonPushed)
    {
       resetButtonOK();
       //riceMenu();         
    }    
   
          break;

     case PASTA: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PASTA_MAIN_MENU_TEXT);
           if(buttonPushed)
    {
       resetButtonOK();
        //pastaMenu();      
    }     
   
          break;

     case LIQUID: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(LIQUID_MAIN_MENU_TEXT);
           if(buttonPushed != true)
    {
       resetButtonOK();
        //liquidMenu();            
    }    
   
          break;
     
   case FRUITS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(FRUITS_MAIN_MENU_TEXT);
           if(buttonPushed != true)
    {
       resetButtonOK();
       //fruitMenu();         
    }    
   
          break;

     
}
wait(33);  

}

void menuSelect() {

scroller = analogRead(SCROLLER_PIN);
menuProgram = (scroller/MENU_RANGE)+1;
if(menuProgram > NUMBER_MENU_CHOICE)
{
  menuProgram = NUMBER_MENU_CHOICE;
}
if(menuProgram - bufferScroller != 0)
{
  bufferScroller = menuProgram;
sameChoice = false;
}
wait(50);

}

void meatSelect() {

scroller = analogRead(SCROLLER_PIN);
meatProgram = scroller/MEAT_RANGE;
if(meatProgram - bufferScroller != 0)
{
  bufferScroller = meatProgram;
sameChoice = false;
}

}

void fishSelect() {

scroller = analogRead(SCROLLER_PIN);
fishProgram = scroller/FISH_RANGE;
if(fishProgram - bufferScroller != 0)
{
  bufferScroller = fishProgram;
sameChoice = false;
}

}

void vegeSelect() {

  ;  
scroller = analogRead(SCROLLER_PIN);
vegetableProgram = scroller/VEGETABLES_RANGE;
if(vegetableProgram - bufferScroller != 0)
{
  bufferScroller = vegetableProgram;
sameChoice = false;
backLightState = false;
  setbackLightTimeReference();
}

}

void eggSelect() {

  ;
scroller = analogRead(SCROLLER_PIN);
eggProgram = scroller/EGG_RANGE;
if(eggProgram - bufferScroller != 0)
{
  bufferScroller = eggProgram;
sameChoice = false;
backLightState = false;
  setbackLightTimeReference();
}

}

void fruitSelect() {

scroller = analogRead(SCROLLER_PIN);
fruitProgram = scroller/FRUITS_RANGE;
if(fruitProgram - bufferScroller != 0)
{
  bufferScroller = fruitProgram;
sameChoice = false;
}

}

void liquidSelect() {

scroller = analogRead(SCROLLER_PIN);
liquidProgram = scroller/LIQUID_RANGE;
if(liquidProgram - bufferScroller != 0)
{
  bufferScroller = liquidProgram;
sameChoice = false;
}

}

void binarySelect() {

scroller = analogRead(SCROLLER_PIN);
twoOption = scroller/TWO_OPTIONS_CHOICE;
if(twoOption - bufferScroller != 0)
{
  bufferScroller = twoOption;
sameChoice = false;
} 

}

void meatMenu() {

while(insideMenu == true)
{
CLEAR_LCD_LINE_1();   
lcd.setCursor(0,LINE_1);
lcd.print(MEAT_MAIN_MENU_TEXT);
meatSelect(); 
switch(meatProgram)
{
  case PREVIOUS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PREVIOUS_MENU_TEXT);
         if(buttonPushed == true)
              {
               resetButtonOK(); 
               leaveMenu();
              }
        break;

  case BEEF: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(MEAT_MENU_BEEF_TEXT);
           if(buttonPushed == true)
       {
         resetButtonOK();
         CLEAR_LCD_LINE_1();
          lcd.setCursor(0,LINE_1);
          lcd.print(MEAT_MENU_BEEF_TEXT);     
         cookingSetting(MEAT,BEEF);
         //preheat();
         startCooking();
         while(endCooking == false)
         {
           menuSelect();
           if(buttonPushed == true)
           {
       CLEAR_LCD_LINE_2();
       lcd.setCursor(0,LINE_2);
             lcd.print(ABORT_TEXT);  
       wait(1000);
       resetButtonOK();
       leaveMenu();
       break;
       
           }
           monitorCooking();
           isCookingDone();
            ;
         }
     if(endCooking == true)
     {
         ;
       CLEAR_LCD_LINE_2();
             lcd.print(COOKING_SUCCESS_TEXT);
             wait(3000);
          leaveMenu();
         }
  }
  
  break;
}
}
enterMenu();

}

void fishMenu() {

while(insideMenu == true)
{
CLEAR_LCD_LINE_1();   
lcd.setCursor(0,LINE_1);
lcd.print(FISH_MAIN_MENU_TEXT);
fishSelect(); 
switch(fishProgram)
{
   case PREVIOUS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PREVIOUS_MENU_TEXT);
     if(buttonPushed == true)
              {
         resetButtonOK(); 
         leaveMenu();
              }
      break;

  case WHITE_FISH: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(FISH_MENU_WHITE_FISH_TEXT);
     if(buttonPushed == true)
       {
     resetButtonOK();
    CLEAR_LCD_LINE_1();
          lcd.setCursor(0,LINE_1);
          lcd.print(FISH_MENU_WHITE_FISH_TEXT);     
         cookingSetting(FISH,WHITE_FISH);
         //preheat();
         startCooking();
         while(endCooking == false)
         {
         ;
           if(buttonPushed == true)
           {
       CLEAR_LCD_LINE_2();
       lcd.setCursor(0,LINE_2);
             lcd.print(ABORT_TEXT);  
       wait(1000);
       resetButtonOK();
       leaveMenu();
       break;
       
           }
           monitorCooking();
           isCookingDone();
      ;
         }
     if(endCooking == true)
     {
       CLEAR_LCD_LINE_2();
             lcd.print(COOKING_SUCCESS_TEXT);
             wait(3000);
          leaveMenu();
         }
  }
  
  break;

}
}
enterMenu();

}

void vegeMenu() {

while(insideMenu == true)
{
CLEAR_LCD_LINE_1(); 
lcd.setCursor(0,LINE_1);
lcd.print(VEGETABLES_MAIN_MENU_TEXT);
vegeSelect(); 
switch(vegetableProgram)
{
  case PREVIOUS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PREVIOUS_MENU_TEXT);
           if(buttonPushed == true)
              {
         resetButtonOK(); 
         wait(100);        
               leaveMenu();
              }
      break;

  case HARD_VEGETABLES: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(VEGETABLES_MENU_HARD_TEXT);
     if(buttonPushed == true)
       {
     resetButtonOK();
    CLEAR_LCD_LINE_1();
          lcd.setCursor(0,LINE_1);
          lcd.print(VEGETABLES_MENU_HARD_TEXT);     
         cookingSetting(VEGETABLES,HARD_VEGETABLES);
         //preheat();
         startCooking();
         while(endCooking == false)
         {
         ;
           if(buttonPushed == true)
           {
       CLEAR_LCD_LINE_2();
       lcd.setCursor(0,LINE_2);
             lcd.print(ABORT_TEXT);  
       wait(1000);
       resetButtonOK();
       leaveMenu();
       break;
       
           }
           monitorCooking();
           isCookingDone();
      ;
         }
     if(endCooking == true)
     {
       CLEAR_LCD_LINE_2();
             lcd.print(COOKING_SUCCESS_TEXT);
             wait(3000);
          leaveMenu();
         }
  }
  
  break;

}
}
enterMenu();

}

void eggMenu() {

while(insideMenu == true)
{
CLEAR_LCD_LINE_1();
lcd.setCursor(0,LINE_1);
lcd.print(EGG_MAIN_MENU_TEXT);
eggSelect();  
switch(eggProgram)
{
  case PREVIOUS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PREVIOUS_MENU_TEXT);
      if(buttonPushed == true)
              {
         resetButtonOK(); 
         leaveMenu();
              }
      break;

  case EGG_62:  CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(EGG_MENU_EGG62_TEXT);
     if(buttonPushed == true)
       {
     resetButtonOK();
    CLEAR_LCD_LINE_1();
          lcd.setCursor(0,LINE_1);
          lcd.print(EGG_MENU_EGG62_TEXT);     
         cookingSetting(EGG,EGG_62);
         //preheat();
         startCooking();
         while(endCooking == false)
         {
         ;
           if(buttonPushed == true)
           {
       CLEAR_LCD_LINE_2();
       lcd.setCursor(0,LINE_2);
             lcd.print(ABORT_TEXT);  
       wait(1000);
       resetButtonOK();
       leaveMenu();
       break;
       
           }
           monitorCooking();
           isCookingDone();
      ;
         }
     if(endCooking == true)
     {
       CLEAR_LCD_LINE_2();
             lcd.print(COOKING_SUCCESS_TEXT);
             wait(3000);
          leaveMenu();
         }
  }
  
  break;     
} 
}
enterMenu();

}

void liquidMenu() {

while(insideMenu == true)
{
CLEAR_LCD_LINE_1();
lcd.setCursor(0,LINE_1);
lcd.print(LIQUID_MAIN_MENU_TEXT);
liquidSelect(); 
switch(liquidProgram)
{
  case PREVIOUS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PREVIOUS_MENU_TEXT);
    if(buttonPushed == true)
              {
         resetButtonOK(); 
     leaveMenu();
              }
      break;

  case GREEN_TEA: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(LIQUID_MENU_GREEN_TEA_TEXT);
     if(buttonPushed == true)
       {
     resetButtonOK();
    CLEAR_LCD_LINE_1();
          lcd.setCursor(0,LINE_1);
          lcd.print(LIQUID_MENU_GREEN_TEA_TEXT);      
         cookingSetting(LIQUID,GREEN_TEA);
         //preheat();
         startCooking();
         while(endCooking == false)
         {
         ;
           if(buttonPushed == true)
           {
       CLEAR_LCD_LINE_2();
       lcd.setCursor(0,LINE_2);
             lcd.print(ABORT_TEXT);  
       wait(1000);
       resetButtonOK();
       leaveMenu();
       break;
       
           }
           monitorCooking();
           isCookingDone();
      ;
         }
     if(endCooking == true)
     {
       CLEAR_LCD_LINE_2();
             lcd.print(COOKING_SUCCESS_TEXT);
             wait(3000);
          leaveMenu();
         }
  }
  
  break;

}
}
enterMenu();

}

void fruitMenu() {

while(insideMenu == true)
{
CLEAR_LCD_LINE_1();
lcd.setCursor(0,LINE_1);
lcd.print(FRUITS_MAIN_MENU_TEXT);
fruitSelect();  
switch(fruitProgram)
{
  case PREVIOUS: CLEAR_LCD_LINE_2();lcd.setCursor(0,LINE_2);lcd.print(PREVIOUS_MENU_TEXT);
          if(buttonPushed == true)
              {
         resetButtonOK(); 
      leaveMenu();
              }
      break;

  case CRUNCHY_FRUITS: lcd.setCursor(0,LINE_2);lcd.print(FRUITS_MENU_CRUNCHY_TEXT);
     if(buttonPushed == true)
       {
     resetButtonOK();
    CLEAR_LCD_LINE_1();
          lcd.setCursor(0,LINE_1);
          lcd.print(FRUITS_MENU_CRUNCHY_TEXT);      
         cookingSetting(FRUITS,CRUNCHY_FRUITS);
         //preheat();
         startCooking();
         while(endCooking == false)
         {
         ;
           if(buttonPushed == true)
           {
       CLEAR_LCD_LINE_2();
       lcd.setCursor(0,LINE_2);
             lcd.print(ABORT_TEXT);  
       wait(1000);
       resetButtonOK();
       leaveMenu();
       break;
       
           }
           monitorCooking();
           isCookingDone();
      ;
         }
     if(endCooking == true)
     {
       CLEAR_LCD_LINE_2();
             lcd.print(COOKING_SUCCESS_TEXT);
             wait(3000);
          leaveMenu();
         }
  }
  
  break;
}
}
enterMenu();

}

void riceMenu() {

}

void pastaMenu() {

}

void startCooking() {

cookTimer = millis();
onCooking = true;
endCooking = false;

}

void sealBag() {

 //Preheating
 digitalWrite(SEALER_PIN,HIGH);
 wait(5000);
 //Preheating over
 digitalWrite(SEALER_PIN,LOW);

}

unsigned int getWeight() {

}

void cookingSetting(unsigned char material,unsigned char recipe) {

switch(material)
{
     case MEAT: cookingTemperature = meatArray[recipe];
              cookingTime = meatArray[recipe+1];
    break;

     case FISH: cookingTemperature = fishArray[recipe];
              cookingTime = fishArray[recipe+1];
    break;

     case EGG:  cookingTemperature = eggArray[recipe];
              cookingTime = eggArray[recipe+1];
    break;
    
     case VEGETABLES: cookingTemperature = vegetableArray[recipe];
                    cookingTime = vegetableArray[recipe+1];
    break;
     
   case RICE: cookingTemperature = riceArray[recipe];
              cookingTime = riceArray[recipe+1];
    break;
    
     case PASTA: cookingTemperature = pastaArray[recipe];
              cookingTime = pastaArray[recipe+1];
    break;
    
     case LIQUID: cookingTemperature = meatArray[recipe];
                cookingTime = meatArray[recipe+1]; 
    break;
     
     case FRUITS: cookingTemperature = meatArray[recipe];
                cookingTime = meatArray[recipe+1];
    break;
    
}

}

void preheat() {

CLEAR_LCD_LINE_2();
lcd.setCursor(0,LINE_2);  
lcd.print(STARTING_PREHEAT_TEXT);
digitalWrite(HEAT_PIN,HIGH);
tempTreshold = (cookingTemperature - 1)*100;
while(onCooking == true && (tempTreshold - realTimeTempInt) > 0)
{
  if(buttonPushed == true)
  {
  wasPreheated = false; 
    abortCooking();
    resetButtonOK();
  }
  wait(200); 
  realTimeTempInt = getTemperature()*100; 
}
wasPreheated = true;
ledON();
CLEAR_LCD_LINE_2();
lcd.setCursor(0,LINE_2);  
lcd.print(ENDING_PREHEAT_TEXT);
wait(1000);
ledOFF();

}

bool isCookingDone() {

   if(millis() - cookTimer > cookingTime)
   {
   endCooking = true;    
 }
 endCooking = false;
 return endCooking;
 

}

void monitorCooking() {

if(wasPreheated == false)
{
  leaveMenu();
  return;
}   
CLEAR_LCD_LINE_2();
ellapsedTime = ((millis() - cookTimer)/1000.0);
hourTimer = ellapsedTime/3600;
minTimer = (ellapsedTime % 3600)/60;
secTimer = (ellapsedTime % 3600) - 60*minTimer;
realTimeTempInt = getTemperature()*100;
deltaTemperature = realTimeTempInt - cookingTemperature*100;

sprintf(strTemperature, "%d", realTimeTempInt);
sprintf(timeTracker,"%02lu:%02lu:%02lu  ", hourTimer,minTimer,secTimer);
timeTracker[10] = strTemperature[0];
timeTracker[11] = strTemperature[1];
timeTracker[12] = '.';
timeTracker[13] = strTemperature[2];
timeTracker[14] = strTemperature[3];
lcd.setCursor(0,LINE_2);
lcd.print(timeTracker);
lcd.setCursor(15,LINE_2);
lcd.write((uint8_t)0); //Ecrire le symbole degre

wait(200);

if( (deltaTemperature < -TEMPERATURE_EPSILON) && (deltaTemperature < 0))
{
  if(digitalRead(HEAT_PIN) == LOW)
  {
    digitalWrite(HEAT_PIN, HIGH);
  }
  return;
}
if( (deltaTemperature > -TEMPERATURE_EPSILON) && (deltaTemperature < 0))
{
  if(digitalRead(HEAT_PIN) == HIGH)
  {
    digitalWrite(HEAT_PIN, LOW);
  }
  return;
}
if( (deltaTemperature > TEMPERATURE_EPSILON) && (deltaTemperature > 0))
{
  if(digitalRead(HEAT_PIN) == HIGH)
  {
    digitalWrite(HEAT_PIN, LOW);
  }
  return;
}
if( (deltaTemperature < TEMPERATURE_EPSILON) && (deltaTemperature > 0))
{
  if(digitalRead(HEAT_PIN) == HIGH)
  {
    digitalWrite(HEAT_PIN, LOW);
  }
  return;
}

}

float getTemperature() {

 //Specificite du capteur de temperature Vout = 
 //return ((analogRead(TEMPERATURE_PIN))*500.0)/1023;

}

void initAllPins() {

pinMode(TEMPERATURE_PIN,INPUT);
pinMode(SCROLLER_PIN,INPUT);
pinMode(OK_PIN, INPUT_PULLUP);
pinMode(HEAT_PIN,INPUT);
pinMode(WITNESS_LED_PIN,OUTPUT);
pinMode(SEALER_PIN,OUTPUT);
pinMode(ENGINE_PIN,OUTPUT);
pinMode(SCREEN_LUMINOSITY_PIN,OUTPUT);
pinMode(BACKLIGHT_PIN,OUTPUT);
pinMode(LCD_RS,OUTPUT);
pinMode(LCD_E,OUTPUT);
pinMode(LCD_D4,OUTPUT);
pinMode(LCD_D5,OUTPUT);
pinMode(LCD_D6,OUTPUT);
pinMode(LCD_D7,OUTPUT);

}

void wait(unsigned int ms) {

while(ticks - reference < ms)
{
  ticks = millis();
}
reference = ticks;  

}

void welcome(const char *username) {

 centerStringLCD(GREETING_TEXT,LINE_1);
 centerStringLCD(username,LINE_2);

}

void setup() {

// put your setup code here, to run once:
attachInterrupt(digitalPinToInterrupt(OK_PIN), pushButtonOK, FALLING);
initAllPins();
initCookingArrays();
Serial.begin(9600);
defineScreenLuminosity(SCREEN_LUMINOSITY_PIN,LUMINOSITY);
lcd.createChar(0,degreeCharacter);
lcd.begin(16,2);
welcome(USERNAME);
wait(4000);
CLEAR_LCD_SCREEN();

}

void loop() {

// put your main code here, to run repeatedly:
 //menuPrincipal();
menuPrincipal();

} </code>

Ici il faut mettre l'avancement du projet au jours le jour. Cela permet au porteur du projet de partager son expérience (choix, difficultés…), mais aussi au Fablab de savoir si un projet continue de se construire.