LM75 / CJMCU-75 Sensore di temperatura per Arduino

LM75, noto anche come CJMCU-75, è un versatile modulo sensore di temperatura digitale con supporto I2C. Offre un monitoraggio preciso della temperatura e fornisce letture della temperatura sia in unità Celsius che Fahrenheit.
Lettura temperature da -55 a +125 °C, risoluzione 0.125 °C, accuratezza della misura ±3°C.

Indice

Descrizione

Il sensore LM75, conosciuto anche come CJMCU-75, è un versatile modulo sensore di temperatura che permette la sua misurazione in un range compreso tra -55°C a +125°C.
Fornisce letture della temperatura sia in gradi Celsius che Fahrenheit.
Funziona con una tensione di alimentazione compresa tra 2,7 V e 5,5 V, rendendolo compatibile con schede controller diffuse come Arduino, ESP8266 ed ESP32. I dati sono trasmessi su bus I2C.

Caratteristiche

Lo schema a blocchi del sensore LM75 (datasheet) è riportato nella figura 1

La piedinatura del sensore LM75 invece riportata nella Figura 2:

Simbolo	Pin	Descrizione
SDA	1	I/O digitale. Linea dati bidirezionale seriale del bus I2C; open-drain.
SCL	2	Ingresso digitale. Ingresso del clock seriale del bus I2C.
OS	3	Uscita di spegnimento per sovratemperatura; open-drain.
GND	4	Massa. Da collegare alla massa del sistema.
A2	5	Ingresso digitale. Bit di indirizzo 2 definito dall'utente.
A1	6	Ingresso digitale. Bit di indirizzo 1 definito dall'utente.
A0	7	Ingresso digitale. Bit di indirizzo 0 definito dall'utente.
VCC	8	Alimentazione.

Funzionamento Interno

Rilevamento della Temperatura: Il LM75 utilizza il suo sensore di temperatura interno per monitorare continuamente la temperatura ambiente.

Interfaccia I2C: Comunica i dati di temperatura a un host esterno, tipicamente un MCU, attraverso l’interfaccia I2C. L’host può richiedere letture della temperatura dal LM75 in qualsiasi momento.

Rilevamento del Sovraccarico Termico: Il LM75 include un limite di temperatura programmabile. Quando la temperatura supera questo limite, l’uscita open-drain di sovraccarico termico (OS) viene attivata. Questa uscita può assorbire corrente, avvisando l’host della condizione di sovraccarico termico.

Modalità di Funzionamento: L’uscita OS può operare in due modalità: comparatore e interruzione. Nella modalità comparatore, l’host imposta una soglia di temperatura (TOS) e quando la temperatura supera questa soglia, l’uscita OS viene attivata. Nella modalità interruzione, l’uscita OS funziona come un pin di interruzione, segnalando all’host quando la temperatura supera TOS.

Controllo dell’Isteresi: L’host può anche controllare la temperatura di isteresi (THYST), che definisce la temperatura a cui la condizione di allarme è considerata non valida. Questo impedisce il commutarsi frequente del segnale di allarme vicino alla soglia.

Configurazione dell’Indirizzo: Il LM75 utilizza tre pin per impostare il suo indirizzo, consentendo a più dispositivi LM75 di operare sullo stesso bus I2C senza conflitti.

Schema elettrico del modulo CJMCU-75

Lo schema del modulo sensore di temperatura LM75 è riportato sotto.
Sul connettore J1, sono presenti i pin :

VCC, GND di alimentazione
SDA e SCL per la comunicazione
OS, che funziona come allarme di temperatura.

Troviamo poi un condensatore tra VCC e GND e un resistore di protezione con LED. Vi sono 3 resistori di pull-up da 10K su SCL ed SDA e uno da 200K su O.S.

Sono poi presenti 3 piazzole: A0, A1 ed A2 per la determinazione dei pin di indirizzo, quindi possiamo avere sino a 8 diversi lm75 connessi ad un microcontrollore e attivarli uno per volta.

Versioni del sensore LM75

In vendita esistono moduli che possono montare versioni del sensore diverse, LM75A o LM75B.
Sotto le differenze trovate su un forum della Texas Instruments

LM75A ha un registro di ID prodotto – LM75B non lo supporta.
LM75A ha una valutazione di ESD (Electrostatic Discharge) – LM75B non è valutato per ESD.
La tensione massima assoluta di LM75A è 6V – LM75B è 6.5V.
LM75A supporta un intervallo di alimentazione da 2.7V a 5.5V – LM75B supporta un intervallo da 3.6V a 5.5V.
Quando si legge un registro a 16 bit per LM75A, i 7 bit inferiori non utilizzati segnalano “0” – per LM75B i 3 bit inferiori non utilizzati sono zeri e i successivi 4 bit sono leggibili/scrivibili.
Il comportamento della coda di errore per LM75A si imposta dopo n eventi di sovratemperatura dove n = 1, 2, 4, 6 e si reimposta dopo n eventi di sotto temperatura – LM75B si imposta dopo n eventi di sovratemperatura dove n = 1, 2, 4, 6 e si reimposta dopo 1 evento di sotto temperatura.
LM75A è più è stato rilasciato nel febbraio 2009 – LM75B è stato rilasciato nel settembre 2002.

Riassunto delle caratteristiche del sensore LM75

Tensione di funzionamento:	3,3 Volt – 5,0 Volt
Intervallo di temperatura:	-55°C – 125°C
Risoluzione:	0,125°C
Precisione:	±3°C
Tempo di conversione della temperatura:	100ms
Corrente di alimentazione:	250µA
Corrente massima di alimentazione:	1mA
OS Sink Current:	10mA
Risoluzione Delta-sigma:	8 bit
Temperatura TOS:	80°C
Temperatura THYST:	75°C

Indirizzo I2C

Come indicato nello schema elettrico, nella parte posteriore del PCB sono presenti 3 gruppi di piazzole denominate A0, A1 e A2, che permettono al sensore LM75 di modificare l’indirizzo I2C.

Questo consente di collegare sino ad un massimo di otto dispositivi LM75 sullo stesso bus a 2 fili I2C, semplificando il monitoraggio e il controllo centralizzato della temperatura in sistemi complessi.
Per questo è possibile cortocircuitare uno qualsiasi di questi pin di indirizzo con VCC o massa.
Sotto la tabella dei possibili indirizzi, quello di default è 0x48.

LM75 CJMCU-75 Sensore di temperatura - indirizzi I2C

A0	A1	A2	Address
GND	GND	GND	0x48
VCC	GND	GND	0x49
GND	VCC	GND	0x4A
VCC	VCC	GND	0x4B
GND	GND	VCC	0x4C
VCC	GND	VCC	0x4D
GND	VCC	VCC	0x4E
VCC	VCC	VCC	0x4F

Comparazione con altri sensori

Il sensore LM75 si può trovare in varie versioni, sotto alcuni esempi

Dove trovare il modulo LM75 o CJMCU-75

Il sensore LM75 potrà essere acquistato online presso questi link

Il modulo è inviato all’interno di una busta antistatica, contenente anche un pin-strip maschio che deve essere saldato a vostra cura.

Test base del modulo sensore LM75 con Arduino

Nell’esempio proposto sarà possibile visualizzare i dati letti dal sensore LM75 su un display OLED in questo caso un OLED da 0.96 ” con una risoluzione di 128×64 pixel, che sfrutta il driver SSD1306 e si interfaccia tramite la connessioni I2C.
Per informazioni sul modulo display vedere l’articolo Display bicolore OLED 0.96″ 128×64 – SSD1306

Materiale occorrente


Arduino UNO o suo clone	CJMCU-75 (Sensore di temperatura I2C)

OLED da 0.96 ” 128×64 pixel	Cavi colorati M/M

Bread board

Schema dei collegamenti

I collegamenti sono mostrati nella figura sottostante.

Arduino	CJMCU-75	SSD1306 OLED	Colore cavo
5V	VCC	VCC	rosso
GND	GND	GND	nero
A4	SDA	SDA	giallo
A5	SCL	SCL	bianco
N.C.	OS

Libreria di gestione per il display OLED

Per utilizzare il display OLED è necessario installare l’apposita libreria. Può essere cercata tra le librerie installabili nell’IDE, basterà inserire nel campo di ricerca “Adafruit_SSD1306“.
Sarà anche mostrata una finestra che segnala che la libreria ha una dipendenza con la libreria grafica “Adafruit GFX Library“. Procedete premendo su “Install all”.
Per altre informazioni su come installare le librerie vedete l’articolo Arduino – Tutorial, come installare una libreria

Programma per lettura dati da LM75 su display

Il programma proposto non utilizza una specifica libreria per la gestione del sensore, ma effettua la lettura e manipolazione dei dati all’interno del programma.

Spiegazione del codice

Caricamento librerie
Vengono caricare le tre librerie : Wire.h, Adafruit_GFX.h, Adafruit_SSD1306.h
Impostazioni
- Viene impostato l’indirizzo del sensore e le dimensioni del display
- Viene creato l’oggetto display
- Viene definita l’icona del termometro da mostrare sul display
Setup e Inizializzazione
- La comunicazione seriale viene inizializzata a 9600 baud.
- La libreria Wire per la comunicazione I2C viene inizializzata.
- Viene inizializzato il display
Loop principale:
- Legge la temperatura dal sensore ogni secondo utilizzando la funzione readCJMCU75Temperature() e la stampa sulla porta seriale.
- Viene aggiornato il display OLED
Funzione readCJMCU75Temperature():
- Inizia la trasmissione I2C verso l’indirizzo del sensore CJMCU-75.
- Invia il comando per leggere i dati dalla posizione di memoria 0x00.
- Riceve 2 byte di dati (MSB e LSB).
- Calcola la temperatura utilizzando la formula specificata nel datasheet del sensore (ogni incremento di 1 nei dati corrisponde a 0,0625 °C).

Nota
Nel caso fosse riportata la scritta “Impossibile trovare il sensore”, controllare che il modulo sia correttamente alimentato o che non siano invertiti i cavi SDA e SCL.
Nel caso sul display non fossero visibili i dati, controllare che il display sia correttamente alimentato o che non siano invertiti i cavi SDA e SCL. Verificare che l’indirizzo del display sia quello indicato nel programma.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define CJMCU_75_ADDRESS 0x48  // Indirizzo I2C del sensore
#define SCREEN_WIDTH 128       // Larghezza del display OLED
#define SCREEN_HEIGHT 64       // Altezza del display OLED

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);  // Creazione oggetto display

// Bitmap 16x32 per il termometro
const unsigned char thermometer_icon[] PROGMEM = {
  0b00000110, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00001111, 0b00000000,
  0b00000110, 0b00000000,
  0b00000000, 0b00000000,
  0b00000110, 0b00000000,
  0b00001101, 0b10000000,
  0b00001111, 0b11000000,
  0b00001111, 0b11000000,
  0b00001111, 0b11000000,
  0b00000111, 0b10000000,
  0b00000011, 0b00000000,
  0b00000011, 0b00000000,
  0b00000011, 0b00000000,
  0b00000011, 0b00000000,
  0b00000011, 0b00000000,
  0b00000011, 0b00000000,
  0b00000001, 0b00000000
};

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

  // Inizializza il display OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("Errore durante l'inizializzazione del display SSD1306");
    while (true)
      ;  // Blocca il programma se il display non è trovato
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("Inizializzazione...");
  display.display();
  delay(2000);
}

void loop() {
  float temperature = readCJMCU75Temperature();

  // Stampa la temperatura su Serial Monitor
  Serial.print("Temperatura: ");
  Serial.print(temperature);
  Serial.println(" °C");

  // Aggiorna il display OLED
    display.clearDisplay();

      // Disegna l'icona del termometro (posizione: X=10, Y=16)
  display.drawBitmap(10, 16, thermometer_icon, 16, 32, SSD1306_WHITE);
  
  display.setTextSize(1);
  display.setCursor(10, 0);
  display.print("Temperatura locale");
  display.setTextSize(2);
  display.setCursor(30, 20);
  display.print(temperature, 1);
  display.print((char)247);
  display.print("C");
  display.setTextSize(1);
  display.setCursor(15, 55);
  display.println("WWW.ADRIROBOT.IT");
  display.display();  // Aggiorna il display
  delay(1000);
}

// Funzione per leggere la temperatura dal CJMCU-75
float readCJMCU75Temperature() {
  Wire.beginTransmission(CJMCU_75_ADDRESS);
  Wire.write(0x00);  // Registro della temperatura
  Wire.endTransmission();

  Wire.requestFrom(CJMCU_75_ADDRESS, 2);
  byte msb = Wire.read();
  byte lsb = Wire.read();

  int tempData = ((msb << 8) | lsb) >> 4;
  float temperature = tempData * 0.0625;  // Conversione in °C

  return temperature;
}

100

101

102

103

104

105

106

107

108

109

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#define CJMCU_75_ADDRESS 0x48 // Indirizzo I2C del sensore

#define SCREEN_WIDTH 128 // Larghezza del display OLED

#define SCREEN_HEIGHT 64 // Altezza del display OLED

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1); // Creazione oggetto display

// Bitmap 16x32 per il termometro

const unsigned char thermometer_icon[] PROGMEM = {

0b00000110, 0b00000000,

0b00001111, 0b00000000,

0b00000110, 0b00000000,

0b00000000, 0b00000000,

0b00000110, 0b00000000,

0b00001101, 0b10000000,

0b00001111, 0b11000000,

0b00000111, 0b10000000,

0b00000011, 0b00000000,

0b00000001, 0b00000000

};

void setup() {

Serial.begin(9600);

Wire.begin();

// Inizializza il display OLED

if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {

Serial.println("Errore durante l'inizializzazione del display SSD1306");

while (true)

; // Blocca il programma se il display non è trovato

}

display.clearDisplay();

display.setTextSize(1);

display.setTextColor(SSD1306_WHITE);

display.setCursor(0, 0);

display.println("Inizializzazione...");

display.display();

delay(2000);

}

void loop() {

float temperature = readCJMCU75Temperature();

// Stampa la temperatura su Serial Monitor

Serial.print("Temperatura: ");

Serial.print(temperature);

Serial.println(" °C");

// Aggiorna il display OLED

display.clearDisplay();

// Disegna l'icona del termometro (posizione: X=10, Y=16)

display.drawBitmap(10, 16, thermometer_icon, 16, 32, SSD1306_WHITE);

display.setTextSize(1);

display.setCursor(10, 0);

display.print("Temperatura locale");

display.setTextSize(2);

display.setCursor(30, 20);

display.print(temperature, 1);

display.print((char)247);

display.print("C");

display.setTextSize(1);

display.setCursor(15, 55);

display.println("WWW.ADRIROBOT.IT");

display.display(); // Aggiorna il display

delay(1000);

}

// Funzione per leggere la temperatura dal CJMCU-75

float readCJMCU75Temperature() {

Wire.beginTransmission(CJMCU_75_ADDRESS);

Wire.write(0x00); // Registro della temperatura

Wire.endTransmission();

Wire.requestFrom(CJMCU_75_ADDRESS, 2);

byte msb = Wire.read();

byte lsb = Wire.read();

int tempData = ((msb << 8) | lsb) >> 4;

float temperature = tempData * 0.0625; // Conversione in °C

return temperature;

}

Sotto l’esempio dell’output sul monitor seriale tramite display OLED

Sotto l’esempio dell’output sul display OLED

Raccolta di sensori di temperatura e umidità

Per altri modelli di sensore potete visitare la Raccolta di sensori di temperatura e umidità. Sono presenti sensori: misuratori di sola temperatura di tipo analogico o con uscita digitale, misuratori di temperatura IR, sensori di sola umidità, dispositivi che possono misurare sia la temperatura che l’umidità, altri ancora misurano anche altri parametri.