//programme principal
  
  #define Lampe 3
  #define venti 4
  #define photocellPin 0
  
  #include <Wire.h>
  
  #define SLAVE_ADDRESS 0x12
  int dataReceived = 0;
  
  int temp;//en dégres > Reception de la Raspberry
  int lum; // en pourcent 
  int vent; // en pourcent 
  
  
  int temp_m;//envoie vers  la raspb
  int lum_m; 
  int hum_m;
  
  int photocellReading;
  int envoie;
  /* brochage  de la  carte  arduino 
   */
  const byte resitanceChauf= A0;
  const  byte  ventilateur=A1;
  
  
  /** Broche "DATA" du capteur */
  const byte BROCHE_CAPTEUR = 5;
  
  /* Code d'erreur de la fonction readDHT11() et readDHT22() */
  const byte DHT_SUCCESS = 0;        // Pas d'erreur
  const byte DHT_TIMEOUT_ERROR = 1;  // Temps d'attente dépassé
  const byte DHT_CHECKSUM_ERROR = 2; // Données reçues erronées
  
  void setup() {
    // put your setup code here, to run once:
    Serial.begin(9600);
    Wire.begin(SLAVE_ADDRESS);
    Wire.onReceive(receiveData);
    Wire.onRequest(sendData);
    pinMode(Lampe,OUTPUT);
    pinMode (venti,OUTPUT);
    
    /* Place la broche du capteur en entrée avec pull-up */
    pinMode(BROCHE_CAPTEUR, INPUT_PULLUP);
  
  }
  
  
  
  void loop() {
    
    float temperature, humidity;
  
    // création des trames pour la com rasp 
    
    //lecture des données 
     temp = dataReceived/1000000;
     vent = (dataReceived /1000)-temp;
     lum= dataReceived -vent -temp;
    cmd_vent(vent);
    cmd_lampe(lum);
    if ( temp_m >= temp ) 
    {
      cmd_temp(false);
    }
    else
    {
      
    cmd_temp(true);
    }
    
     
   
    /* Lecture de la température et de l'humidité, avec gestion des erreurs */
    // N.B. Remplacer readDHT11 par readDHT22 en fonction du capteur utilisé !
    switch (readDHT11(BROCHE_CAPTEUR, &temperature, &humidity)) {
    case DHT_SUCCESS: 
       
      /* Affichage de la température et du taux d'humidité */
      /*Serial.print(F("Humidite (%): "));
      Serial.println(humidity, 2);
      Serial.print(F("Temperature (^C): "));
      Serial.println(temperature, 2);*/
      temp_m=temperature;
      hum_m=humidity;
      break;
   
    case DHT_TIMEOUT_ERROR: 
      Serial.println(F("Pas de reponse !")); 
      break;
   
    case DHT_CHECKSUM_ERROR: 
      Serial.println(F("Pb de communication !")); 
      break;
    }
    lum=cpt_lum();
    
    // envoie  des données ic2 
    envoie = temp_m * 1000000 + hum_m *1000 +lum_m; 
    /* Pas plus d'une mesure par seconde */
  }
  int cpt_lum()
  {
    photocellReading = analogRead(photocellPin);
  
    //faire la  conversion  valeur  vers lux 
    
    return photocellReading;
  
  }
  void cmd_lampe(float lum)
  {
  
    // conversion vent a faire une fois le dome concu 
    lum = (lum/100)*255 ;// commande en pourcentage pour l'instant  
    analogWrite(Lampe,lum);
    
  }
  void cmd_vent(float vent)
  {
  
    // conversion vent a faire une fois le dome concu 
    vent = (vent/100)*255 ;// commande en pourcentage pour l'instant  
    analogWrite(ventilateur,vent);
    
  }
  void cmd_temp(bool actif)
  {
    if ( actif)
    {
    analogWrite(resitanceChauf,200);
    }
    else
    {
     analogWrite(resitanceChauf,0); 
      }
    }
  // communication  i2c entre raspeberrry  et  arduino 
  void receiveData(int byteCount){
      while(Wire.available()) {
          dataReceived = Wire.read();
      }
  }
  
  void sendData(){
      Wire.write(envoie);
  }
    
   /*
   * Lit la température et le taux d'humidité mesuré par un capteur DHT11.
   *
   * @param pin Broche sur laquelle est câblée le capteur.
   * @param temperature Pointeur vers la variable stockant la température.
   * @param humidity Pointeur vers la variable stockant le taux d'humidité.
   * @return DHT_SUCCESS si aucune erreur, DHT_TIMEOUT_ERROR en cas de timeout, ou DHT_CHECKSUM_ERROR en cas d'erreur de checksum.
   */
  byte readDHT11(byte pin, float* temperature, float* humidity)
  {
    
    /* Lit le capteur */
    byte data[5];
    byte ret = readDHTxx(pin, data, 18, 1000);
    
    /* Détecte et retourne les erreurs de communication */
    if (ret != DHT_SUCCESS) 
      return ret;
      
    /* Calcul la vraie valeur de la température et de l'humidité */
    *humidity = data[0];
    *temperature = data[2];
  
    /* Ok */
    return DHT_SUCCESS;
  }
  
  /**
   * Fonction bas niveau permettant de lire la température et le taux d'humidité (en valeurs brutes) mesuré par un capteur DHTxx.
   */
  byte readDHTxx(byte pin, byte* data, unsigned long start_time, unsigned long timeout) 
  {
    data[0] = data[1] = data[2] = data[3] = data[4] = 0;
    // start_time est en millisecondes
    // timeout est en microsecondes
   
    /* Conversion du numéro de broche Arduino en ports / masque binaire "bas niveau" */
    uint8_t bit = digitalPinToBitMask(pin);
    uint8_t port = digitalPinToPort(pin);
    volatile uint8_t *ddr = portModeRegister(port);   // Registre MODE (INPUT / OUTPUT)
    volatile uint8_t *out = portOutputRegister(port); // Registre OUT (écriture)
    volatile uint8_t *in = portInputRegister(port);   // Registre IN (lecture)
    
    /* Conversion du temps de timeout en nombre de cycles processeur */
    unsigned long max_cycles = microsecondsToClockCycles(timeout);
   
    /* Evite les problèmes de pull-up */
    *out |= bit;  // PULLUP
    *ddr &= ~bit; // INPUT
    delay(100);   // Laisse le temps à la résistance de pullup de mettre la ligne de données à HIGH
   
    /* Réveil du capteur */
    *ddr |= bit;  // OUTPUT
    *out &= ~bit; // LOW
    delay(start_time); // Temps d'attente à LOW causant le réveil du capteur
    // N.B. Il est impossible d'utilise delayMicroseconds() ici car un délai
    // de plus de 16 millisecondes ne donne pas un timing assez précis.
    
    /* Portion de code critique - pas d'interruptions possibles */
    noInterrupts();
    
    /* Passage en écoute */
    *out |= bit;  // PULLUP
    delayMicroseconds(40);
    *ddr &= ~bit; // INPUT
   
    /* Attente de la réponse du capteur */
    timeout = 0;
    while(!(*in & bit)) { /* Attente d'un état LOW */
      if (++timeout == max_cycles) {
          interrupts();
          return DHT_TIMEOUT_ERROR;
        }
    }
      
    timeout = 0;
    while(*in & bit) { /* Attente d'un état HIGH */
      if (++timeout == max_cycles) {
          interrupts();
          return DHT_TIMEOUT_ERROR;
        }
    }
  
    /* Lecture des données du capteur (40 bits) */
    for (byte i = 0; i < 40; ++i) {
   
      /* Attente d'un état LOW */
      unsigned long cycles_low = 0;
      while(!(*in & bit)) {
        if (++cycles_low == max_cycles) {
          interrupts();
          return DHT_TIMEOUT_ERROR;
        }
      }
  
      /* Attente d'un état HIGH */
      unsigned long cycles_high = 0;
      while(*in & bit) {
        if (++cycles_high == max_cycles) {
          interrupts();
          return DHT_TIMEOUT_ERROR;
        }
      }
      
      /* Si le temps haut est supérieur au temps bas c'est un "1", sinon c'est un "0" */
      data[i / 8] <<= 1;
      if (cycles_high > cycles_low) {
        data[i / 8] |= 1;
      }
    }
    
    /* Fin de la portion de code critique */
    interrupts();
   
    /*
     * Format des données :
     * [1, 0] = humidité en %
     * [3, 2] = température en degrés Celsius
     * [4] = checksum (humidité + température)
     */
     
    /* Vérifie la checksum */
    byte checksum = (data[0] + data [1] + data[2] + data[3]) & 0xff;
    if (data[4] != checksum)
      return DHT_CHECKSUM_ERROR; /* Erreur de checksum */
    else
      return DHT_SUCCESS; /* Pas d'erreur */
  
  }