Semaine 8 : Modélisation 3D - La Fabrication numérique • Bibliothèque • Zeste de Savoir

Avant d’imprimer des objets, il faut les modéliser

Bienvenue dans cette 8^ème semaine du MOOC "La Fabrication Numérique". Cette semaine, nous continuons notre découverte des outils de modélisation avec une série de vidéos d’initiation à Blender. Nous verrons quel vocabulaire, quels outils et quelles techniques sont nécessaires pour produire des modèles 3D exploitables par les imprimantes 3D qui seront abordées la semaine prochaine.

En parallèle de ces vidéos d’introduction, nous continuons à vous proposer des cours sur les concepts de base du prototypage électronique et du développement Arduino.

Bonne semaine !

Introduction à la modélisation 3D
Initiation à Blender
Introduction à la modélisation 3D - Annexe
Transistors (suite)
Arduinomètre, troisième partie
Travaux pratiques

Introduction à la modélisation 3D

La modélisation 3D

http://www.dailymotion.com/video/x2kgztv_la-modelisation-3d_school

Merci d’avoir regardé cette vidéo. Celle-ci constitue une brève introduction à la modélisation 3D. La suite passe par l’installation de Blender, un incroyable logiciel de modélisation, d’animation et de rendu en 3D. Ce logiciel nous permettra de créer nos premiers modèles 3D, exportables pour les imprimantes 3D que nous verrons la semaine prochaine.

Pour utiliser Blender, nous vous invitons à regarder la vidéo ci-dessous. Aussi, il est fortement recommandé de lire les références proposées ici :

Références

Manuel complet consacré à Blender par l’équipe de FlossManuals
Manuel officiel par l’équipe Blender

Merci à Laurent Mattlé pour ce cours !

Initiation à Blender

Voici dès maintenant trois vidéos sur Blender, le logiciel de modélisation 3D que nous allons utiliser pour modéliser nos objets.

Introduction à la modélisation 3D - Annexe

Annexe

Voici quelques compléments dont il faudra se souvenir lorsque nos modèles seront exportés vers des imprimantes 3D.

Types d’impression

Il existe de nombreux procédés d’impression 3D mais les plus courants sont :

le FDM (Fused Deposition Modeling) : où l’on vient faire fondre un filament de thermoplastique et le déposer couche par couche.
le SLS (Selective Laser Sintering ) : où l’on vient solidifier de la poudre avec une impulsion laser. Cette technique plus coûteuse donne de meilleurs résultats (elle est souvent la technique utilisée par les boutiques en ligne).

Si on modèlise pour le SLS il faut penser à faire un trou d’au moins 3mm pour que la poudre à l’intérieur puisse s’échapper de notre modèle.

Parois

Une face seule ne sera pas considérée comme un objet 3D et ne sera pas imprimée. Pour qu’une face soit comprise comme telle, il faut que cette face ait de l’épaisseur. L’épaisseur dépend de votre outil et matériau cible. Pour le SLS (si vous passez par un imprimeur) il faut simplement suivre les instructions disponibles sur son site internet et qui conviennent à sa machine.

Pour le FDM, l’épaisseur du fil a son importance car chaque paroi est faite du dépôt d’une épaisseur de fil pour un côté et d’une autre pour l’autre côté. Il faudra donc que l’épaisseur de la paroi soit au moins de 2 épaisseurs de fils. Enfin, si on veut qu’il y ait un remplissage, il faut de la place pour celui ci sinon la solidité pourrait lourdement en pâtir.

Je resterai très superficiel sur ce qu’il faut faire tout simplement parce que chaque couple “imprimante/fil” réagit différemment selon le modèle et il est préférable d’aller discuter avec celui qui maintient l’imprimante ou de faire quelques tests avant, pour savoir à quoi vous attendre (pour avoir un ordre de grandeur, 0,25mm entre les parois est un bon minimum).

Manifold

Lors de la création du modèle il faut avoir en tête que toutes les faces soient bien reliées. Chaque espace doit être fermé et c’est ce qu’on peut découvrir avec la fonction non manifold dans Blender.

Ensuite, ce n’est pas parce que deux vertices ou edges sont au même endroit qu’ils sont reliés d’où la nécessité de supprimer les doublons (remove doubles) et de vérifier s’il n’y a pas de parois qui se chevauchent ou bien des faces internes qui ne servent à rien et qui ne pourront être interprétées par le logiciel de l’imprimante.

Normales

Vérifiez aussi les normales de chaque face pour qu’elles soient toutes tournées vers l’extérieur.

Tailles/poids

En fait nous sommes vite tentés d’avoir beaucoup de subdivisions pour avoir le plus de “douceur” possible mais le nombre de polygons augmentet de façon dramatique.

Il faut savoir utiliser les polygons à bon escient : ne pas dépasser les 500 000 vertices tout en optimisant la taille des modèles.

Angle des parois (Overhang)

Un concept que l’on oublie souvent est la gravité. En effet, si on dépose du plastique fondu dans le vide, il tombe ! Mais si on le pose à moitié dans le vide ça peut peut-être tenir. Cela signifie que l’on peut se permettre de monter nos couches de plastique avec un angle de 45°.

Sinon il faut faire des échafaudages, soit automatiquement soit en les construisant soi-même dans le modèle, ce qui permet d’optimiser la consommation de plastique.

Vérification automatique

Il y a dans Blender un outil 3D appelé "print toolbox" qui, une fois paramétré avec les limites de votre machine cible, met en lumière les points problématiques du modèle.

Dans le même esprit, voici deux logiciels très utiles :

Ces logiciels prennent le modèle et le répare quasi automatiquement s’il n’est pas conforme aux exigences de l’impression. Il sont tous deux gratuits et finalement apportent sécurité et sérénité au flux de production.

Merci à Laurent Mattlé pour ce cours !

Transistors (suite)

Arduino chauffage

L’Arduino peut-être programmé pour calculer la température ambiante, en exploitant une tension variable fournie par un capteur. En précisant un seuil, l’Arduino peut allumer ou arrêter la chauffage. Mais comment brancher un chauffage de 2Kw à 240v sur l’Arduinomètre ?

Une possibilité comme ceci :

Ici la charge c’est un relais de puissance. La bobine du relais est prévue pour 12V, et sa résistance est d’environ 250Ω¹. Notez bien que il n’y a aucune connexion entre le circuit 230V et le circuit Arduino / transistor. C’est un des grands intérêts des relais : une séparation complète de deux environnements électriques incompatibles entre-eux. Néanmoins, un tel montage devra se trouver bien enfermé dans une boite en plastique, à cause des branchements secteur !

Q : Quel est l’intensité maximum quand le transistor est en conduction ?

R : La résistance du relais est de 250Ω¹. Donc $I_C = \frac{12 V}{250 \Omega} = 0.048 A$ (48mA)

Mais il y a une dernière valeur à vérifier, surtout car nous avons commencé à augmenter la tension commandée par le transistor : la dissipation (de chaleur) totale, $P_{tot}$ .

Si le transistor chauffe trop, il se détruit ! Les données constructeur donnent une valeur de $P_{tot}$ de 625mW. Vérifions que nous sommes dans les clous :

$P_{tot} = P_{CE} + P_{BE}$  : C’est-à-dire qu’il ne faut pas oublier la (faible) intensité qui traverse les bornes $B-E$ dans notre calcul !

Pour calculer la puissance dissipée dans le transistor par les 48mA qui passent à travers les bornes $C-E$ , il faut connaître la chute de tension. C’est aussi dans les données fabricant :

$VCE_{SAT} = 700mV$ (0,7v)

On peut donc calculer :

$P_{CE} = 0.7 V \times 0,048 A$ (l’intensité à travers le relais) $= 33,6mW$

$P_{BE} = 5 V \times 0,005 A$ (l’intensité de 'pilotage’) $= 25mW$

Et donc $P_{tot} = 33.6 + 25 = 58.6mW$ . Pas de soucis avec $P_{tot}$ pour cette application.

Récapitulons : Transistor 'interrupteur'

Chercher les données techniques ;
Calculer $IC_{MAX}$ avec la vraie valeur R de votre charge (relais, bobine, etc.) et, bien sûr, la vraie valeur de la tension d’alimentation ;
Calculer la résistance du Base $R2$ pour limiter l’intensité $IB$ a $\frac{IC_{MAX}}{β}$  : n’oubliez pas la chute de tension $VBE$  ;
Ne dépassez JAMAIS les limites maximales du transistor ( $IC$ , $P_{tot}$ … )

Seuil de tension $V_{BE}$

Vous vous souvenez de notre petit montage R-C avec l’Arduino d’il y à quelques semaines ? Celui où la LED clignotait 'en retard' par rapport à la sortie de l’Arduino. Je vous ai dit que la formule pour calculer le temps pour un circuit RC était, tout simplement, $R \times C$ .

Mais ce calcul est basé sur le principe que le temps T est le temps pour charger complètement le condensateur (en fait la définition c’est le temps pour arriver à 63 % de la tension d’alimentation, mais passons). Notre montage, souvenons-nous :

La sortie de l’Arduino va charger le condensateur à travers la résistance de 10 kΩ. La tension d’alimentation va être 5V (le niveau 'high' de l’Arduino). Mais notre transistor commence à laisser passer du courant à partir d’environ 0.7 V de tension $V_{BE}$ (l’équivalent diode). Le transistor va se mettre en conduction bien avant que le condensateur se trouve complètement chargé !

Voila un mystère résolu….

Transistors PNP

Les montages 'transistor' vus jusqu’à présent utilisent un transistor NPN. L’émetteur se trouvait toujours à une tension négative par rapport au collecteur. Il existe des transistors avec exactement les mêmes données techniques SAUF que leur polarité est inversée. Ce sont, donc, les transistors PNP. On les trouve beaucoup dans les circuits analogiques, surtout dans les amplificateurs audio. Mais parfois ils peuvent nous filer un coup de main pour nos montages numériques.

Regardons ce schéma ensemble :

La partie inférieure/droite du schéma nous est familière : un transistor NPN qui pilote une DEL rouge. Et voilà en haut à gauche notre transistor PNP. Ici on voit bien le sens des flèches sur les symboles pour les deux transistors : ils pointent dans la même direction: de +ve au -ve. L’émetteur PNP est +ve par rapport à son collecteur.

Alors, quelle est l’utilité de ce montage ? Essayons de comprendre un peu…

Supposant que le niveau à l’entrée est à '1' (5v). Nous avons déjà vu que cela fait passer un courant à la base du transistor NPN, et la DEL s’allume. Mais la base du transistor PNP se trouve au même potentiel que son émetteur – et donc le transistor ne "s’allume" pas. Si l’entrée est tirée au niveau 0v, le NPN va s’arrêter de laisser passer le courant de la DEL rouge, mais maintenant, car $V_{BE}$ devient -5 V (réfléchir), le PNP va se mettre en conduction – et la DEL verte s’allume.

Avec une seule sortie de l’Arduino, nous pilotons deux sorties exclusives. Une idée pour les feux de signalisation sur une machine ou pour sécuriser nos feux tricolores / piétons, par exemple…

Les règles d’utilisation et les calculs pour les transistors PNP sont les mêmes que pour les NPN : il suffit (je sais, c’est pas facile – c’est toujours écrit en Shakespeare) de chercher la fiche technique. Parfois les fabricants sont sympas et ils mettent sur la fiche l’équivalent complémentaire du transistor : cela aide à la recherche.

Transistors à Effet de Champ (FET)

À nouveau j’essaie de rester simple (mais il y aura un peu de maths simples, comme pour les transistors bipolaires).

Je vous ai déjà dit que la différence importante entre les FETs et les transistors bipolaires, c’est la présence d’une tension entre les bornes G et S qui contrôlent l’intensité qui traverse les FETs, là où nous avons vu que c’est l’intensité (entre B et E) pour les transistors bipolaires.

Les FETs ont aussi un autre différence : une très faible résistance interne en mode conduction (souvent moins d’un ohm) ; mais une résistance très élevée en mode bloquant. Deux paramètres faisant des FETs des candidats idéaux pour faire des interrupteurs pilotés. Quelques valeurs pour une FET de puissance, le IRFP260 :

Des valeurs à faire rêver :

$V_{DSMAX} = 200 V$ (la tension maximale entre D et S);
$I_{DMAX} = 46 A$ (intensité maximale à travers D);
$R_{DS(on)} = 55 mΩ$ (0,055Ω) ! (la résistance en mode conduction)

Une autre valeur, tirée de la même fiche technique :

$V_{GS(thres)} = 2,0 V_{min}, 4,0 V_{max}$

Alors, c’est quoi ? C’est tout simplement le seuil de tension à partir duquel le FET commence à entrer en conduction.

Alors, ça se branche comment ? Ben, presque comme un transistor 'normal' :

Branchement d'un FET — Branchement d’un FET

Notre 'charge' (bobine¹, relais, moteur…) est montée entre la source d’alimentation et le FET. Une résistance en entrée plutôt pour protéger la source (Arduino) en cas de court-circuit (car c’est une tension sur le gate qui fait fonctionner le FET - plus besoin de limiter le courant). La résistance de 10KΩ pour les cas ou l’entrée reste 'flottante' : c’est pour s’assurer que le FET s’arrête bien : le Gate est tiré vers 0v.

La source de tension dans ce schéma est de 5v, mais les données techniques nous disent qu’on peut aller jusqu’à 200v !

Notons que c’est la tension qui contrôle le passage de courant de G à S, et qu’il faut plus que 5v pour 'pousser' ce particular FET² jusqu’à passer les 46A – plutôt 10V. Les sorties Arduino nous 'fournissent' seulement 5V au niveau 'high’… Comment faire si on a vraiment besoin de faire un interrupteur de puissance $200 V$ / $46 A$ (cela fait un peu plus que 9kW quand même) ?

Facile – vous ne voyez pas ? Allez, réfléchissez un peu…

Et si on faisait 'piloter' le FET avec un transistor en mode interrupteur ? :

Pilotage d'un FET par un bipolaire — Pilotage d’un FET par un bipolaire

Alors, à vous de travailler un peu :

Q : Quel est le type du transistor Q1 ?³

Q : Comment calculer la valeur pour R2 ?⁴

Q : Comment calculer la valeur pour R1 ?⁵

Q : Quel est l’inconvénient de ce montage (car il en a un) ?⁶

Fonctionnement

Quand la sortie de l’Arduino est à 5V, un courant traverse R1, le transistor Q1 est en conduction et le Gate du FET est tiré à 0V. Pas de conduction (courant S-D à travers le FET) : la charge est donc éteinte.

Quand le niveau à l’entrée se trouve à 0V, Q1 n’est plus en conduction et le Gate est tiré vers 12V à travers R2 : le FET est on conduction 'plein gaz’.

Réponses :

¹ Ex. une des deux / quatre bobines d’un moteur pas-a-pas ² cad l’IRFP260. Il existent les FETs qui rentre en conduction totale avec VGS à 5V ³ Regarder le sens de la flèche : NPN ⁴ Il faut 'laisser passer' assez de courant pour bien ramener le gate du FET à 0V : disons 100mA ⁵ Exactement comme avant : chute de tension pour limiter le courant IBE ⁶ L’inversion des commandes : le FET est 'allumé' quand la sortie Arduino est à 0V

Il est, bien sûr, possible d’annuler cette 'inversion' en ajoutant un deuxième transistor devant Q1, mais cela coûte plus cher que d’inverser la logique de sortie de l’Arduino…

Merci à Glenn Smith pour ce cours !

Non, ce n’est pas un chiffre sorti par magie : soit on lit les données fabricant ; soit on la mesure avec un ohm-mètre !↩

Arduinomètre, troisième partie

Arduino thermomètre avec diode pour sonde

Troisième partie

Nous avons maintenant la base fonctionnelle pour créer plusieurs types d’appareils. Je vais vous donner quelques pistes, quelques idées de réalisations complètes, mais c’est l’opportunité pour vous de laisser votre imagination et votre créativité vous guider.

Coté Arduino on commence à être équipé pour attaquer la programmation. Avec l’appel et l’écriture des fonctions, et les libraries (bibliothèques) nous allons avancer à grands pas.

Couper le cordon

Jusqu’à maintenant les dialogues avec l’Arduino se faisaient par la liaison série (le cordon USB). Il est temps de s’affranchir de cette liaison, de couper le cordon et de rendre notre montage autonome. Deux soucis se présentent à nous : a) comment alimenter l’Arduinomètre ? b) comment afficher la température ?

Alimentation

Si on coupe le cordon, l’Arduino n’est plus alimenté - car s’est notre ordinateur qui l’alimentait à travers la prise USB. Plusieurs solutions sont possibles. Une simple c’est une petite alimentation secteur 5v équipée avec une prise USB (type chargeur de téléphone) : brancher le câble USB bleu et hop ! L’Arduino s’allume.

D’autres solutions :

une alimentation universelle, à brancher sur la prise d’alimentation de l’Arduino. Dans ce cas veillez bien à ce que la tension en sortie de l’alimentation ne dépasse pas 12V ;
pile ou accumulateur : à partir d’une tension de 7V, jusqu’à 12V. À brancher aussi sur la prise d’alimentation de l’Arduino.

En tout cas l’Arduinomètre dans l’état actuel n’est pas du tout gourmand en électricité et la solution pile est très pratique. Une pile 9V fera l’affaire.

Je ne vois rien…

Et oui, comment lire la température maintenant qu’il n’y a plus la liaison série ? C’est maintenant que les choses deviennent intéressantes, car vous pouvez laisser libre cours à votre imagination pour un système d’affichage vraiment personnalisé. Regardons quelques solutions ensemble.

Affichage LCD

Les afficheurs LCD deviennent assez abordables, et ont l’intérêt d’être relativement normalisés. Le logiciel de développement de l’Arduino est fourni avec une bibliothèque standard, LiquidCrystal, qui prend en charge ces afficheurs en nous épargnant la complexité de leur protocole de communication. Avec un tel afficheur nous pouvions afficher au moins 2 lignes de 16 symboles : largement assez pour afficher la température ! Voici un montage exemple sur notre platine d’expérimentation Fritzing :

Schéma électronique de l’écran LCD

Si votre afficheur LCD n’est pas déjà équipé, il faut ajouter un jeu de broches pour faciliter le branchement sur la platine :

Ça commence à faire beaucoup de fils à brancher, mais avec un peu d’ordre et de méthode (comme disait Hercule Poirot) ce n’est pas trop compliqué. Ce montage exemple est simplifié au maximum. Je n’ai pas branché les deux broches du rétro-éclairage à LEDs (broches 15 et 16). Pour la grande majorité des afficheurs vendus actuellement les résistances pour ces LEDs sont déjà montées dans l’afficheur - vous n’avez qu’à brancher le 0V et +5V. Si vous avez récupéré l’afficheur il faut trouver la documentation ou regarder de près afin de voir si les résistances sont présentes ou non. Notez que l’utilisation du rétro-éclairage n’est pas trop compatible avec une alimentation par petite pile 9v (consommation accrue).

Pour tester ce montage il va nous falloir un Sketch (programme). Voici un exemple :

/*
  Montage pour faire un thermomètre avec une diode pour sonde
  Troisième partie : thermomètre fonctionelle.
  La diode est montée en sens 'conduction' (cathode branche sur GND)
  avec une résistance fixe de 4.7k et une résistance variable de
  préférence de 10k en serie.
  
  Il faut d'abord régler le montage pour que le résultat de analogRead();
  donne 558 (environ 600mV) a 20°C (Sketch "Diode_Thermo_1") -OU-
  calibrer le montage avec deux températures connus.
  
  Ne plus toucher le potentiomètre après !
  
  Cette version avec afficheur LCD branché en mode 4-bits comme suite :
  
  LCD    Arduino    Libellé
  ===============================================================
    1      -        Ov / GND
    2      -        +5v
    3      -        Contraste
    4      2        RS (register select)
    5      -        RW (read / write) Branché sur 0v
    6      3        E  (enable)
   11      4        D4 (données bit 4)
   12      5        D5 (données bit 5)
   13      6        D6 (données bit 6)
   14      7        D7 (données bit 7)
  
  Avril 2014 MOOC Fabrication Numérique

*/
// Bibliothèques
#include <LiquidCrystal.h>

// Définition des broches
#define Diode A0  // forward biased diode w/10K R to Vcc
// Brochage LCD
#define LCD_rs 2
#define LCD_enable 3
#define LCD_d4 4
#define LCD_d5 5
#define LCD_d6 6
#define LCD_d7 7

// variables:
int DiodeValue = 0;    // for the diode
int Temperature = 0; // Brrrrr
float Result = 0.0;  // for calculations 

// Déclarer notre afficheur LCD
  LiquidCrystal lcd(LCD_rs, LCD_enable, LCD_d4, LCD_d5, LCD_d6, LCD_d7);

void setup() {
  // Réference max. pour l'ADC = 1,1v
  analogReference(INTERNAL);
  // Démarrer l'affichage
  lcd.begin(16, 2);
  lcd.print("Arduinometre");  
}

void loop() {
  DiodeValue = analogRead(Diode); // Lire la valeur
  Result = DiodeValue * 1.075; // Convertir en mV
  // effacer la deuxième ligne
  lcd.setCursor(0, 1);
  lcd.print("                ");  
  lcd.setCursor(0, 1);
  // afficher les valeurs
  lcd.print(Result);
  lcd.print("mV ");
  Temperature = map(DiodeValue, 595, 409, 0, 100);  // Traduire valeur en degrés C
  lcd.print("(");
  lcd.print(Temperature);
  lcd.write(0xdf);  // Le symbole "°"
  lcd.print("C)");
  delay(10000);  // Attente 10s
}

Arduinomètre avec écran LCD

Vous avez peut-être remarqué que l’afficheur par défaut n’affiche que les caractères sans accents. Si vous voulez ajouter des symboles supplémentaires ( "é" et "è", par exemple ) il faut ajouter des appels à createChar(); pour définir vos symboles. Pour plus d’information sur l’utilisation des fonctions fournies par la bibliothèque LiquidCrystal, et l’utilisation de createChar(); se référer à la page chez "mon-club-elec" ici. J’ajouterai un article Wiki dédié à ce sujet ultérieurement.

Notre montage ressemble à un vrai thermomètre maintenant !

Avertisseur

Notre Arduinomètre est désormais autonome et nous affiche la température. Mais (surtout sans rétro-éclairage) il faut se pencher dessus pour voir la T°. Et si on ajoutait un avertissement par LED ? LED verte = température dans la plage souhaitée ; LED rouge = trop basse ou trop élevée. J’espère que je n’ai plus besoin de dessiner comment brancher les LEDs (avec les résistances en série, bien sûr). On peut utiliser les broches 8 et 9 de l’Arduino comme sorties pour les LEDs. Il va falloir ajouter quelques bouts de code supplémentaires dans le Sketch :

Déclarations :

#define LED_Rouge 8#define LED_Verte 9
// constantes:
const int seuilBas = 15;   // Seuil d'erreur bas
const int seuilHaute = 25; // Seuil d'erreur haut

Déclaration d’une procédure à nous

(à ajouter après la } à la fin du loop() ou avant setup() )

void avertissement() {
 if ((Temperature > seuilHaut) || (Temperature < seuilBas)) {
    digitalWrite(LED_Rouge, HIGH);
    digitalWrite(LED_Verte, LOW);
  }
  else {
   digitalWrite(LED_Rouge, LOW);
   digitalWrite(LED_Verte, HIGH);
  }
}

Corps du code : (quelque part dans le `loop()` )

// T° bien ?
avertissement();

Exemple complet :

/*
  Montage pour faire un thermomètre avec une diode pour sonde
  Troisième partie : thermomètre fonctionelle.
  La diode est montée en sens 'conduction' (cathode branche sur GND)
  avec une résistance fixe de 4.7k et une résistance variable de
  préférence de 10k en serie.
  
  Il faut d'abord régler le montage pour que le résultat de analogRead();
  donne 558 (environ 600mV) a 20°C (Sketch "Diode_Thermo_1") -OU-
  calibrer le montage avec deux températures connus.
  
  Ne plus toucher le potentiomètre après !
  
  Cette version avec afficheur LCD branché en mode 4-bits comme suite :
  
  LCD    Arduino    Libellé
  ===============================================================
    1      -        Ov / GND
    2      -        +5v
    3      -        Contraste
    4      2        RS (register select)
    5      -        RW (read / write) Branché sur 0v
    6      3        E  (enable)
   11      4        D4 (données bit 4)
   12      5        D5 (données bit 5)
   13      6        D6 (données bit 6)
   14      7        D7 (données bit 7)
  
  ... et deux LEDs pour avertissement.
  
  Avril 2014 MOOC Fabrication Numérique

*/
// Bibliothèques
#include <LiquidCrystal.h>

// Définition des broches
#define Diode A0  // forward biased diode w/10K R to Vcc
#define LED_Rouge 8
#define LED_Verte 9

// Brochage LCD
#define LCD_rs 2
#define LCD_enable 3
#define LCD_d4 4
#define LCD_d5 5
#define LCD_d6 6
#define LCD_d7 7

// constantes:
const int seuilBas = 15;  // Seuil d'erreur bas
const int seuilHaute = 25;  // Seuil d'erreur haute 

// variables:
int DiodeValue = 0;    // for the diode
int Temperature = 0; // Brrrrr
float Result = 0.0;  // for calculations 

// Déclarer notre afficheur LCD (et création de l'objet "lcd" de type LiquidCrystal)
  LiquidCrystal lcd(LCD_rs, LCD_enable, LCD_d4, LCD_d5, LCD_d6, LCD_d7);

void setup() {
  pinMode(LED_Rouge, OUTPUT);     
  pinMode(LED_Verte, OUTPUT);     
  digitalWrite(LED_Rouge, LOW); 
  digitalWrite(LED_Verte, LOW); 

  // Réference max. pour l'ADC = 1,1v
  analogReference(INTERNAL);  // Arduino UNO et autres

  // Démarrer l'affichage
  lcd.begin(16, 2);  // Obligatoire pour démarrer
  lcd.print("Arduinometre");
}

void loop() {
  DiodeValue = analogRead(Diode); // Lire la valeur
  Result = DiodeValue * 1.075; // Convertir en mV
  Temperature = map(DiodeValue, 595, 409, 0, 100);  // Convertir en degrés C
  // T° bien ?
  avertissement();
 
  // effacer la deuxième ligne
  lcd.setCursor(0, 1);
  lcd.print("                ");  
  lcd.setCursor(0, 1);

  // afficher les valeurs
  lcd.print(Result);
  lcd.print("mV ");
  lcd.print("(");
  lcd.print(Temperature);
  lcd.write(0xdf);  // Le symbole "°"
  lcd.print("C)");
    
  delay(10000);  // Attente 10s
}

void avertissement() {
  if ((Temperature > seuilHaute) || (Temperature < seuilBas)) {
    digitalWrite(LED_Rouge, HIGH); 
    digitalWrite(LED_Verte, LOW);
  } 
  else {
  digitalWrite(LED_Rouge, LOW); 
  digitalWrite(LED_Verte, HIGH);
  }
}

Exemple compte de l’Arduinomètre

Idées

Encore quelques idées à essayer

Utiliser une ligne de LEDs pour afficher la température (comme l’affichage du niveau du son sur certains magnétophones…(vous souvenez-vous des magnétophones ?) ;
Ajout d’une deuxième diode sonde pour faire thermomètre intérieur / extérieur (mais lire l’article Wiki sur la sonde LM35 : quelques informations sur la lecture de plusieurs sources analogiques simultanées);
Au lieu d’un avertissement (ou en supplément), faire actionner une sortie numérique pour piloter un relais : l’Arduinomètre devient Arduinostat.
faire un thermomètre à cadran : prendre un servomoteur, y fixer une aiguille et faire tourner l’aiguille sur une échelle graduée. Si votre servomoteur a une plage de fonctionnement limitée, utiliser la technique des seuils : réserver un espace 'rouge' 5° en bas et 5° en haut du cadran et utiliser le reste de la plage pour afficher la température 'normale' ;
Vos idées ici…