//programme principal #define Lampe 3 #define venti 4 #define photocellPin 0 #include #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 */ }