Utilizzo di un termometro a infrarossi Melexis MLX90614 con un Arduino LCD1602

Utilizzo di un termometro a infrarossi Melexis MLX90614 con un Arduino LCD1602

Questo progetto è perfetto per un'ampia gamma di applicazioni, come ad esempio:

• Costruire una stazione di screening della febbre senza contatto per l'ingresso di una clinica o di un ufficio.
• Monitorare la temperatura del piano o dell'hot-end di una stampante 3D senza interferire con la stampa.
• Creare un controllore di temperatura degli alimenti sicuro e senza contatto per cucinare o produrre birra.
• Sviluppare un semplice rilevatore di presenza umana misurando le firme di calore corporeo.
• Controllare la temperatura di parti meccaniche in movimento o quadri elettrici a distanza di sicurezza.

Il sensore MLX90614 comunica tramite il protocollo I2C, il che significa che richiede solo due pin dati (SDA e SCL) oltre a alimentazione e massa. Questo rende il cablaggio semplice e lascia molti pin liberi per altri componenti. Alla fine di questo tutorial, avrai un display di temperatura funzionante in grado di mostrare letture in Celsius, Fahrenheit o Kelvin, e capirai come personalizzare il codice per le tue esigenze specifiche.

Hardware Richiesto

Per costruire questo progetto, avrai bisogno dei seguenti componenti:

• Scheda Arduino (Uno, Nano, Mega, ecc.)
• Modulo sensore di temperatura a infrarossi MLX90614
• Display LCD I2C (16x2 o 20x4 caratteri)
• Cavi jumper
• Breadboard (opzionale, per collegamenti più facili)

Guida al Cablaggio

Il cablaggio per questo progetto è semplice perché sia il sensore MLX90614 che il display LCD utilizzano il protocollo di comunicazione I2C. Ciò significa che possono condividere le stesse due linee dati (SDA e SCL), che sono collegate in parallelo. Il sensore opera a logica 3.3V, ma può essere alimentato dall'uscita 3.3V dell'Arduino. Il modulo LCD, tuttavia, richiede tipicamente 5V per la retroilluminazione e la logica (nel video a 03:15).

Ecco la suddivisione dei collegamenti:

• MLX90614 VCC → Arduino 3.3V
• MLX90614 GND → Arduino GND
• MLX90614 SCL → Arduino A5 (SCL)
• MLX90614 SDA → Arduino A4 (SDA)
• LCD VCC → Arduino 5V
• LCD GND → Arduino GND
• LCD SCL → Arduino A5 (SCL)
• LCD SDA → Arduino A4 (SDA)

Poiché I2C è un protocollo a bus, puoi collegare fino a 128 dispositivi sulle stesse due linee (nel video a 03:44). Se stai usando un Arduino Uno o Nano, i pin SDA e SCL si trovano rispettivamente su A4 e A5. Per altre schede come il Mega, questi pin si trovano in posizioni diverse (20 e 21), quindi assicurati di controllare la piedinatura della tua scheda.

Configurazione delle Librerie

Prima di caricare il codice, devi installare due librerie essenziali. La prima è la libreria Adafruit MLX90614, che gestisce la comunicazione con il sensore di temperatura. La seconda è la libreria LiquidCrystal I2C, che semplifica il controllo del display LCD tramite il bus I2C. Queste librerie possono essere installate tramite il Gestore Librerie di Arduino cercando i loro nomi.

Dopo aver installato le librerie, devi determinare gli indirizzi I2C dei tuoi dispositivi collegati. Questo è un passaggio critico perché sia il sensore che il display hanno i propri indirizzi unici. Il codice fornito include uno speciale schizzo "I2C Scanner" che puoi caricare sul tuo Arduino per trovare questi indirizzi. Quando esegui lo scanner con entrambi i dispositivi collegati, stamperà due indirizzi sul Monitor Seriale. Nel video, il display LCD è stato trovato a 0x3F e il sensore MLX90614 a 0x5A (nel video a 06:28). I tuoi dispositivi potrebbero avere indirizzi diversi, quindi è essenziale eseguire lo scanner e annotare i valori.

Spiegazione del Codice

Il codice è progettato per essere flessibile, consentendoti di personalizzare facilmente quali unità di temperatura visualizzare e come presentare le informazioni sul display LCD. Ecco le parti chiave del codice configurabili dall'utente (nel video a 04:31):

Configurazione LCD

All'inizio del codice, troverai le impostazioni per il tuo specifico display LCD. Devi regolare questi valori per adattarli al tuo hardware:

const uint8_t I2C_ADDRESS = 0x3f;  // Indirizzo I2C del tuo LCD
const uint8_t LCD_CHAR = 16;       // Numero di caratteri per riga (16 o 20)
const uint8_t LCD_ROW = 2;         // Numero di righe sul display (2 o 4)

Cambia I2C_ADDRESS con l'indirizzo che hai trovato usando lo scanner I2C. Se stai usando un LCD 20x4, imposta LCD_CHAR a 20 e LCD_ROW a 4.

Visualizzazione delle Unità di Temperatura

Il codice utilizza un sistema intelligente di lettere per rappresentare diverse letture di temperatura. La funzione principale printTemp('X') accetta un singolo argomento carattere per determinare cosa visualizzare. La mappatura è la seguente:

• 'C' - Temperatura dell'oggetto in Celsius
• 'D' - Temperatura ambiente in Celsius
• 'F' - Temperatura dell'oggetto in Fahrenheit
• 'G' - Temperatura ambiente in Fahrenheit
• 'K' - Temperatura dell'oggetto in Kelvin
• 'L' - Temperatura ambiente in Kelvin

Nella funzione loop(), puoi scegliere quali letture visualizzare decommentando le righe che ti servono. Ad esempio, per mostrare solo le letture in Celsius sia per la temperatura dell'oggetto che per quella ambiente, il tuo loop sarà così:

void loop() {
  printTemp('C'); // temperatura dell'oggetto in C
  delay(2000);
  printTemp('D'); // temperatura ambiente in C
  delay(2000);
}

Se vuoi visualizzare sia Fahrenheit che Celsius, basta decommentare le righe aggiuntive. Il ritardo di 2000 millisecondi (2 secondi) tra le letture ti dà il tempo di leggere il display.

Personalizzazione delle etichette di visualizzazione

Puoi cambiare le etichette di testo che appaiono sul LCD. L'array typeName[] contiene le etichette per le temperature dell'oggetto e ambiente:

char *typeName[]={"Oggetto:","Ambiente:"};

Puoi modificare queste stringhe per visualizzare il testo nella tua lingua preferita, purché usi caratteri latini (nel video a 05:08).

Aggiunta di azioni condizionali

Il codice include anche una funzione utile getTemp('X') che restituisce la temperatura come numero a virgola mobile. Questo ti permette di eseguire azioni basate su soglie di temperatura. Ad esempio, potresti attivare un relè o un cicalino se la temperatura supera un certo valore:

if( getTemp('C') > 40)
{
  // fai qualcosa qui, come attivare un relè o un cicalino
}

Questo è particolarmente utile per creare sistemi di allarme o risposte automatiche ai cambiamenti di temperatura.

Dimostrazione

Una volta caricato il codice e verificato il cablaggio, il LCD inizierà a visualizzare le letture di temperatura. Nella dimostrazione, il sensore è stato puntato verso diversi oggetti per mostrare come risponde. Quando puntato sulla fronte di una persona, il sensore ha misurato una temperatura corporea intorno ai 33-34°C (nel video a 09:39). Quando puntato su una superficie più fredda, le letture sono scese a circa 26°C per l'oggetto e 28°C per la temperatura ambiente (nel video a 09:52).

Il sensore è abbastanza stabile e fornisce letture costanti. Il video dimostra anche come modificare il codice per visualizzare solo le letture in Celsius commentando le righe per Fahrenheit e Kelvin. Questo si fa selezionando le righe e usando la funzione di commento dell'IDE Arduino (Ctrl+/ o Cmd+/), che aggiunge doppie barre (//) all'inizio di ogni riga.

Per impostazione predefinita, il codice visualizza le letture in Celsius sia per l'oggetto che per la temperatura ambiente. Puoi facilmente passare a Fahrenheit o Kelvin decommentando le righe appropriate nella funzione loop(). Il LCD alternerà quindi tra le letture dell'oggetto e quelle ambiente ogni due secondi.

Capitoli

• [00:00] Introduzione al progetto MLX90614 con LCD
• [01:20] Opzioni di display: LCD2004 e LCD1602
• [02:29] Cablaggio spiegato
• [04:28] Codice spiegato
• [04:53] Trovare gli indirizzi I2C
• [08:35] Dimostrazione
• [10:47] Osservazioni finali e crediti

Immagini

MLX90614 LCD wiring

MLX90614 4

MLX90614 3

MLX90614 2

MLX90614 1 ESF

MLX90614 LCD wiring

MLX90614 4

MLX90614 3

MLX90614 2

MLX90614 1 ESF

++
/*************************************************** 
  This is a library example for the MLX90614 Infrared Temperature Sensor with LCD1602 
Original Library and code source: https://github.com/adafruit/Adafruit-MLX90614-Library

This code has been mostly updated.
It displays the temperature on LCD1602 or LCD2004 in C, F, and K for object and for ambient.

 * 
 * Watch video instructions for this code:  https://youtu.be/_iO2L4P_irw
Updated/written by Ahmad Shamshiri on June 28, 2020 
 
 * in Ajax, Ontario, Canada. www.robojax.com

Introduction to MLX90614 Infrared Temperature Sensor: https://youtu.be/cFDSqiEIunw

 * Get this code and other Arduino codes from Robojax.com
Learn Arduino step by step in a structured course with all material, wiring diagrams, and libraries
all in one place. Purchase My course on Udemy.com http://robojax.com/L/?id=62

If you found this tutorial helpful, please support me so I can continue creating 
content like this. 

or make a donation using PayPal http://robojax.com/L/?id=64

 *  * This code is "AS IS" without warranty or liability. Free to be used as long as you keep this note intact.* 
 * This code has been downloaded from Robojax.com
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

Origin
  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include <Wire.h>
#include <Adafruit_MLX90614.h>
char *typeName[]={"Object:","Ambient:"};

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

#include <LiquidCrystal_I2C.h>
const uint8_t I2C_ADDRESS =0x3f;
const uint8_t LCD_CHAR= 16;
const uint8_t LCD_ROW= 2;
LiquidCrystal_I2C lcd(I2C_ADDRESS, LCD_CHAR,LCD_ROW);


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

  Serial.println("Robojax MLX90614 test");  

   if (!mlx.begin()) //Begin returns 0 on a good init
  {
      lcd.print("MLX90614 Failed");
      lcd.setCursor(0,1);
      lcd.print("check wiring!");      
    while (1)
      ;
  }  
  Wire.begin();
  lcd.begin();
  lcd.backlight();  
      lcd.print("Robojax MLX90614");
      lcd.setCursor(0,1);
      lcd.print("Infrared Temp.");          
      delay(2000);       
      clearCharacters(LCD_ROW-1,0, LCD_CHAR-1);
       
  
}//setup() end

void loop() {
  //Robojax Example for MLX90614 with LCD
  printTemp('C');//object temperature in C
  delay(2000);
  
  printTemp('D');//ambient temperature in C
  delay(2000);
//    
//  printTemp('F'); //object temperature in F
//  delay(2000);
//     
//  printTemp('G'); //ambient temperature in F
//  delay(2000);  
//  if( getTemp('C')>40)
//  {
//    //do something here
//  }
//  
//  printTemp('K'); //object temperature in K
//  delay(2000);    
//  printTemp('L');//ambient temperature in K  
//  delay(2000);  


  //Robojax Example for MLX90614
}

/*
 * @brief returns temperature or relative humidity
 * @param "type" is a character
 *     C = Object Celsius
 *     D = Ambient Celsius
 *     
 *     K = Object Kelvin
 *     L = Ambient Kelvin
 *     
 *     F = Object Fahrenheit
 *     G = Ambient Fahrenheit

 * @return returns one of the values above
 * Usage: to get Fahrenheit type: getTemp('F')
 * to print it on serial monitor Serial.println(getTemp('F'));
 * Written by Ahmad Shamshiri on March 30, 2020. 
 * in Ajax, Ontario, Canada
 * www.Robojax.com 
 */
float getTemp(char type)
{
   // Robojax.com MLX90614 Code
  float value;
    float tempObjec = mlx.readObjectTempC();//in C object
    float tempAmbient = mlx.readAmbientTempC();
   if(type =='F')
   {
    value = mlx.readObjectTempF(); //Fahrenheit Object
   }else if(type =='G')
   {
    value = mlx.readAmbientTempF();//Fahrenheit Ambient
   }else if(type =='K')
   {
    value = tempObjec + 273.15;// Object Kelvin
   }else if(type =='L')
   {
    value = tempAmbient + 273.15;//Ambient Kelvin
   }else if(type =='C')
   {
    value = tempObjec;
   }else if(type =='D')
   {
    value = tempAmbient;
   }
   return value;
    // Robojax.com MLX90614 Code
}//getTemp

/*
 * @brief nothing
 * @param "type" is a character
 *     C = Object Celsius
 *     D = Ambient Celsius
 *     
 *     K = Object Kelvin
 *     L = Ambient Kelvin
 *     
 *     F = Object Fahrenheit
 *     G = Ambient Fahrenheit

 * @return prints temperature value in serial monitor
 * Usage: to get Fahrenheit type: getTemp('F')
 * to print it on serial monitor Serial.println(getTemp('F'));
 * Written by Ahmad Shamshiri on March 30, 2020 at 21:51
 * in Ajax, Ontario, Canada
 * www.Robojax.com 
 */
void printTemp(char type)
{
 clearCharacters(1,0, LCD_CHAR-1 );  
  // Robojax.com MLX90614 Code
  float tmp =getTemp(type);
      lcd.setCursor(0,1);
      
  if(type =='C')
  {

      lcd.print(typeName[0]);  
      lcd.print(" ");
      lcd.print(tmp);        
      lcd.print((char)223);// 
      lcd.print("C");      
              

  }else if(type =='D')
  {
      lcd.print(typeName[1]); 
      lcd.print(" ");
      lcd.print(tmp);        
      lcd.print((char)223);// 
      lcd.print("C");        
  }else if(type =='F')
  {
      lcd.print(typeName[0]); 
      lcd.print(" ");
      lcd.print(tmp);        
      lcd.print((char)223);// 
      lcd.print("F");        
  }else if(type =='G')
  {
      lcd.print(typeName[1]);
      lcd.print(" ");
      lcd.print(tmp);        
      lcd.print((char)223);// 
      lcd.print("F");        
  }

  else if(type =='K')
  {
      lcd.print(typeName[0]); 
      lcd.print(" ");
      lcd.print(tmp);        
      lcd.print((char)223);// 
      lcd.print("K");        
  }  
  else if(type =='L')
  {
      lcd.print(typeName[1]);
      lcd.print(" ");
      lcd.print(tmp);        
      lcd.print((char)223);// 
      lcd.print("K");        

  }

// Robojax.com MLX90614 Code
}//printTemp(char type)


/*
   clearCharacters(uint8_t row,uint8_t start, uint8_t stop)
 * @brief clears a line of display (erases all characters)
 * @param none
 * @return does not return anything
 * Written by Ahmad Shamshiri
 * www.Robojax.com code May 28, 2020 at 16:21 in Ajax, Ontario, Canada
 */
void clearCharacters(uint8_t row,uint8_t start, uint8_t stop )
{
    for (int i=start; i<=stop; i++)
    {
    lcd.setCursor (i,row); //  
    lcd.write(254);
    } 

}//clearCharacters