/***
 * Shutter automation
 *
 * Dec-2011 First release
 *
 */
 
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
 
 // Delay for small shutter (15s)
unsigned int smallShutter=15000;
// Delay for medium shutter (20s)
unsigned int mediumShutter=20000;
// Delay for big shutter (25s)
unsigned int bigShutter=25000;

// Setup pin number for relays
int pinShutter1Up =  22;
int pinShutter1Down =  23;
int pinShutter2Up =  24;
int pinShutter2Down =  25;
int pinShutter3Up =  26;
int pinShutter3Down =  27;
int pinShutter4Up =  28;
int pinShutter4Down =  29;
int pinShutter5Up =  30;
int pinShutter5Down =  31;
int pinShutter6Up =  32;
int pinShutter6Down =  33;
int pinShutter7Up =  34;
int pinShutter7Down =  35;
int pinShutter8Up =  36;
int pinShutter8Down =  37;

// Setup pin number for wall switch
int pinSwitch1Up=38;
int pinSwitch1Down=39;
int pinSwitch2Up=40;
int pinSwitch2Down=41;
int pinSwitch3Up=42;
int pinSwitch3Down=43;
int pinSwitch4Up=44;
int pinSwitch4Down=45;
int pinSwitch5Up=46;
int pinSwitch5Down=47;
int pinSwitch6Up=48;
int pinSwitch6Down=49;
int pinSwitch7Up=51;
int pinSwitch7Down=50;
int pinSwitch8Up=52;
int pinSwitch8Down=53;

// Setup pin number for centralized switch
int pinSwitchCentralizationUp=A14;
int pinSwitchCentralizationDown=A15;

// set the LCD address to 0x27 for a 16 chars and 4 lines display
LiquidCrystal_I2C lcd(0x27, 16, 4);

// Switch status
boolean sw1Up;
boolean sw1Down;
boolean sw1UpChange;
boolean sw1DownChange;
boolean sw2Up;
boolean sw2Down;
boolean sw2UpChange;
boolean sw2DownChange;
boolean sw3Up;
boolean sw3Down;
boolean sw3UpChange;
boolean sw3DownChange;
boolean sw4Up;
boolean sw4Down;
boolean sw4UpChange;
boolean sw4DownChange;
boolean sw5Up;
boolean sw5Down;
boolean sw5UpChange;
boolean sw5DownChange;
boolean sw6Up;
boolean sw6Down;
boolean sw6UpChange;
boolean sw6DownChange;
boolean sw7Up;
boolean sw7Down;
boolean sw7UpChange;
boolean sw7DownChange;
boolean sw8Up;
boolean sw8Down;
boolean sw8UpChange;
boolean sw8DownChange;
boolean swCentralizationUp;
boolean swCentralizationDown;
boolean swCentralizationUpChange;
boolean swCentralizationDownChange;

// Setup
void setup()   
{                
  // Set ports
  pinMode(pinSwitchCentralizationUp, INPUT);
  pinMode(pinSwitchCentralizationDown, INPUT);
  pinMode(pinShutter1Up, OUTPUT);
  pinMode(pinShutter1Down, OUTPUT);
  pinMode(pinSwitch1Up, INPUT);
  pinMode(pinSwitch1Down, INPUT);
  pinMode(pinShutter2Up, OUTPUT);
  pinMode(pinShutter2Down, OUTPUT);
  pinMode(pinSwitch2Up, INPUT);
  pinMode(pinSwitch2Down, INPUT);
  pinMode(pinShutter3Up, OUTPUT);
  pinMode(pinShutter3Down, OUTPUT);
  pinMode(pinSwitch3Up, INPUT);
  pinMode(pinSwitch3Down, INPUT);
  pinMode(pinShutter4Up, OUTPUT);
  pinMode(pinShutter4Down, OUTPUT);
  pinMode(pinSwitch4Up, INPUT);
  pinMode(pinSwitch4Down, INPUT);
  pinMode(pinShutter5Up, OUTPUT);
  pinMode(pinShutter5Down, OUTPUT);
  pinMode(pinSwitch5Up, INPUT);
  pinMode(pinSwitch5Down, INPUT);
  pinMode(pinShutter6Up, OUTPUT);
  pinMode(pinShutter6Down, OUTPUT);
  pinMode(pinSwitch6Up, INPUT);
  pinMode(pinSwitch6Down, INPUT);
  pinMode(pinShutter7Up, OUTPUT);
  pinMode(pinShutter7Down, OUTPUT);
  pinMode(pinSwitch7Up, INPUT);
  pinMode(pinSwitch7Down, INPUT);
  pinMode(pinShutter8Up, OUTPUT);
  pinMode(pinShutter8Down, OUTPUT);
  pinMode(pinSwitch8Up, INPUT);
  pinMode(pinSwitch8Down, INPUT);

  // Set all output to off
  digitalWrite(pinShutter1Up, LOW);
  digitalWrite(pinShutter1Down, LOW);
  digitalWrite(pinShutter2Up, LOW);
  digitalWrite(pinShutter2Down, LOW);
  digitalWrite(pinShutter3Up, LOW);
  digitalWrite(pinShutter3Down, LOW);
  digitalWrite(pinShutter4Up, LOW);
  digitalWrite(pinShutter4Down, LOW);
  digitalWrite(pinShutter5Up, LOW);
  digitalWrite(pinShutter5Down, LOW);
  digitalWrite(pinShutter6Up, LOW);
  digitalWrite(pinShutter6Down, LOW);
  digitalWrite(pinShutter7Up, LOW);
  digitalWrite(pinShutter7Down, LOW);
  digitalWrite(pinShutter8Up, LOW);
  digitalWrite(pinShutter8Down, LOW);
  // Init LCD
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.print("Volet v0.2 111229");
  // Default change status
  initChange();
  setUpDown(false);
}

void setUpDown(boolean b)
{
  sw1Up=b;
  sw1Down=b;
  sw2Up=b;
  sw2Down=b;
  sw3Up=b;
  sw3Down=b;
  sw4Up=b;
  sw4Down=b;
  sw5Up=b;
  sw5Down=b;
  sw6Up=b;
  sw6Down=b;
  sw7Up=b;
  sw7Down=b;
  sw8Up=b;
  sw8Down=b;
  swCentralizationUp=b;
  swCentralizationDown=b;
}

void initChange()
{
  sw1UpChange=digitalRead(pinSwitch1Up);
  sw1DownChange=digitalRead(pinSwitch1Down);
  sw2UpChange=digitalRead(pinSwitch2Up);
  sw2DownChange=digitalRead(pinSwitch2Down);
  sw3UpChange=digitalRead(pinSwitch3Up);
  sw3DownChange=digitalRead(pinSwitch3Down);
  sw4UpChange=digitalRead(pinSwitch4Up);
  sw4DownChange=digitalRead(pinSwitch4Down);
  sw5UpChange=digitalRead(pinSwitch5Up);
  sw5DownChange=digitalRead(pinSwitch5Down);
  sw6UpChange=digitalRead(pinSwitch6Up);
  sw6DownChange=digitalRead(pinSwitch6Down);
  sw7UpChange=digitalRead(pinSwitch7Up);
  sw7DownChange=digitalRead(pinSwitch7Down);
  sw8UpChange=digitalRead(pinSwitch8Up);
  sw8DownChange=digitalRead(pinSwitch8Down);
  swCentralizationUpChange=digitalRead(pinSwitchCentralizationUp);
  swCentralizationDownChange=digitalRead(pinSwitchCentralizationDown);
}

// Task to read the wall switch
// Each time the switch status change we record it
void readSwitch()
{
  // Switch 1
  if (sw1UpChange!=digitalRead(pinSwitch1Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Salon Up change");
    sw1UpChange=!sw1UpChange;
    sw1Up=digitalRead(pinSwitch1Up);
  }
  if (sw1DownChange!=digitalRead(pinSwitch1Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Salon Down change");
    sw1DownChange=!sw1DownChange;
    sw1Down=digitalRead(pinSwitch1Down);
  }
  // Switch 2
  if (sw2UpChange!=digitalRead(pinSwitch2Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Salle de bain Up change");
    sw2UpChange=!sw2UpChange;
    sw2Up=digitalRead(pinSwitch2Up);
  }
  if (sw2DownChange!=digitalRead(pinSwitch2Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Salle de bain Down change");
    sw2DownChange=!sw2DownChange;
    sw2Down=digitalRead(pinSwitch2Down);
  }
  // Switch 3
  if (sw3UpChange!=digitalRead(pinSwitch3Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Chambre Erine Up change");
    sw3UpChange=!sw3UpChange;
    sw3Up=digitalRead(pinSwitch3Up);
  }
  if (sw3DownChange!=digitalRead(pinSwitch3Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Chambre Erine Down change");
    sw3DownChange=!sw3DownChange;
    sw3Down=digitalRead(pinSwitch3Down);
  }
  // Switch 4
  if (sw4UpChange!=digitalRead(pinSwitch4Up))
  {
    sw4UpChange=!sw4UpChange;
    sw4Up=digitalRead(pinSwitch4Up);
  }
  if (sw4DownChange!=digitalRead(pinSwitch4Down))
  {
    sw4DownChange=!sw4DownChange;
    sw4Down=digitalRead(pinSwitch4Down);
  }
  // Switch 5
  if (sw5UpChange!=digitalRead(pinSwitch5Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Chambre Eva Up change");
    sw5UpChange=!sw5UpChange;
    sw5Up=digitalRead(pinSwitch5Up);
  }
  if (sw5DownChange!=digitalRead(pinSwitch5Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Chambre Eva Up change");
    sw5DownChange=!sw5DownChange;
    sw5Down=digitalRead(pinSwitch5Down);
  }
  // Switch 6
  if (sw6UpChange!=digitalRead(pinSwitch6Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Chambre parents Up change");
    sw6UpChange=!sw6UpChange;
    sw6Up=digitalRead(pinSwitch6Up);
  }
  if (sw6DownChange!=digitalRead(pinSwitch6Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Chambre parents Down change");
    sw6DownChange=!sw6DownChange;
    sw6Down=digitalRead(pinSwitch6Down);
  }
  // Switch 7
  if (sw7UpChange!=digitalRead(pinSwitch7Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Salle a manger Up change");
    sw7UpChange=!sw7UpChange;
    sw7Up=digitalRead(pinSwitch7Up);
  }
  if (sw7DownChange!=digitalRead(pinSwitch7Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Salle a manger Down change");
    sw7DownChange=!sw7DownChange;
    sw7Down=digitalRead(pinSwitch7Down);
  }
  // Switch 8
  if (sw8UpChange!=digitalRead(pinSwitch8Up))
  {
    lcd.setCursor(1, 2);
    lcd.print("Cuisine Up change");
    sw8UpChange=!sw8UpChange;
    sw8Up=digitalRead(pinSwitch8Up);
  }
  if (sw8DownChange!=digitalRead(pinSwitch8Down))
  {
    lcd.setCursor(1, 3);
    lcd.print("Cusine Down change");
    sw8DownChange=!sw8DownChange;
    sw8Down=digitalRead(pinSwitch8Down);
  }
  // Switch Centralization
  if (swCentralizationUpChange!=digitalRead(pinSwitchCentralizationUp))
  {
    lcd.setCursor(1, 2);
    lcd.print("Centralisation Up change");
    swCentralizationUpChange=!swCentralizationUpChange;
    swCentralizationUp=digitalRead(pinSwitchCentralizationUp);
  }
  if (swCentralizationDownChange!=digitalRead(pinSwitchCentralizationDown))
  {
    lcd.setCursor(1, 3);
    lcd.print("Centralisation Down change");
    swCentralizationDownChange=!swCentralizationDownChange;
    swCentralizationDown=digitalRead(pinSwitchCentralizationDown);
  }
}

// Task up for the 1st shutter (Salon)
void shutter1Up()
{
  // Set the shutter to go up
  if (sw1Up && !sw1Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Salon Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter1Down)==HIGH) digitalWrite(pinShutter1Down, LOW);
    // Shutter up
    digitalWrite(pinShutter1Up, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch1Up))
    {
      delay(1);
      time++;
    }
    sw1Up=false;
    if (digitalRead(pinSwitch1Down)) sw1Down=true;
    digitalWrite(pinShutter1Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter1Up, LOW);
  }
}

// Task down for the 1st shutter (Salon)
void shutter1Down()
{
  // Set the shutter to go down
  if (sw1Down && !sw1Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Salon Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter1Down)==HIGH) digitalWrite(pinShutter1Up, LOW);
    // Shutter down
    digitalWrite(pinShutter1Down, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch1Down))
    {
      delay(1);
      time++;
    }
    sw1Down=false;
    if (digitalRead(pinSwitch1Up)) sw1Up=true;
    digitalWrite(pinShutter1Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter1Down, LOW);
  }
}

// Task up for the 2nd shutter (Salle de bain)
void shutter2Up()
{
  // Set the shutter to go up
  if (sw2Up && !sw2Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Salle de bain Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter2Down)==HIGH) digitalWrite(pinShutter2Down, LOW);
    // Shutter up
    digitalWrite(pinShutter2Up, HIGH);
    int time=0;
    while((time<smallShutter) && digitalRead(pinSwitch2Up))
    {
      delay(1);
      time++;
    }
    sw2Up=false;
    if (digitalRead(pinSwitch2Down)) sw2Down=true;
    digitalWrite(pinShutter2Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter2Up, LOW);
  }
}

// Task down for the 2nd shutter (Salle de bain)
void shutter2Down()
{
  // Set the shutter to go down
  if (sw2Down && !sw2Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Salle de bain Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter2Up)==HIGH) digitalWrite(pinShutter2Up, LOW);
    // Shutter down
    digitalWrite(pinShutter2Down, HIGH);
    int time=0;
    while((time<smallShutter) && digitalRead(pinSwitch2Down))
    {
      delay(1);
      time++;
    }
    sw2Down=false;
    if (digitalRead(pinSwitch2Up)) sw2Up=true;
    digitalWrite(pinShutter2Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter2Down, LOW);
  }
}

// Task up for the 3rd shutter (Chambre Erine)
void shutter3Up()
{
  // Set the shutter to go up
  if (sw3Up && !sw3Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Chambre Erine Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter3Down)==HIGH) digitalWrite(pinShutter3Down, LOW);
    // Shutter up
    digitalWrite(pinShutter3Up, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch3Up))
    {
      delay(1);
      time++;
    }
    sw3Up=false;
    if (digitalRead(pinSwitch3Down)) sw3Down=true;
    digitalWrite(pinShutter3Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter3Up, LOW);
  }
}

// Task down for the 3rd shutter (Chambre Erine)
void shutter3Down()
{
  // Set the shutter to go down
  if (sw3Down && !sw3Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Chambre Erine Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter3Up)==HIGH) digitalWrite(pinShutter3Up, LOW);
    // Shutter down
    digitalWrite(pinShutter3Down, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch3Down))
    {
      delay(1);
      time++;
    }
    sw3Down=false;
    if (digitalRead(pinSwitch3Up)) sw3Up=true;
    digitalWrite(pinShutter3Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter3Down, LOW);
  }
}

// Task up for the 4th shutter (Chambre Eva)
void shutter4Up()
{
  // Set the shutter to go up
  if (sw4Up && !sw4Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("NU Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter4Down)==HIGH) digitalWrite(pinShutter4Down, LOW);
    // Shutter up
    digitalWrite(pinShutter4Up, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch4Up))
    {
      delay(1);
      time++;
    }
    sw4Up=false;
    if (digitalRead(pinSwitch4Down)) sw4Down=true;
    digitalWrite(pinShutter4Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter4Up, LOW);
  }
}

// Task down for the 4th shutter (Chambre Eva)
void shutter4Down()
{
  // Set the shutter to go down
  if (sw4Down && !sw4Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("NU Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter4Up)==HIGH) digitalWrite(pinShutter4Up, LOW);
    // Shutter down
    digitalWrite(pinShutter4Down, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch4Down))
    {
      delay(1);
      time++;
    }
    sw4Down=false;
    if (digitalRead(pinSwitch4Up)) sw4Up=true;
    digitalWrite(pinShutter4Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter4Down, LOW);
  }
}

// Task up for the 5th shutter (Chambre parents)
void shutter5Up()
{
  // Set the shutter to go up
  if (sw5Up && !sw5Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Chambre Eva Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter5Down)==HIGH) digitalWrite(pinShutter5Down, LOW);
    // Shutter up
    digitalWrite(pinShutter5Up, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch5Up))
    {
      delay(1);
      time++;
    }
    sw5Up=false;
    if (digitalRead(pinSwitch5Down)) sw5Down=true;
    digitalWrite(pinShutter5Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter5Up, LOW);
  }
}

// Task down for the 5th shutter (Chambre parents)
void shutter5Down()
{
  // Set the shutter to go down
  if (sw5Down && !sw5Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Chambre Eva Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter5Up)==HIGH) digitalWrite(pinShutter5Up, LOW);
    // Shutter down
    digitalWrite(pinShutter5Down, HIGH);
    int time=0;
    while((time<mediumShutter) && digitalRead(pinSwitch5Down))
    {
      delay(1);
      time++;
    }
    sw5Down=false;
    if (digitalRead(pinSwitch5Up)) sw5Up=true;
    digitalWrite(pinShutter5Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter5Down, LOW);
  }
}

// Task up for the 6th shutter (Salle a manger)
void shutter6Up()
{
  // Set the shutter to go up
  if (sw6Up && !sw6Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Chambre parents Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter6Down)==HIGH) digitalWrite(pinShutter6Down, LOW);
    // Shutter up
    digitalWrite(pinShutter6Up, HIGH);
    int time=0;
    while((time<bigShutter) && digitalRead(pinSwitch6Up))
    {
      delay(1);
      time++;
    }
    sw6Up=false;
    if (digitalRead(pinSwitch6Down)) sw6Down=true;
    digitalWrite(pinShutter6Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter6Up, LOW);
  }
}

// Task down for the 6th shutter (Salle a manger)
void shutter6Down()
{
  // Set the shutter to go down
  if (sw6Down && !sw6Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Chambre parents Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter6Up)==HIGH) digitalWrite(pinShutter6Up, LOW);
    // Shutter down
    digitalWrite(pinShutter6Down, HIGH);
    int time=0;
    while((time<bigShutter) && digitalRead(pinSwitch6Down))
    {
      delay(1);
      time++;
    }
    sw6Down=false;
    if (digitalRead(pinSwitch6Up)) sw6Up=true;
    digitalWrite(pinShutter6Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter6Down, LOW);
  }
}

// Task up for the 7th shutter (Cuisine)
void shutter7Up()
{
  // Set the shutter to go up
  if (sw7Up && !sw7Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Salle a manger Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter7Down)==HIGH) digitalWrite(pinShutter7Down, LOW);
    // Shutter up
    digitalWrite(pinShutter7Up, HIGH);
    int time=0;
    while((time<bigShutter) && digitalRead(pinSwitch7Up))
    {
      delay(1);
      time++;
    }
    sw7Up=false;
    if (digitalRead(pinSwitch7Down)) sw7Down=true;
    digitalWrite(pinShutter7Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter7Up, LOW);
  }
}

// Task down for the 7th shutter (Cuisine)
void shutter7Down()
{
  // Set the shutter to go down
  if (sw7Down && !sw7Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Salle a manger Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter7Up)==HIGH) digitalWrite(pinShutter7Up, LOW);
    // Shutter down
    digitalWrite(pinShutter7Down, HIGH);
    int time=0;
    while((time<bigShutter) && digitalRead(pinSwitch7Down))
    {
      delay(1);
      time++;
    }
    sw7Down=false;
    if (digitalRead(pinSwitch7Up)) sw7Up=true;
    digitalWrite(pinShutter7Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter7Down, LOW);
  }
}

// Task up for the 8th shutter (Cellier)
void shutter8Up()
{
  // Set the shutter to go up
  if (sw8Up && !sw8Down)
  {
    lcd.setCursor(1, 4);
    lcd.print("Cuisine Up");
    // Test if shutter is activated to go down
    if (digitalRead(pinShutter8Down)==HIGH) digitalWrite(pinShutter8Down, LOW);
    // Shutter up
    digitalWrite(pinShutter8Up, HIGH);
    int time=0;
    while((time<smallShutter) && digitalRead(pinSwitch8Up))
    {
      delay(1);
      time++;
    }
    sw8Up=false;
    if (digitalRead(pinSwitch8Down)) sw8Down=true;
    digitalWrite(pinShutter8Up, LOW);
  }
  else
  {
    digitalWrite(pinShutter8Up, LOW);
  }
}

// Task down for the 8th shutter (Cellier)
void shutter8Down()
{
  // Set the shutter to go down
  if (sw8Down && !sw8Up)
  {
    lcd.setCursor(1, 4);
    lcd.print("Cuisine Down");
    // Test if shutter is activated to go up
    if (digitalRead(pinShutter8Up)==HIGH) digitalWrite(pinShutter8Up, LOW);
    // Shutter down
    digitalWrite(pinShutter8Down, HIGH);
    int time=0;
    while((time<smallShutter) && digitalRead(pinSwitch8Down))
    {
      delay(1);
      time++;
    }
    sw8Down=false;
    if (digitalRead(pinSwitch8Up)) sw8Up=true;
    digitalWrite(pinShutter8Down, LOW);
  }
  else
  {
    digitalWrite(pinShutter8Down, LOW);
  }
}

// Task up for centralization
void centralizationUp()
{
  // Set the shutter to go up
  if (swCentralizationUp && !swCentralizationDown)
  {
    lcd.setCursor(1, 4);
    lcd.print("Centralization Up");
    // Ensure there is no shutter going down
    writeAllDown(LOW);
    // Shutter up
    writeAllUp(HIGH);
    int time=0;
    while((time<bigShutter) && digitalRead(pinSwitchCentralizationUp))
    {
      delay(1);
      time++;
    }
    writeAllUp(LOW);
    swCentralizationUp=false;
  }
}

// Task down for centralization
void centralizationDown()
{
  // Set the shutter to go down
  if (swCentralizationDown && !swCentralizationUp)
  {
    lcd.setCursor(1, 4);
    lcd.print("Centralization Down");
    // Ensure there is no shutter going up
    writeAllUp(LOW);
    // Shutter down
    writeAllDown(HIGH);
    int time=0;
    while((time<bigShutter) && digitalRead(pinSwitchCentralizationDown))
    {
      delay(1);
      time++;
    }
    writeAllDown(LOW);
    swCentralizationDown=false;
  }
}

void writeAllUp(boolean b)
{
  digitalWrite(pinShutter1Up, b);
  digitalWrite(pinShutter2Up, b);
  digitalWrite(pinShutter3Up, b);
  digitalWrite(pinShutter4Up, b);
  digitalWrite(pinShutter5Up, b);
  digitalWrite(pinShutter6Up, b);
  digitalWrite(pinShutter7Up, b);
  digitalWrite(pinShutter8Up, b);
}

void writeAllDown(boolean b)
{
  digitalWrite(pinShutter1Down, b);
  digitalWrite(pinShutter2Down, b);
  digitalWrite(pinShutter3Down, b);
  digitalWrite(pinShutter4Down, b);
  digitalWrite(pinShutter5Down, b);
  digitalWrite(pinShutter6Down, b);
  digitalWrite(pinShutter7Down, b);
  digitalWrite(pinShutter8Down, b);
}

void loop()                     
{
  readSwitch();
  shutter1Up();
  shutter1Down();
  shutter2Up();
  shutter2Down();
  shutter3Up();
  shutter3Down();
  shutter4Up();
  shutter4Down();
  shutter5Up();
  shutter5Down();
  shutter6Up();
  shutter6Down();
  shutter7Up();
  shutter7Down();
  shutter8Up();
  shutter8Down();
  centralizationUp();
  centralizationDown();
}