In questo tutorial imparerai come utilizzare un LM35 sensore di temperatura analogico con Arduino. Ho incluso uno schema di collegamento e codici di esempio per aiutarti a iniziare!
Nella prima parte di questo articolo, troverai le specifiche e il pinout del LM35. Successivamente, vedremo come collegare il sensore all’Arduino.
Il primo esempio di codice può essere usato per rilevare la temperatura dal sensore e mostrare i risultati nel Serial Monitor. Nel secondo esempio, ti mostrerò come usare la tensione di riferimento interna da 1,1 V dell’Arduino per ottenere letture più precise. Infine, vedremo come visualizzare la temperatura su un I2C LCD per creare un termometro autonomo.
Materiali
Componenti hardware
| LM35 analog temperature sensor (TO-92) | × 1 | Amazon |
| Arduino Uno | × 1 | Amazon |
| Breadboard | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon |
| 16×2 character I2C LCD | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Software
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Informazioni sul LM35
Il LM35 è un sensore di temperatura Centigrado preciso ed economico prodotto da Texas Instruments. Fornisce una tensione di uscita proporzionale linearmente alla temperatura in gradi Centigradi ed è quindi molto facile da usare con Arduino.
Il sensore non richiede alcuna calibrazione o taratura esterna per garantire una precisione di ±0,5°C a temperatura ambiente e ±1°C nell’intervallo da −50°C a +155°C.
Uno svantaggio del sensore è che necessita di una tensione di polarizzazione negativa per misurare temperature sotto zero. Se ti serve questa funzione, ti consiglio di usare invece il DS18B20 o il TMP36. Il TMP36 di Analog Devices è molto simile al LM35 e può misurare temperature da -40°C a 125°C senza componenti esterni.
Puoi trovare un tutorial dedicato per TMP36 e DS18B20 qui:
- TMP36 analog temperature sensor with Arduino tutorial
- The complete guide for DS18B20 digital temperature sensors with Arduino
Il fattore di scala di uscita del LM35 è 10 mV/°C e fornisce una tensione di uscita di 250 mV a 25°C (vedi figura sotto).
Nota che il sensore funziona con una tensione da 4 a 30 V e che la tensione di uscita è indipendente dalla tensione di alimentazione.
Il LM35 fa parte di una serie di sensori di temperatura analogici venduti da Texas Instruments. Altri modelli della serie includono:
- LM335 – tensione di uscita direttamente proporzionale alla temperatura assoluta a 10 mV/°K.
- LM34 – tensione di uscita linearmente proporzionale alla temperatura in Fahrenheit a 10 mV/°F.
Pinout del LM35
Il LM35 è disponibile in 4 diversi package, ma il tipo più comune è il package transistor TO-92 a 3 pin.
Il pinout del sensore è il seguente:
Nota che il pin 1 (+V S ) è il pin più a sinistra quando il lato piatto del sensore (con la scritta) è rivolto verso di te.
| Nome | Pin | Descrizione |
|---|---|---|
| +V S | 1 | Pin di alimentazione positiva (4 – 30 V) |
| V OUT | 2 | Uscita analogica del sensore di temperatura |
| GND | 3 | Pin di massa del dispositivo, collegare al terminale negativo dell’alimentazione |
Puoi trovare le specifiche del LM35 nella tabella sottostante.
Specifiche del sensore di temperatura analogico LM35
| Tensione di alimentazione | 4 V a 30 V |
| Corrente di funzionamento | 60 µA |
| Intervallo di temperatura | -55°C a +155°C |
| Precisione garantita | ±0,5°C a +25°C ±1°C da -55°C a +150°C |
| Fattore di scala di uscita | 10 mV/°C |
| Tensione di uscita a 25°C | 250 mV |
| Auto-riscaldamento | <0,1°C in aria ferma |
| Package | TO-92 a 3 pin |
| Produttore | Texas Instruments |
Per maggiori informazioni, puoi consultare anche il datasheet qui:
Collegamenti – Collegare il sensore di temperatura analogico LM35 ad Arduino
Collegare un LM35 ad Arduino è molto semplice perché devi collegare solo 3 pin. Inizia collegando il pin +V S al pin 5 V di Arduino e il pin GND a massa.
Poi collega il pin centrale (V OUT ) a uno qualsiasi degli ingressi analogici di Arduino. In questo caso ho usato il pin analogico A0.
I collegamenti sono anche riportati nella tabella sottostante:
Collegamenti del sensore di temperatura analogico LM35
| LM35 | Arduino |
|---|---|
| Pin 1 (+V S ) | 5 V |
| Pin 2 (V OUT ) | Pin A0 |
| Pin 3 (GND) | GND |
Convertire la tensione di uscita del LM35 in temperatura
Per convertire la tensione di uscita del sensore in temperatura in gradi Celsius, puoi usare la seguente formula:
Temperatura (°C) = V OUT / 10
con V OUT in millivolt (mV). Quindi se l’uscita del sensore è 750 mV, la temperatura è 75°C.
Come puoi vedere nello schema di collegamento sopra, l’uscita del LM35 è collegata a uno degli ingressi analogici di Arduino. Il valore di questo ingresso analogico può essere letto con la funzione analogRead(). Tuttavia, questa funzione non restituisce direttamente la tensione di uscita del sensore.
Le schede Arduino contengono un convertitore analogico-digitale (ADC) multicanale a 10 bit, che mappa le tensioni di ingresso tra 0 e la tensione di alimentazione (5 V o 3,3 V) in valori interi tra 0 e 1023. Su un Arduino Uno, ad esempio, questo corrisponde a una risoluzione di 5 volt / 1024 unità, cioè 0,0049 volt (4,9 mV) per unità.
Quindi, se usi analogRead() per leggere la tensione su uno degli ingressi analogici di Arduino, otterrai un valore tra 0 e 1023.
Per convertire questo valore nella tensione di uscita del sensore, puoi usare:
V OUT = lettura dall’ADC * (Vref / 1024)
Useremo queste formule negli esempi di codice qui sotto.
Esempio di codice per sensore di temperatura analogico LM35 con Arduino
Con il seguente esempio di codice puoi leggere la temperatura da un sensore LM35 e mostrarla nel Serial Monitor.
/* LM35 analog temperature sensor with Arduino example code. More info: https://www.makerguides.com */
// Define to which pin of the Arduino the output of the LM35 is connected:
#define sensorPin A0
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (5000 / 1024.0);
// Convert the voltage into the temperature in degree Celsius:
float temperature = voltage / 10;
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
delay(1000); // wait a second between readings
}
Dovresti vedere il seguente output nel Serial Monitor:
Assicurati che la velocità di trasmissione del Serial Monitor sia impostata a 9600.
Come funziona il codice
Per prima cosa ho definito a quale pin di Arduino è collegato il pin V OUT del sensore. In questo caso abbiamo usato il pin analogico A0. L’istruzione #define può essere usata per assegnare un nome a un valore costante. Il compilatore sostituirà tutte le occorrenze di questa costante con il valore definito durante la compilazione. Quindi ovunque menzioni sensorPin, il compilatore lo sostituirà con A0 quando il programma sarà compilato.
// Define to which pin of the Arduino the output of the LM35 is connected: #define sensorPin A0
Nella sezione setup del codice, iniziamo la comunicazione seriale a 9600 baud.
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
}
Nella sezione loop del codice, iniziamo prendendo una lettura dal sensore con la funzione analogRead(pin).
// Get a reading from the temperature sensor: int reading = analogRead(sensorPin);
Poi usiamo le formule menzionate prima nell’articolo per convertire la lettura in tensione e poi in temperatura.
// Convert the reading into voltage: float voltage = reading * (5000 / 1024.0); // Convert the voltage into the temperature in degree Celsius: float temperature = voltage / 10;
Infine, i risultati vengono stampati nel Serial Monitor:
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
Migliorare la precisione delle letture
Poiché abbiamo usato la tensione di riferimento predefinita di Arduino per l’ingresso analogico (cioè il valore usato come massimo dell’intervallo di ingresso), la risoluzione massima che otteniamo dall’ADC è 5000/1024 = 4,88 mV o 0,49°C.
Se vogliamo una precisione maggiore, possiamo usare invece la tensione di riferimento interna da 1,1 V di Arduino. Questa tensione di riferimento può essere cambiata usando la funzione analogReference().
Con 1,1 V come tensione di riferimento, otteniamo una risoluzione di 1100/1024 = 1,07 mV o 0,11°C. Nota che questo limita l’intervallo di temperatura misurabile da 0 a 110 gradi Celsius.
Ho evidenziato le righe che devi aggiungere/modificare nel codice qui sotto:
/* LM35 analog temperature sensor with Arduino example code. More info: https://www.makerguides.com */
// Define to which pin of the Arduino the output of the LM35 is connected:
#define sensorPin A0
void setup() {
// Begin serial communication at a baud rate of 9600:
Serial.begin(9600);
// Set the reference voltage for analog input to the built-in 1.1 V reference:
analogReference(INTERNAL);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (1100 / 1024.0);
// Convert the voltage into the temperature in degree Celsius:
float temperature = voltage / 10;
// Print the temperature in the Serial Monitor:
Serial.print(temperature);
Serial.print(" \xC2\xB0"); // shows degree symbol
Serial.println("C");
delay(1000); // wait a second between readings
}
Esempio di codice LM35 con LCD I2C e Arduino
Se vuoi realizzare un termometro autonomo che non necessita di un computer, può essere utile sapere come visualizzare le letture di temperatura su un display LCD.
Con il codice di esempio qui sotto puoi visualizzare le letture di temperatura su un 16×2 character I2C LCD.
Collegare l’LCD I2C è abbastanza semplice come puoi vedere nello schema di collegamento sotto. Puoi consultare il mio tutorial dettagliato su How to control a character I2C LCD with Arduino per maggiori informazioni. Se vuoi usare un LCD standard non I2C, dai un’occhiata a How to use a 16×2 character LCD with Arduino.
I collegamenti sono anche riportati nella tabella sottostante:
Collegamenti LCD I2C
| LCD caratteri I2C | Arduino |
|---|---|
| GND | GND |
| VCC | 5 V |
| SDA | A4 |
| SCL | A5 |
Nota che il sensore di temperatura LM35 è collegato come prima.
Installazione delle librerie Arduino necessarie
Per usare un LCD I2C, devi installare la libreria LiquidCrystal_I2C per Arduino.
Per installare questa libreria, vai su Tools > Manage Libraries (Ctrl + Shift + I su Windows) nell’IDE Arduino. Si aprirà il Library Manager che aggiornerà la lista delle librerie installate.
Ora cerca ‘liquidcrystal_i2c’ e cerca la libreria di Frank de Brabander . Seleziona l’ultima versione e clicca su Install.
Esempio di codice LM35 con LCD I2C
/* LM35 analog temperature sensor with I2C LCD and Arduino example code.
https://www.makerguides.com */
// Include the required Arduino libraries:
#include "LiquidCrystal_I2C.h"
// Create a new instance of the LiquidCrystal_I2C class:
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Degree symbol:
byte Degree[] = {
B00111,
B00101,
B00111,
B00000,
B00000,
B00000,
B00000,
B00000
};
// Define to which pin of the Arduino the output of the LM35 is connected:
#define sensorPin A0
void setup() {
// Start the LCD and turn on the backlight:
lcd.init();
lcd.backlight();
// Create a custom character:
lcd.createChar(0, Degree);
}
void loop() {
// Get a reading from the temperature sensor:
int reading = analogRead(sensorPin);
// Convert the reading into voltage:
float voltage = reading * (5000 / 1024.0);
// Convert the voltage into the temperature in degree Celsius:
float temperature = voltage / 10;
// Print the temperature on the LCD;
lcd.setCursor(0, 0);
lcd.print("Temperature:");
lcd.setCursor(0, 1);
lcd.print(temperature);
lcd.write(0); // print the custom character
lcd.print("C");
delay(1000); // wait a second between readings
}
Dovresti vedere il seguente output sul display LCD:
Conclusione
In questo tutorial ti ho mostrato come usare un sensore di temperatura analogico LM35 con Arduino. Se vuoi saperne di più su altri sensori di temperatura, dai un’occhiata agli articoli qui sotto.
- The complete guide for DS18B20 digital temperature sensors with Arduino
- How to use DHT11 and DHT22 sensors with Arduino
- TMP36 analog temperature sensor with Arduino tutorial
- How to control a character I2C LCD with Arduino
Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, lascia pure un commento qui sotto.
