Thermophare RGB

Un phare est un système de signalisation employé soit, dans le domaine maritime, soit dans le domaine aéronautique. C'est alors qu'une poignée d'étudiants brestois eurent l'idée d'étendre le domaine d'utilisation du phare. Le Thermophare RGB a été conçu par les élèves de l'ENIB.

L'ENIB est une école d'ingénieurs situé au Technopôle de Brest

Erreur lors de la création de la miniature : Fichier avec des dimensions supérieures à 12,5 MP

Le Thermophare RGB dans sa version finale.

Description du projet

Le Thermophare RGB est un phare miniature en bois possédant une optique multicolore RGB qui change de couleur en fonction de la température ambiante.

Objectifs pédagogiques

Ce projet a pour ambition de nous faire découvrir de nouvelles façons d'utiliser le numérique et plus particulièrement l'Arduino.

Équipe en charge du projet

• Claire SESBOÜÉ
• Julianne BARBOT
• Gabriel ROUVIER
• Lucas BRAND

Matériel nécessaire

• Arduino
• LED RGB
• Capteur thermique
• Résistances 220 Ω
• Fils
• Breadboard
• Pinces crocodiles
• Bois
• Découpe Laser
• Colle
• Feuille calque

Les différentes couleurs en fonction de la température

• 0° : bleu
• 0-5° : vert clair
• 5-10° : vert foncé
• 10-15° : jaune verdâtre
• 15-20° : jaune
• 20-25° : orange pâle
• 25-30° : orange foncé
• 30-35° : rouge clair
• 35-40° : rouge

Réalisation

Étape 1 : Réalisation du câblage Arduino

On utilise un Breadboard, un capteur thermique, une LED RGB, des pinces crocodiles, des résistances 220 Ω, ainsi que des fils. Nous réalisons le montage ci-dessous.

Schéma réalisé sur Fritzing.

Étape 2 : Réalisation du code Arduino

Nous nous sommes inspiré de codes déjà existants sur internet pour ensuite les adapter à notre situation. Code Arduino :

/* déclaration des broches */
const byte PIN_LED_R = 9;
const byte PIN_LED_G = 10;
const byte PIN_LED_B = 11;

/* Dépendance pour le bus 1-Wire */
#include <OneWire.h>
 
/* Broche du bus 1-Wire */
const byte BROCHE_ONEWIRE = 7;

/* Code de retour de la fonction getTemperature() */
enum DS18B20_RCODES {
  READ_OK,  // Lecture ok
  NO_SENSOR_FOUND,  // Pas de capteur
  INVALID_ADDRESS,  // Adresse reçue invalide
  INVALID_SENSOR  // Capteur invalide (pas un DS18B20)
};


/* Création de l'objet OneWire pour manipuler le bus 1-Wire */
OneWire ds(BROCHE_ONEWIRE);
 

 
/**
 * Fonction de lecture de la température via un capteur DS18B20.
 */
byte getTemperature(float *temperature, byte reset_search) {
  byte data[9], addr[8];
  // data[] : Données lues depuis le scratchpad
  // addr[] : Adresse du module 1-Wire détecté
  
  /* Reset le bus 1-Wire ci nécessaire (requis pour la lecture du premier capteur) */
  if (reset_search) {
    ds.reset_search();
  }
 
  /* Recherche le prochain capteur 1-Wire disponible */
  if (!ds.search(addr)) {
    // Pas de capteur
    return NO_SENSOR_FOUND;
  }
  
  /* Vérifie que l'adresse a été correctement reçue */
  if (OneWire::crc8(addr, 7) != addr[7]) {
    // Adresse invalide
    return INVALID_ADDRESS;
  }
 
  /* Vérifie qu'il s'agit bien d'un DS18B20 */
  if (addr[0] != 0x28) {
    // Mauvais type de capteur
    return INVALID_SENSOR;
  }
 
  /* Reset le bus 1-Wire et sélectionne le capteur */
  ds.reset();
  ds.select(addr);
  
  /* Lance une prise de mesure de température et attend la fin de la mesure */
  ds.write(0x44, 1);
  delay(800);
  
  /* Reset le bus 1-Wire, sélectionne le capteur et envoie une demande de lecture du scratchpad */
  ds.reset();
  ds.select(addr);
  ds.write(0xBE);
 
 /* Lecture du scratchpad */
  for (byte i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
   
  /* Calcul de la température en degré Celsius */
  *temperature = (int16_t) ((data[1] << 8) | data[0]) * 0.0625; 
  
  // Pas d'erreur
  return READ_OK;
}
 
// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {

  // Initialise les broches
  pinMode(PIN_LED_R, OUTPUT);
  pinMode(PIN_LED_G, OUTPUT);
  pinMode(PIN_LED_B, OUTPUT);
  displayColor(0, 0, 0);
  
  /* Initialisation du port série */
  Serial.begin(115200);
}
/** Affiche une couleur */
void displayColor(byte r, byte g, byte b) {

  // Assigne l'état des broches
  // Version cathode commune
  //analogWrite(PIN_LED_R, r);
  //analogWrite(PIN_LED_G, g);
  //analogWrite(PIN_LED_B, b);
  // Version anode commune
  analogWrite(PIN_LED_R, ~r);
  analogWrite(PIN_LED_G, ~g);
  analogWrite(PIN_LED_B, ~b);
}
// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {

  float temperature;
   
  /* Lit la température ambiante à ~1Hz */
  if (getTemperature(&temperature, true) != READ_OK) {
    Serial.println(F("Erreur de lecture du capteur"));
    return;
  }

  /* Affiche la température */
  Serial.print(F("Temperature : "));
  Serial.print(temperature, 2);
  Serial.write(176); // Caractère degré
  Serial.write('C');
  Serial.println();
  
  /* Code de démonstration */
  if (temperature==0)
    displayColor(0, 192, 255);

  if (temperature>0 && temperature<=5)
    displayColor(0, 255, 160);

  if (temperature>5 && temperature<=10)
    displayColor(0, 255, 0);

  if (temperature>10 && temperature<=15)
    displayColor(255, 255, 0);

  if (temperature>15 && temperature<=20)
    displayColor(255, 224, 0);

  if (temperature>20 && temperature<=25)
    displayColor(255, 160, 0);

  if (temperature>25 && temperature<=30)
    displayColor(255, 128, 0);

  if (temperature>30 && temperature<=35)
    displayColor(255, 64, 0);

  if (temperature>35 && temperature<=40)
    displayColor(255, 0, 0);
  
}

Étape 3 : Réalisation du phare à la découpe laser

Nous avons trouvez sur le site Thingiverse des plans pour un phare que nous avons ensuite utilisé puis fabriqué à la découpe laser. Les plans que nous avions trouvé en premier lieux sont trouvables ici. Cependant, nous avons modifié les plans de base pour qu'ils conviennent à notre projet. Vous pourrez trouver ces plans ci-dessous.

Notez qu'une des faces du phare contient une porte que nous avons réalisé nous même pour pouvoir faire passer le câble d'alimentation de la carte Arduino. Le phare seul, sans les éléments numériques que nous lui rajoutons, ressemble initialement à cela :

Étape 4 : Assemblage

Nous avons fixé la LED à un petit bout de carton que nous avons placé à l'emplacement de l'optique du phare et nous avons utilisé les pinces crocodiles pour lier la lampe à la Breadboard qui se situe dans la base du phare avec la carte Arduino. Nous avons ensuite placé une feuille de calque enroulée à l'intérieure de l'optique du phare, autours de la LED RGB.

On aperçoit comment la LED est câblée au reste du montage.