[Arduino] Light-painting et capteur de température ? Humm …

Bonjour tout le monde !

Dans mon précédent article je vous ai présenté un capteur de température sans contact. Si vous ne l’avez pas lu c’est le moment pour aller y jeter un œil 😉

Température … light-painting … leds de couleurs … hummm, je sait pas vous mais moi ça me donne des idées tout ça !

Et si je faisait du light-painting avec des leds de couleurs contrôlaient par la température mesurée par le capteur sans contact ?
Le tout depuis un robot géant tirant des rayons laser dans l’espace ! Bon ok, laissons tomber le robot géant 🙂

—

Comment faire correspondre une couleur et une température ?

Bonne question ! En réalité c’est super simple 😉

Vous avez surement déjà entendu parler du modèle de couleurs TSV (Teinte Saturation Valeur) (HSV (Hue Saturation Value) en anglais) si vous avez fait de la photo.

Le modèle TSV définit une couleur au moyen de trois valeurs :
– la teinte qui définie la couleur en elle même (de 0 à 360),
– la saturation qui définie … la saturation (de 0 à 1),
– et la valeur qui définie l’intensité de la couleur (de 0 à 1).

Plus la saturation d’une couleur est faible, plus l’image sera sombre, une saturation de 0 équivaut à faire du niveau de gris.
Même chose pour la valeur.

Et la teinte ?
Et bien la teinte est codée par un angle en degré sur le cercle des couleurs :
– 0° ou 360° : rouge,
– 60° : jaune,
– 120° : vert,
– 180° : cyan,
– 240° : bleu,
– 300° : magenta.

En résumé le modèle TSV c’est ça :

(merci Wikipedia pour l’image ;))

—

Ok le modèle TSV c’est génial mais à quoi il sert dans ce projet ?

Pour faire simple : à tout.

En fixant la saturation et la valeur à 1 (valeur max) et en faisant varier la teinte on obtient les différentes couleurs du cercle ci dessus.
Il suffit ensuite de convertir le modèle TSV en trois composantes de base : Rouge Vert et Bleu.
Pour se faire il suffit de demander à google, voici le code que j’ai utilisé par exemple : http://www.cs.rit.edu/~ncs/color/t_convert.html

Reste un petit truc à définir : comment faire varier la teinte en fonction de la température mesurée, parce que bon au final c’est le but !

En laissant de côté le magenta qui n’as pas franchement de sens visuellement parlant on obtient ceci :
froid — (240° bleu) — (180° cyan) — (120° vert) — (60° jaune) — (0° rouge) –> chaud

Il suffit donc d’y faire correspondre une échelle de température, par exemple :
froid — (240° bleu) — (180° cyan) — (120° vert) — (60° jaune) — (0° rouge) –> chaud
froid — (-25°C) — (0°C) — (25°C) — (50°C) — (75°C) –> chaud

Au niveau code cela se résume à faire un map() sur des nombres flottants.

—

Le montage

C’est le même que celui de mon précédent article, avec une led RGB en plus.
Les leds sont connectées aux sorties PWM 3, 5, et 6.

Bon par contre j’ai du polir le boitier de la led.
De base le boitier « cristal » ne diffuse absolument rien et les trois couleurs RGB ne sont pas du tout mélangées ensembles.

—

Le code

C’est le même que celui de mon précédent article, la partie « couleurs » en plus.

/* Librairie Wire pour les communications I2C */
#include <Wire.h>

/* Adresse par défaut du capteur IR */
#define I2C_ADDR 0x5A

/** Map function (float version) */
float fmap(float x, float in_min, float in_max, float out_min, float out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

/** Fonction setup() */
void setup() {

  /* Initialisation du port série (pour debug) */
  Serial.begin(115200);
  Serial.println(F("BOOT"));

  /* Initialisation du bus I2C */
  Wire.begin();

  /* Mise en sortie de broches PWM */
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
}

/** Fonction loop() */
void loop() {

  /* Données brute de température */
  uint16_t data;

  /* Commande de lecture de la RAM à l'adresse 0x07 */
  Wire.beginTransmission(I2C_ADDR);
  Wire.write(0x07);
  Wire.endTransmission(false);

  /* Lecture des données : 1 mot sur 16 bits + octet de contrôle (PEC) */
  Wire.requestFrom(I2C_ADDR, 3, false);
  while(Wire.available() < 3);
  data = Wire.read();
  data |= (Wire.read() & 0x7F) << 8;  // Le MSB est ignoré (bit de contrôle d'erreur)
  Wire.read(); // PEC
  Wire.endTransmission();

  /* Calcul de la température */
  const float tempFactor = 0.02; // 0.02°C par LSB -> résolution du MLX90614
  float tempData = (tempFactor * data) - 0.01;
  float celsius = tempData - 273.15; // Conversion des degrés Kelvin en degrés Celcius

  /* Affichage de la température (pour debug) */
  //Serial.print(F("Celcius: "));
  //Serial.println(celsius);

  /* Map la plage -25° ~ +75° vers la plage 240 (bleu sombre) ~ 0 (rouge vif) du modèle de couleur TSV */
  const float lowTempBlue = 10.0;
  const float highTempRed = 40.0;
  celsius = constrain(celsius, lowTempBlue, highTempRed);
  float hue = fmap(celsius, lowTempBlue, highTempRed, 240.0, 0);

  /* Affiche la teinte (pour debug) */
  //Serial.print(F("Hue: "));
  //Serial.println(hue);

  /* Affiche les couleurs */
  float r, g, b;
  HSVtoRGB(&r, &g, &b, hue, 1, 1);
  setLeds(r * 255, g * 255, b * 255);

  /* Affiche les composantes RGB (pour debug) */
  //Serial.print(F("R: "));
  //Serial.println(r);
  //Serial.print(F("G: "));
  //Serial.println(g);
  //Serial.print(F("B: "));
  //Serial.println(b);
  //Serial.println(F("---------------"));

  /* Temps d'attente */
  //delay(250);
}

/** From http://www.cs.rit.edu/~ncs/color/t_convert.html */
void HSVtoRGB( float *r, float *g, float *b, float h, float s, float v ) {
  int i;
  float f, p, q, t;
  if( s == 0 ) {
    // achromatic (grey)
    *r = *g = *b = v;
    return;
  }
  h /= 60;			// sector 0 to 5
  i = floor( h );
  f = h - i;			// factorial part of h
  p = v * ( 1 - s );
  q = v * ( 1 - s * f );
  t = v * ( 1 - s * ( 1 - f ) );
  switch( i ) {
  case 0:
    *r = v;
    *g = t;
    *b = p;
    break;
  case 1:
    *r = q;
    *g = v;
    *b = p;
    break;
  case 2:
    *r = p;
    *g = v;
    *b = t;
    break;
  case 3:
    *r = p;
    *g = q;
    *b = v;
    break;
  case 4:
    *r = t;
    *g = p;
    *b = v;
    break;
  default:		// case 5:
    *r = v;
    *g = p;
    *b = q;
    break;
  }
}

void setLeds(byte r, byte g, byte b) {
  // Leds à anode commune
  analogWrite(6, 255 - r);
  analogWrite(5, 255 - g);
  analogWrite(3, 255 - b);

  // Leds à cathode commune
  //analogWrite(6, r);
  //analogWrite(5, g);
  //analogWrite(3, b);
}

—

Le résultat

Les premiers essais ont été un peu foireux, mais la dernière photo est à mes yeux un vrai succès !
Je vous laisse juger par vous même 😉

Bon WE à tous !