Mesure de température

Groupe 1

Objectif

  • Acquérir et enregistrer la température à l’intérieur et à l’extérieur de la nacelle, pendant tout le vol.

Challenge : comparer les performances (précision, sensibilité, …) entre plusieurs moyens de mesure :

  • Moyens « modernes » : capteurs analogiques ou numériques couramment utilisés (thermistance, PT, DHT, D S, …)
  • Moyens « physiques » : utilisation d’une bilame (lame bimétallique)

 

Tâches à réaliser

Analyse fonctionnelle

Recherches sur les conditions en altitude (amplitudes de températures, conditions susceptibles de perturber la mesure, …) :

La pression atmosphérique baisse de 1 hPa chaque fois que l’on s’élève de 8 mètres, et la température baisse d’environ 1 °C chaque fois que l’on s’élève de 150 m.

C’est à l’altitude de la tropopause (limite troposphère/stratosphère), au environs de 12km, que la température sera la plus basse. Selon les sources elle devrait être entre -50 et -60 °C.

 

 

 

 

 

 

 

 

 

 

 

 

Problème : Réussir à capturer la température au cours de l’expérience en fonction de l’attitude et de la durée.

Amplitudes de températures mesurables avec les différents appareils :

  • DS18B20 :  -55 à +125 °C un peu limite
  • – Thermistance :  -50 à 300°Cinsuffisant
  • – PT100 : -200 °C à 850 °Ccorrect
  • – DHT22 : -40 à +80°Cinsuffisant

 

Mise en œuvre de différents capteurs « modernes »

DS18B20

C’est le capteur le plus simple à mettre en œuvre : il est numérique et fonctionne sur un bus à 1 seul fil (one Wire) :

Programme de test pour le capteur DS18B20
#include <OneWire.h>

const byte DS_PIN = 7;

OneWire ds(DS_PIN);

void getTemperature(float *temperature) {
  byte data[9], addr[8];
  ds.reset_search();
  if (!ds.search(addr)) return;
  if (OneWire::crc8(addr, 7) != addr[7]) return;
  if (addr[0] != 0x28) return;

  ds.reset();
  ds.select(addr);

  ds.write(0x44, 1);
  delay(800);

  ds.reset();
  ds.select(addr);
  ds.write(0xBE);

  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
  *temperature = ((data[1] << 8) | data[0]) * 0.0625;
}

void setup() {
  Serial.begin(115200);
}

void loop() {
  float temperature;

  getTemperature(&temperature);

  Serial.print(F("Temperature : "));
  Serial.print(temperature, 1);
  Serial.write(176);
  Serial.write('C');
  Serial.println();
}

Thermistance

PT100

DHT22

 

Réalisation d’un capteur « maison »

Principe de fonctionnement

Sous l’effet de la chaleur, la plupart des matériaux augmentent de volume : on parle de dilatation thermique. Ce phénomène est loin d’être négligeable : plus grand est l’objet et au plus importante est l’augmentation de température, au plus grande sera sa dilatation.

La déformation est d’amplitude trop faible pour pouvoir la mesurer facilement. On envisage donc d’utiliser un capteur de force pour mesurer l’effort dû à la dilatation et de le traduire en température.

En physique, la loi de Hooke modélise le comportement des solides élastiques soumis à des contraintes. Elle stipule que la déformation élastique est une fonction linéaire des contraintes. Sous sa forme la plus simple, elle relie l’allongement (d’un ressort, par exemple) à la force appliquée. Cette loi de comportement a été énoncée par le physicien anglais Roberen 1676.

La loi de Hooke est en fait le terme de premier ordre d’une série de Taylor. C’est donc une approximation qui peut devenir inexacte quand la déformation est trop grande. Au-delà d’un certain seuil la déformation peut aussi devenir permanente, ce qui invalide aussi la loi. En revanche, la loi de Hooke peut être considérée à toutes fins pratiques comme exacte quand les forces et les déformations sont suffisamment petites, aussi est-elle utilisée dans de très nombreux domaines de la physique et de l’ingénierie, tels que la sismologie, la mécanique moléculaire et l’acoustique.

  • loi \(F=f(\epsilon)\)
L’utilisation d’un autre capteur plus « moderne » permettra de comparer les mesures réalisées par la bilame et comparer leurs performances.

 

Fabrication du capteur

Pour évaluer la déformation de la bilame, nous allons utiliser un capteur de force composé d’une cellule à jauge de déformation et d’un pont amplificateur de pont de Wheatstone (HX711).
Programme de test du capteur d'effort
#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

HX711 scale;

void setup() {
  Serial.begin(38400);
  Serial.println("HX711 Demo");

  Serial.println("Initializing the scale");

  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

  Serial.println("Before setting up the scale:");
  Serial.print("read: \t\t");
  Serial.println(scale.read());

  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));

  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));

  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);

  scale.set_scale(2280.f);
  scale.tare();

  Serial.println("After setting up the scale:");

  Serial.print("read: \t\t");
  Serial.println(scale.read());

  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));

  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));

  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);

  Serial.println("Readings:");
}

void loop() {
  Serial.print("one reading:\t");
  Serial.print(scale.get_units(), 1);
  Serial.print("\t| average:\t");
  Serial.println(scale.get_units(10), 1);

  scale.power_down(); // Extinction
  delay(100);
  scale.power_up(); // Allumage
}

Conception d’un montage

Cellule de force + bilame

 

Capteur terminé

Modèle Solidworks :

Après découpage laser des pièces (PMMA transparent 3mm) :

Étalonnage

Procédure d’étalonnage du capteur :

On place les deux capteurs (DS et bilame) à l’intérieur de congélateurs (jusqu’à -25°C) et on attend que les valeurs mesurées n’évoluent plus (régime permanent).

Programme d'étalonnage
#include "HX711.h"
#include <OneWire.h>

// HX711.DOUT	- pin #A1
// HX711.PD_SCK	- pin #A0
// Connecteur numérique relié à DQ
const byte DS_PIN = 7;

HX711 scale(3, 2);

OneWire ds(DS_PIN);
float temperature;
unsigned long t = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  // Temps écoulé [ms] :
  Serial.print(millis(), 1);
  Serial.print("\t");
  
  // Valeur "brute" du capteur :
  Serial.print(scale.read(), 1);
  Serial.print("\t");

  // Température [°C] mesurée par le DS18B20
  getTemperature(&temperature);
  Serial.println(temperature, 1);


  // Extinction du capteur (pour économies d'énergie) :
  scale.power_down();			       
  delay(10000);
  scale.power_up();
}

//
// Fonction de lecture de la température
//
void getTemperature(float *temperature) {
 byte data[9], addr[8]; // Données et Adresse du module DS18B20
 
 // Réinitialisation du bus
 ds.reset_search();
 
 // Recherche du capteur
 if (!ds.search(addr)) return;
 
 // Vérification de l'adresse reçue
 if (OneWire::crc8(addr, 7) != addr[7]) return;
 
 // Vérification du modèle de capteur (DS18B20)
 if (addr[0] != 0x28) return;
 
 // Sélection du capteur
 ds.reset();
 ds.select(addr);
 
 // Lancement de la mesure
 ds.write(0x44, 1);
 delay(800);
 
 // Resélection du capteur
 ds.reset();
 ds.select(addr);
 
 // Envoie d'une demande de lecture
 ds.write(0xBE);
 
 // Lecture des données
 for (byte i = 0; i < 9; i++) {
 data[i] = ds.read();
 }
 
 // Conversion des données en degrés Celcius
 *temperature = ((data[1] << 8) | data[0]) * 0.0625;
}

On relève les valeurs (valeur « brute » du capteur bilame et valeur en °C du capteur DS) et on les met sur une feuille de calcul :

Analyse des résultats

Chaque « point » est obtenu par copier/coller de plusieurs mesures (20 environ) affichées sur le Terminal du logiciel Arduino.

On constate qu’ils sont très resserrés, la résolution du capteur est donc très bonne !

Par contre, on n’obtient pas une loi très cohérente, cela provient sans doute du fait que le capteur est très sensible aux perturbations extérieures : pesanteur, petits choc lors du passage d’un congélateur à un autre, …

 

Répartition des taches

Date A B C
21/01/2019 Décrire le principe de fonctionnement d’une bilame. Évaluer la déformation d’une bilame. Réaliser des recherches sur les conditions en altitude.
28/01/2019 Recherche du lien entre déformation et effort : loi \(F=f(\epsilon)\). Recherche des caractéristiques des différents capteurs. Comment mesurer un effort ?
04/02/2019 Test capteurs. Test capteurs. Test capteur.
04/03/2019 Croquis.

Relation entre la force, la masse et l’accélération.

X
11/03/2019 Modélisation 3D. Modélisation 3D. X
18/03/2019

Rédaction au propre de la page du site.

Programmation du capteur d’effort.

Branchements du capteur d’effort. X
25/03/2019 Assemblage des modélisation 3D. Comment placer les capteurs dans la nacelle. X
01/04/2019 Programmation des deux sondes Modélisation 3D X
13/05/2019
    X

 

 

 

 

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *