- Lire la température de 3 sondes thermiques DS18B20 à partir d'un arduino
- Fabrication d'une multiprise de 3 prises couplée à 3 relays

- 3 plaques chauffantes

- 3 casseroles

- 3 litres d'huiles de fritures sans odeur

- des pinces à linges

Branchez les plaques électriques sur votre multiprise contrôlée par des relays. Ajouter les sondes thermiques waterproof dans les casseroles remplis d'un litre d'huile. Avec des pinces à linge ou tout autre supports, faites en sorte qu'aucune partie de la sonde ne touche le métal.

Vous avez besoin de savoir combien de seconde votre plaque doit rester allumer pour faire augmenter la température de votre litre d'huile de 20°C à 55 C°C par exemple. La thermodynamique nous dit que la quantité de chaleur (Q) (d’énergie) qu'il faut apporter est proportionnel à 3 choses :
-la masse d'huile que l'on met (m). On multiplie la masse volimique (m/L) qui est de 0.92 par le volume (L) ici 1 litre ce qui nous donne 0.92 Kg
- la capacité calorifique massique © de l'huile (sorte d'inertie thermique), environ 2000 J·kg-1·K-1 (soit deux fois moins que l'eau, et donc chauffe deux fois plus vite)
- la différence de température que l'on veut faire subir à notre huile (dT),ici 55-20=35°C

Soit Q=m*c*dT
Q=0.92*2000*35
Q=64 400 J
Il faut apporter 64400 joules à votre litre d'huile pour que sa température augmente de 35°C.

Voyons maintenant combien d’énergie votre plaque chauffante peut délivrer en une seconde. Une grossière estimation peut être faite en regardant la consommation de votre plaque,à savoir sa puissance théorique (W). Si elle affiche 1500W, cela signifie qu'elle délivre 1500 J par seconde. Pour savoir combien de seconde il faut que notre plaque chauffante soit allumée pour augmenter la température de notre litre d'huile de 35°C, il faut simplement diviser la quantité de chaleur nécessaire (64400) par la puissance.
Soit durée = Q/W
durée=64400/1500
durée=42.9 secondes.

Mais cette durée est complétement fausse.

Afin de calculer empiriquement la puissance réel de la plaque chauffante, nous allons mesurer la température initiale, allumer la plaque pendant une durée déterminée et récupérer la valeur de la température maximale (quand elle commence à baisser). Supposons que nous avons la température initiale à 20°C, la température finale est de 55°C et que nous avons laisser la plaque allumée pendant deux minutes (120 secondes). Nous avons donc la puissance (W) égale à la quantité de chaleur (Q) divisé par le temps en seconde. Soit :
W=Q/s
W=(m*c*dT)/s
W=(0.92*2000*35)/120
W=536.5 J/s
Voici la puissance réel de votre plaque ! Si vous avez plusieurs plaques ou des casseroles différentes, il faut faire cette mesure pour chacune.

Voici le code

/*
But : Determiner la puissance réèl d'une plaque plaque chauffante
Auteur : Emmanuel T., du PMClab
  */
#include <OneWire.h> 
#include <elapsedMillis.h>
 
int broche_OneWire = 11;
OneWire  capteur(broche_OneWire);;
//---- code des instructions du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;
 
float temperature_den = 95;
float temperature_hybridation = 55;
float temperature_taq = 72;
 
float T_sonde_den=0;
float T_sonde_taq=0;
float T_sonde_hybridation=0;
 
int latence_hyb=50;
int latence_den=100;
int latence_taq=150;
 
int relay_den = 4;/////////////////////////////////////////////////////!!!!!! pas les bons relay
int relay_hyb = 3;
int relay_taq = 2;
 
elapsedMillis temps;
int seconde=0;
 
int row = 0;
 
void setup(void) {
   Serial.begin(9600);
    pinMode(relay_den, OUTPUT);
    pinMode(relay_taq, OUTPUT);
    pinMode(relay_hyb, OUTPUT);
    pinMode(T_sonde_hybridation,INPUT);
    pinMode(T_sonde_taq,INPUT);
    pinMode(T_sonde_den,INPUT);
    Serial.println("CLEARDATA");
    Serial.println("LABEL,temperature_hyb,temperature_taq,temperature_den,seconde");
    digitalWrite(relay_hyb, HIGH); 
    digitalWrite(relay_taq, HIGH);
    digitalWrite(relay_den, HIGH);    
}
 
 
void loop(void) {
 
   float T_sonde_den=0;
  byte Adresse1[8]={0x28, 0x89, 0x0F, 0xCD, 0x05, 0x00, 0x00, 0x9C}; //droite
  float T_sonde_taq=0;
  byte Adresse2[8]= {0x28,0xEB,0x51,0x47,0x05,0x00,0x00,0xC4};
  float T_sonde_hybridation=0;
  byte Adresse3[8]= {0x28, 0x37, 0x26, 0xCD, 0x05, 0x00, 0x00, 0x83}; 
  float T_ambiante=0; 
  byte Adresse4[8]={0x28, 0x9F, 0x9E, 0x47, 0x05, 0x00, 0x00, 0xCD};
  T_sonde_hybridation=getTemp(Adresse3); //milieu
  T_sonde_den=getTemp(Adresse1); //droite
  T_sonde_taq=getTemp(Adresse2); //gauche
  T_ambiante=getTemp(Adresse4);
   row++; // rajoute une ligne dans excel
 
 
 
    //Calcul du temps necessaire d'allumage pour arriver au plus proche de la température désirée
 
 
  if (seconde<latence_hyb)
  {
    digitalWrite(relay_hyb,LOW);
 
  }
 
  else if (seconde>latence_hyb)
  {
    digitalWrite(relay_hyb,HIGH);
  }
 
 
 
  if (seconde<latence_taq)
  {
    digitalWrite(relay_taq,LOW);
 
  }
 
  else if (seconde>latence_taq)
  {
    digitalWrite(relay_taq,HIGH);
  }
 
 
  if (seconde<latence_den)
  {
    digitalWrite(relay_den,LOW);
 
  }
 
  else if (seconde>latence_den)
  {
    digitalWrite(relay_den,HIGH);
  }
 
 
 
 if(temps>1000)
{
  seconde++;
 
  Serial.print("DATA,TIME,");Serial.print(T_sonde_den);Serial.print(",");Serial.print(T_sonde_hybridation);Serial.print(",");Serial.print(T_sonde_taq);Serial.print(","); Serial.println(seconde);
 
   temps=0;
 
}
}
float getTemp(byte adressecapteur[8]) { //fonction qui renvoie résultat float et ne reçoit rien
  //-------- variable locale de la fonction ----------
  byte data[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
  int tempet=0; // variable pour resultat brute  de la mesure
  float tempetf=0.0; // variable pour resultat à virgule de la mesure
  // XXXXXXXXXXXXXXXXXXXXXX Lancement d'une mesure et lecture du résultat XXXXXXXXXXXXXXXXXXXXXXX
  // Serial.println("**** Acquisition d'une mesure de la temperature **** ");
  // avant chaque nouvelle instruction, il faut :
  //    * initialiser le bus 1-wire
  //    * sélectionner le capteur détecté
  //    * envoyer l'instruction
  //--------- lancer une mesure --------
  capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
  capteur.select(adressecapteur); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
  capteur.write(lancerMesure,1); // lance la mesure et alimente le capteur par la broche de donnée
  //-------- pause d'une seconde -----
 // delay(500);     // au moins 750 ms
  // il faudrait mettre une instruction capteur.depower ici, mais le reset va le faire
  //---------- passer en mode LECTURE -------------
  capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
  capteur.select(adressecapteur); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
  capteur.write(modeLecture,1); // passe en mode lecture de la RAM du capteur
  // ----------- lire les 9 octets de la RAM (appelé Scratchpad) ----
  for ( int i = 0; i < 9; i++) {           // 9 octets de RAM stockés dans 9 octets
    data[i] = capteur.read();             // lecture de l'octet de rang i stocké dans tableau data
  }
  //----- caclul de la température mesurée (enfin!) ---------
  /*data[1]=data[1] & B10000111; // met à 0 les bits de signes inutiles  <- Le bug était caché la
  tempet=data[1]; // bits de poids fort
  tempet=tempet<<8;
  tempet=tempet+data[0]; // bits de poids faible
  */
  tempet=(data[1]<<8)|data[0]; // a l'arrache style !
  // --- en mode 12 bits, la résolution est de 0.0625°C - cf datasheet DS18B20
  tempetf=float(tempet)*6.25;
  tempetf=tempetf/100.0;
  return (tempetf);
}

<= Page précédente PCR : Sommaire