Réaliser des photos thermiques à partir d'Arduino

Img 4842

Difficulté:

L'objectif de ce tutoriel est de réaliser des photos thermiques à partir d'un capteur de température infrarouge et d'une led RGB.

Le capteur transmet la température à la carte Arduino qui va allumer la led d'une couleur correspondant à la température : plus c'est rouge plus c'est chaud, plus c'est bleu plus c'est froid. En utilisant la méthode du "light-painting", on peut ensuite réaliser une photo où seront colorées les zones en fonction de la température.

Je vais développer ce tutoriel pas à pas, de la même façon que j'ai appris à le réaliser. Je pense que sa réalisation est assez simple, mais il est nécessaire d’avoir déjà expérimenté un premier montage Arduino. Je ne détaillerai pas les étapes d’installation de pilote et du logiciel Arduino qui sont déjà largement expliqué sur Google.

Vous êtes prêts ? Allez, c’est parti !

Etape 2 : Température

Pour ce projet on utilise le capteur MLX90614, qui est un capteur infrarouge sans contact qui permet de mesurer la température ambiante (-40 à +85 °C) et la température d’un objet (-70 à +380 °C)

Sur mon schéma, le capteur est alimenté en 3.3V, mais il existe également une version 5V. Pour vérifier la tension de votre capteur, il faut regarder les 3 lettres gravées sur son boitier. Si la première lettre est A, c’est la version 5V. Si c’est un B, c’est la version 3V

Pour communiquer avec le capteur, il existe une bibliothèque Arduino disponible à cette adresse : https://github.com/adafruit/Adafruit-MLX90614-Library. Pour l’installer, il faut placer les fichiers du Github dans mondossierarduino/libraires/Adafruit-MLX90614 puis redémarrer l’IDE.

Cette bibliothèque permet de récupérer la température ambiante, ainsi que la température de ce qui se trouve en face du capteur. C’est cette température qui nous intéresse. On peut alors exécuter ce code :

#include <Adafruit_MLX90614.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

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

void loop() {
// Lecture de la température ambiante
Serial.print("Ambiant = ");
Serial.print(mlx.readAmbientTempC());
Serial.println("*C");

// Lecture de la température de l'objet
Serial.print("Objet = ");
Serial.print(mlx.readObjectTempC());
Serial.println("*C");

Serial.println();
delay(1000);
}

Source : https://learn.adafruit.com/using-melexis-mlx90614-non-contact-sensors/wiring-and-test

Fichiers techniques de cette étape :

1-temperature.ino

Etape 3 : LED de couleur

Nous allons maintenant allumer une LED RGB dont la couleur varie selon la température. La LED sera bleue si la température est froide, et rouge si la température est chaude.


La couleur de la LED sera définie en utilisant le modèle de couleurs TSV (Teinte Saturation Valeur) :

  • Teinte (Hue) : Correspond à la couleur, codée suivant l’angle qui lui correspond sur le cercle des couleurs (voir image). 0° rouge -> 60° jaune -> 120° vert -> 180° cyan -> 240° bleu -> 300° magenta -> 360° rouge
  • Saturation : Correspond à l’intensité de la couleur. Plus elle est faible, plus la couleur sera grisée et apparaîtra fade. Elle varie de 0 à 1, ou 0 correspond à l’absence de couleur et 1 la couleur pure.
  • Valeur (Value) : Correspond à la brillance de la couleur. Plus la valeur est faible, plus la couleur est sombre. Elle varie également de 0 à 1 où 0 correspond au noir.

Dans notre cas, la saturation et la valeur resteront fixes à 100% et seule la teinte varie. Pour obtenir la teinte voulue en fonction de la température, nous allons ré-étalonner la température d’une échelle fixée (par exemple -25°C vers +75°C) vers une échelle de teinte (240° - bleu vers 0° - rouge) :

  • -25°C -> 240° bleu
  • 0°C -> 180° cyan
  • 25°C -> 120° vert
  • 50°C -> 60° jaune
  • 75°C -> 0° rouge

Une fois la couleur obtenue, il faut l’appliquer à notre LED. Le modèle TSV nous était utile puisqu’il permettait de ne modifier que la composante de teinte. Mais notre LED RGB fonctionne en appliquant 3 tensions sur les couleurs rouge verte et bleu. On va donc convertir notre couleur vers le modèle … RGB. La LED que j’utilise est à cathode commune, c’est-à-dire que la broche (-) est commune aux 3 couleurs. Une LED à anode commune est aussi utilisable. Choisissez de préférence un boitier diffusant plutôt qu’un boitier transparent, il permet une meilleure homogénéité de la couleur.


La LED doit être associée à des résistances  de limitation de courant. Pour connaitre la valeur des résistances à utiliser, il faut connaitre les tensions de seuil de la LED, fournies par le constructeur. Dans mon cas, il est indiqué :

Caractéristiques sous 20 mA:
Rouge:
- tension: 2 V
- longueur d'onde: 623 nm
- éclairement: 2800 mcd

Verte:
- tension: 3,2 V
- longueur d'onde: 521 nm
- éclairement: 6500 mcd

Bleue:
- tension: 3,2 V
- longueur d'onde: 466 nm
- éclairement: 1200 mcd

On applique la loi R = (Uarduino – Uled) / I, où Uarduino = 3.3V et I = 0.02A.

Ce qui nous donne :

  • Rouge : 65 ohms
  • Vert :  5 ohms
  • Bleue : 5 ohms

Si la valeur trouvée n’est pas standard, on choisit la valeur standard supérieure la plus proche. J’ai donc choisi 100 ohms et 10 ohms.


Je précise également qu’il est indispensable de placer les 3 broches de la LED sur des sorties PWM de l’Arduino. Ces sorties sont indiquées par un tilde (~) à côté du numéro de sortie. Elles permettent d’appliquer une tension variable, pendant qu’une sortie classique fonctionne en tout ou rien. J’ai choisi les sorties 9,10 et 11.

Le nouveau code devient :

#include <Wire.h>
#include <Adafruit_MLX90614.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

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

    // Initialisation de la LED
    pinMode(9, OUTPUT); // Bleu
    pinMode(10, OUTPUT); // Vert
    pinMode(11, OUTPUT); // Rouge
}

void loop() {
    // Lecture de la température
    float celsius = mlx.readObjectTempC();

    // Re-etalonnage de la plage de temperature vers la plage de teinte
    const float lowTemp = 10.0; // Temperature min (bleu)
    const float highTemp = 30.0; // Temperature max (rouge)
    const float lowHue = 240.0; // Couleur min (bleu)
    const float highHue = 0; // Couleur max (rouge)
    celsius = constrain(celsius, lowTemp, highTemp);
    float hue = fmap(celsius, lowTemp, highTemp, lowHue, highHue);

    // Modification de la couleur de la LED
    float r, g, b;
    HSVtoRGB(&r, &g, &b, hue, 1, 1);
    setLeds(r * 255, g * 255, b * 255);
}

/** Applique les tensions sur les 3 broches de la LED */
void setLeds(byte r, byte g, byte b) {
    // LED à anode commune
    //analogWrite(9, 255 - b);
    //analogWrite(10, 255 - g);
    //analogWrite(11, 255 - r);

    // LED à cathode commune
    analogWrite(9, b);
    analogWrite(10, g);
    analogWrite(11, r);
}

/** Version float de la fonction Map */
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;
}

/** Converti le modele de couleur HSV vers le modele RGB. Source : 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 ) {
        *r = *g = *b = v;
        return;
    }
    h /= 60;
    i = floor(h);
    f = h - i;
    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:
           *r = v;
           *g = p;
           *b = q;
           break;
      }
}

En l’état, le projet peut s’arrêter ici. En utilisant la méthode du light painting, nous pouvons réaliser des photos où les zones sont colorées en fonction de la température (voir la dernière étape). Mais il peut être intéressant d’avoir un écran qui affiche la température, et permettre de modifier les seuils minimum et maximum de température sans modifier le code. C’est ce que nous allons voir dans la suite de ce tutoriel.

Source : https://publiclab.org/notes/ad/11-28-2011/thermal-camera-arduino-uno-mlx90614-ir-thermometer

https://skyduino.wordpress.com/2013/11/02/arduino-light-painting-et-capteur-de-temperature-humm/

Fichiers techniques de cette étape :

led.ino

Etape 4 : Écran LCD

Nous allons utiliser un afficheur alphanumérique LCD  de 2 lignes de 16 caractères. Les écrans compatibles avec la bibliothèque Arduino sont reconnaissables par leurs 16 broches que je vais brièvement décrire :

N°               Nom               Rôle

1                 VSS                Masse

2                 Vdd                +5V

3                 V0                  Réglage du contraste

4                 RS                  Sélection du registre (commande ou donnée)

5                 R/W               Lecture ou écriture

6                 E                     Entrée de validation

7 à 10        D0 à D3         Bits de données de poids fort

11 à 14     D4 à D7         Bits de données de poids faible

15              LED+              Anode du rétroéclairage (+5V)

16              LED-              Cathode du rétroéclairage (masse)


Il existe 2 façons de pilote l’écran. Soit en utilisant les 16 connexions (mode 8 bits), soit en utilisant 4 connexions de moins (mode 4 bits). Le mode 4 bits, malgré qu’il soit plus lent, a l’avantage d’être plus simple et moins gourmand en pins. Comme nous n’avons pas besoin de changement d’information rapide, nous allons utiliser ce mode.

On reprend le tableau précédent et je vous explique où brancher vos broches :

N°               Nom               Rôle

1                 VSS                Masse générale du montage

2                 Vdd                +5V de l’Arduino

3                 V0                  Broche centrale du potentiomètre 10K

4                 RS                  Pin 12 de l’Arduino

5                 R/W               Comme nous allons uniquement écrire sur l’écran, à relier à la masse

6                 E                     Pin 13 de l’Arduino

7 à 10        D0 à D3         Comme nous utilisons le mode 4 bits, à la relier à la masse

11 à 14     D4 à D7         Pins 7,6,5 et 4 de l’Arduino. Oui, dans cet ordre

15              LED+              +5V de l’Arduino

16              LED-              Masse générale du montage

Ça commence à faire beaucoup de fil tout ça ! La boite qui devait contenir le projet devait être plus petite, c’est pour ça que j’ai directement soudé les fils sur l’écran comme un malpropre. Mais sachez qu’il existe des connecteurs pour rendre votre montage moins définitif : https://www.gotronic.fr/art-connecteur-he14-mh100-4457.htm


Côté code, nous allons utiliser la librairie LiquidCrystal qui va nous simplifier la vie pour dialoguer avec l’écran. Pour l’installer dans l’IDE, il faut se rendre dans  Croquis > Inclure une bibliothèque > Gérer les bibliothèques. Dans la barre de rechercher, chercher « LiquidCrystal ». Si la biliothèque est déjà installé, il est indiqué « INSTALLED » à côté de son nom, sinon il y a un bouton pour l’installer.

On peut lancer le code d’essai de l’écran :

#include <LiquidCrystal.h>
LiquidCrystal lcd(12,13,7,6,5,4); // (RS, E, d4, d5, d6, d7)

void setup() {
    lcd.begin(16,2); //on initialise la communication avec 16 colonnes et 2 lignes
    lcd.clear(); // on efface l'écran
    lcd.print("Oui are"); // on écrit la premiere ligne
    lcd.setCursor(0,1); //on passe à la ligne suivante
    lcd.print("Makers"); // on écrit la deuxieme ligne
}

void loop() {
}

En soit, ce n’est pas super utile d’afficher un texte fixe sur un écran. Nous allons alors afficher la température en mélangeant ce code avec celui de l’étape 1 :

#include <Adafruit_MLX90614.h>
#include <LiquidCrystal.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();
LiquidCrystal lcd(12,13,7,6,5,4); // (RS, E, d4, d5, d6, d7)

void setup() {
    Serial.begin(9600);
    mlx.begin();
    lcd.begin(16,2); // 16 colonnes et 2 lignes
    lcd.clear(); // On efface l'écran
    lcd.print(F("Temperature :")); // On écrit sur la 1ere ligne
}

void loop() {
    /* Affichage de la température */
    lcd.setCursor(0,1); // On se place au debut de la 2eme ligne
    lcd.print(mlx.readObjectTempC());
    lcd.print(" ");
    lcd.write(178); // Astuce pour afficher °
    lcd.print("C");

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

Source : https://openclassrooms.com/courses/perfectionnez-vous-dans-la-programmation-arduino/programmez-un-ecran-lcd

http://eskimon.fr/26-arduino-701-les-ecrans-lcd

Fichiers techniques de cette étape :

3-lcd.ino

Etape 5 : Encodeur

Pour pouvoir naviguer dans le menu, nous allons utiliser un encodeur rotatif. Cette petite bête ressemble à un potentiomètre qui ne possède pas de fin. En le tournant, on peut ressentir des crans, qui seront interprétées par l’Arduino par un +1 ou -1.

Comme je suis fainéant, je me vais me servir une fois de plus d’une librairie existante pour que l’Arduino puisse comprendre les mouvements de rotation de l’encodeur : https://github.com/brianlow/Rotary

Pour ceux du fond qui dormaient pendant la 1ère étape, pour l’installer, il faut placer les fichiers du Github dans mondossierarduino/libraires/Rotary puis redémarrer l’IDE.

La librairie possède 2 méthodes pour capturer les evenements : Polling ou Interrupt :

  • Pooling : L’Arduino vérifie régulièrement si la position de l’encodeur a été modifiée ou non. En fonction de l’intervalle de vérification, la réactivité peut être plus lente, et l’Arduino consomme plus de CPU. En faisant l’analogie avec un téléphone, c’est comme si nous devons décrocher régulièrement pour vérifier s’il n’y a personne au bout du fil.
  • Interrupt : Lorsque la position de l’encodeur a été modifiée, le programme s’interrompt pour effectuer l’action associée, ici le changement de menu. En reprenant l’analogie du téléphone, le téléphone sonne quand quelqu’un est au bout du fil, avouez que c’est plus séduisant.

Mais il faut savoir que tous les pins de l’Arduino ne disposent pas de cette fonction d’interruption, seulement les pins 2 et 3 dans le cas de l’Arduino UNO. Ça tombe bien, ils sont encore disponibles dans notre projet, quel hasard !

Avec ce bout de code, nous affichons « +1 » pour une rotation dans le sens horaire, et « -1 » pour une rotation dans le sens anti-horaire :

#include <Rotary.h>

Rotary r = Rotary(2, 3);

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

    // Declaration de l'encodeur
    PCICR |= (1 << PCIE2);
    PCMSK2 |= (1 << PCINT18) | (1 << PCINT19);
    sei();
}

void loop() {
}

/**  Fonction appelée au mouvement de l'encodeur */
ISR(PCINT2_vect) {
    unsigned char result = r.process();
    if (result == DIR_CW) {
        Serial.println("+1");
    } else if (result == DIR_CCW) {
        Serial.println("-1");
    }
}

L’encodeur dispose également d’un bouton poussoir qui est câblé indépendamment comme n’importe quel bouton. Il y a 3 manières de connecter un bouton sur l’Arduino :

  • Résistance pull-down : Le bouton poussoir est placé entre le +5V et le pin de l’Arduino. Une résistance est placée entre le GND et la liaison Bouton <-> Pin pour absorber le courant si le bouton est relevé.
  • Résistance pull-up : Le bouton poussoir est placé entre le GND  et le pin de l’Arduino. Une résistance est placée entre le +5V  et la liaison Bouton <-> . Lorsque le bouton est relevé, l’Arduino reçoit +5V ce qui le passe en état HAUT, et GND quand le bouton est appuyé, ce que le passe en état BAS. Vous remarquerez que les états du pin sont inversés par rapport au bouton.
  • Mode INPUT_PULLUP : L’Arduino propose un mode qui permet d'activer une résistance de 20 KΩ qui est dans la carte pour en faire une résistance pull-up. L'avantage est clair : pas besoin de se prendre la tête avec une résistance en plus. Il suffit de connecter correctement le bouton poussoir en mode pull-up, ce qui implique que nous aurons encore l’état inversé par rapport à la position du bouton.

Allez, on ajoute ce bout de code qui indique l’état du bouton en plus de l’état de l’encodeur :

#include <Rotary.h>

Rotary r = Rotary(2, 3); // L'encodeur est sur les pins 2 et 3
int pinBouton = 8; // Le bouton est sur le pin 8
boolean etatBouton = 0; // Sauvegarde du dernier etat du bouton

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

    // Declaration de l'encodeur
    PCICR |= (1 << PCIE2);
    PCMSK2 |= (1 << PCINT18) | (1 << PCINT19);
    sei();

    // Declaration du bouton en mode pullup
    pinMode(pinBouton,INPUT_PULLUP);
}

void loop() {
    boolean etatBoutonTmp= !digitalRead(pinBouton); // ! puisque l'etat est inversé par rapport au bouton
    if (etatBoutonTmp != etatBouton) {
        etatBouton = etatBoutonTmp;
        Serial.println(etatBouton); // On affiche l'etat du bouton
        delay(5); // Corrige un bug etrange qui engendre des appuis non sollicites
    }
}

/** Fonction appelée au mouvement de l'encodeur */
ISR(PCINT2_vect) {
    unsigned char result = r.process();
    if (result == DIR_CW) {
        Serial.println("+1");
    } else if (result == DIR_CCW) {
        Serial.println("-1");
    }
}

Source :

https://github.com/brianlow/Rotary

https://community.nxp.com/thread/29262

http://simple-duino.com/interruption-et-arduino/

https://openclassrooms.com/courses/programmez-vos-premiers-montages-avec-arduino/le-bouton-poussoir

Fichiers techniques de cette étape :

encodeur.ino

Etape 6 : Assemblage final

Pour résumer, nous avons réussi à faire fonctionner un capteur de température, une LED de couleur, un écran LCD et un encodeur numérique. Maintenant il faut les faire fonctionner tous ensemble.

L’écran et l’encodeur vont nous permettre de créer un menu. Il y aura 4 étapes :

  1. LED : Mode principal qui affichera la LED en fonction de la température
  2. Temperature : Affiche la température du capteur. Cela peut être utile pour analyser la température avant la photo, afin de régler correctement les seuils maximum et minimum.
  3. Temp + : Réglage de la température maximale qui correspond au rouge. En appuyant sur le bouton, on entre dans le réglage de la température. L’encodeur incrémente alors la valeur de + ou - 0.10°C. Un second appui sur le bouton repasse sur le menu général
  4. Temp - : Réglage de la température minimale qui correspond au bleu. Même comportement que Temp +

Le code étant un peu longuet, je le place uniquement dans les fichiers techniques.


Il nous reste plus qu’à positionner tous ces éléments dans le boitier. Celui que j’ai indiqué dans la partie matériel est assez grand pour tout contenir, et assez haut pour que les fils ne soient pas écrasés (200 x 130x 45 cm). Je vous conseille de monter les composants avant d’entamer le câblage final, de cette manière on peut plus facilement couper les fils à la bonne taille. En plaçant tous les éléments sur la même face, nous pouvons plus facilement câbler et fermer le boitier.

Pour créer un interrupteur, il faut sectionner un des 2 fils reliant la pile à l’arduino, pour les souder sur l’interrupteur. Un brin du fil est soudé sur la borne centrale, l’autre fil sur une des 2 autres bornes, sachant que l’interrupteur doit être positionné vers cette borne pour alimenter l’arduino.

Pour fixer le support de la LED, l’interrupteur et l’encodeur, il suffit de percer aux bons diamètres et de fixer les écrous. Le capteur de température n’ayant pas de support, j’ai percé un trou aux dimensions exactes du capteur pour le fixer par friction. Pour fixer l’écran, j’ai découpé à la Dremel un rectangle de la taille de l’écran, puis fixé les vis pour le maintenir. L’arduino, la breadboard et la pile sont maintenus par de l’adhésif double face, ce qui fait largement l’affaire.

Fichiers techniques de cette étape :

final.ino

Etape 7 : Photographie

Avoir un boitier qui fait de la couleur c’est bien beau, mais ce qui nous intéresse c’est faire des photos thermiques. Les photos doivent être prises selon la méthode du Light Painting.

Configuration de l’appareil photo :

Ils existent trois réglages qui influent sur le rendu de la scène photographiée. La sensibilité (ISO), l’ouverture (F/) et le temps de pose. Les appareils photo proposent généralement la possibilité d’effectuer ces différents réglages. Si ce n’est pas votre cas, vous pouvez tenter l’expérience en utilisant le mode « Nuit » de votre appareil.

Sensibilité ISO

Le paramètre ISO correspond à la sensibilité du capteur. Plus il est haut, plus le capteur capte de lumière et donc plus l’image est lumineuse. Dans le cas du light painting, la sensibilité doit être basse (ISO 100-200) afin que le capteur de l’appareil photo soit moins sensible à la lumière permettant des scènes correctement exposées malgré le long temps de pose. Par ailleurs, plus la sensibilité est basse, moins le bruit est apparent sur la photographie.

Ouverture (F/)

L’ouverture correspond à l’ouverture du diaphragme de l’objectif. Plus il est ouvert, plus la lumière peut entrer dans l’appareil photo pour atteindre le capteur. Comme le temps de pose sera important, il est préférable d’ouvrir le diaphragme au minimum pour laisser passer le moins de lumière possible. La valeur F/ de l’ouverture est contraire à l’ouverture physique du diaphragme. Ainsi une grande ouverture sera par exemple de F/2.8 alors qu’une petite ouverture sera de l’ordre de F/16. Pour les photos ci-dessus, j’ai fermé à F/22.

Temps de pose

Lorsque l’on appuie sur le bouton pour déclencher la photo, l’appareil ouvre un clapet pour laisser entrer la lumière, et le referme à la fin de la photo. C’est le temps de pose. Ici, il nous faut un temps de pose relativement long pour avoir le temps de balayer la zone avec notre LED. Le temps de pose pourra durer quelques secondes pour une petite zone jusqu’à plusieurs minutes si l’on peint toute une pièce. La plupart des appareils photos ont un temps maximum de 30sec. Cependant, il existe le mode BULB qui est un mode manuel. Nous pouvons lancer la photo et l’arrêter une fois notre balayage terminé.


Préparation de la scène

En premier lieu, il faut que l’appareil soit immobile pendant toute la photo. L’idéal est un trépied, qui permet de modifier l’angle de la photo, mais vous pouvez aussi le poser sur une surface stable.

Sur notre photo nous voulons voir une grande différence de couleur entre les températures. Grâce au mode qui affiche la température, nous allons pouvoir repérer la température exacte du point le plus chaud, et du point le plus froid. Ce sont les températures que nous allons régler sur les seuils min et max.

Avant la prise de photo, il sera utile d’éteindre les lumières ambiantes afin que les zones colorées ne soient pas surexposées à la lumière. Il est cependant possible d’avoir une légère lumière ambiante pour éclairer les alentours. Il ne reste plus qu’à enclencher la photo et d’aller peindre le sujet. Vous pouvez faire des balayages horizontaux ou verticaux, ou laissez libre cours à votre créativité.

Source : http://www.christopher-hibbert.com/lightpainting/

Etape 8 : Conclusion

Pour ce premier projet sur Arduino, je dois avouer que je suis assez content du résultat. Les photos obtenues permettent de distinguer facilement les zones de chaleur, et les couleurs sont vives sans nécessiter de retouche photo.

Il y a une petite amélioration possible, concernant l’écran LCD qui reste allumé pendant la photo. Il oblige d’orienter le boitier dans le bons sens pour ne pas que la lumière de l’écran soit capté par l’appareil photo. Cela peut se régler par un transistor qui active ou désactive l’alimentation de l’écran.

Merci de m’avoir lu jusqu’ici, et n’hésitez pas à me partager vos critiques et corrections en commentaire, voire même votre meilleure blague. N’ayant pas de réelle formation en électronique, je m’excuse d’avance auprès des pros de mes raccourcis et erreurs éventuelles.

Vous aimez ce tutoriel ?


Psine

11 nov. 2017 à 09:21

Super idée et tuto très bien détaillé ! Bravo.

dirtymarmotte

09 déc. 2017 à 16:28

Fabuleux! L'idée est vraiment excellente, bravo!

Nicron

13 déc. 2017 à 20:39

Bravo! L'idée du ligthpainting thermique est absolument géniale!
Je voudrais tout de même revenir sur quelques points. Concernant les résistances de limitation de la DEL, la série E12 et E24 proposent des valeurs multiples de 5.6 et 6.8, ceci donnerait :
Rrouge = 68 ohms ; Rverte = 5.6 ohms et Rbleue = 5.6 ohms,
qui sont des valeurs plus proches de ce que vous avez calculé.
A part ça, le "puriste" que je suis regrette peut-être l'emploi du Arduino, mais ce n'est qu'un détail et cela a au moins l'avantage de rendre le montage accessible au plus grand nombre. En tout cas c'est un beau projet.


Recevez une fois par mois les meilleurs tutoriels Technologie dans votre boîte mail




Oh ça buzz

+ de 1 000 vues pour Réaliser des photos thermiques à partir d'Arduino


Champion

Gagnant du Concours Concours DIY électronique


S'inscrire:



En cliquant sur s'inscire, vous acceptez de respecter les conditions générales d'utilisation de Oui Are Makers.

  • Vues: 1186
  • J'aime: 19