In questo tutorial imparerai come utilizzare un TMP36 sensore di temperatura analogico con Arduino. Ho incluso uno schema di collegamento e diversi esempi di codice per aiutarti a iniziare!
Nella prima parte di questo articolo, troverai le specifiche e le informazioni sui sensori TMP35, TMP36 e TMP37. 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 visualizzare la temperatura su un LCD I2C per creare un termometro autonomo.
Materiali
Componenti hardware
| TMP36 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 sui sensori di temperatura analogici TMP35/TMP36/TMP37
I sensori TMP35/TMP36/TMP37 sono sensori di temperatura centigradi a bassa tensione e precisione prodotti da Analog Devices. Forniscono un’uscita in tensione proporzionale linearmente alla temperatura in gradi Celsius (°C) e sono quindi molto facili da usare con Arduino. Inoltre, sono precisi, non si usurano mai e sono molto economici!
I sensori TMP35/TMP36/TMP37 non richiedono alcuna calibrazione esterna per garantire una precisione tipica di ±1°C a +25°C e ±2°C nell’intervallo di temperatura da −40°C a +125°C.
La differenza tra TMP35, TMP36 e TMP37 riguarda l’intervallo di temperatura operativo e il fattore di scala dell’uscita. Il TMP35 misura temperature da 10°C a 125°C e fornisce un’uscita di 250 mV a 25°C. Questo sensore è compatibile funzionalmente con l’LM35 prodotto da Texas Instruments. Vedi il LM35 analog temperature sensor with Arduino tutorial per maggiori dettagli.
Il TMP36 misura temperature da -40°C a 125°C, fornisce un’uscita di 750 mV a 25°C e funziona fino a +125°C con un’alimentazione singola da 2,7 V. Questo sensore è compatibile funzionalmente con l’LM50. Il TMP35 e il TMP36 hanno lo stesso fattore di scala di uscita di 10 mV/°C.
Il TMP37 è progettato per un intervallo operativo da 5°C a 100°C e fornisce un’uscita di 500 mV a 25°C. Questo sensore offre una precisione leggermente superiore rispetto agli altri e ha un fattore di scala di uscita di 20 mV/°C.
Come si vede nella figura sopra, l’intervallo di uscita di tutti i sensori è compreso tra 0,1 V e 2 V. Nota che la tensione di uscita è indipendente dalla tensione di alimentazione utilizzata.
Pinout TMP35/TMP36/TMP37
I sensori TMP35/TMP36/TMP37 sono disponibili in 3 formati diversi, ma il tipo più comune è il 3-pin TO-92 package, che assomiglia a un transistor. La versione TMP36 di questo sensore ha il numero di modello TMP36GT9Z.
Il pinout del sensore è mostrato nella figura seguente:
Nota che il pin 1 (+V S ) è il pin più a sinistra quando il lato piatto del sensore (con la scritta stampata) è rivolto verso di te.
Puoi trovare altre specifiche del TMP36 nella tabella sottostante.
Specifiche del sensore di temperatura analogico TMP36
| Tensione di alimentazione | 2,7 V a 5,5 V |
| Corrente a riposo | 50 µA |
| Intervallo di temperatura | -40°C a +125°C |
| Precisione | ±1°C a +25°C ±2°C da -40°C a +125°C |
| Fattore di scala di uscita | 10 mV/°C |
| Tensione di uscita a 25°C | 750 mV |
| Package | TO-92 a 3 pin |
| Produttore | Analog Devices |
| Costo | Check price |
Per maggiori informazioni, puoi consultare anche il datasheet qui:
Collegamenti – Collegare il sensore di temperatura TMP36 ad Arduino
Collegare un TMP36 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 terra. Se usi un Arduino a 3,3 V, collega semplicemente +V S a 3,3 V invece.
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 sensore di temperatura analogico TMP36
| TMP36 | Arduino |
|---|---|
| Pin 1 (+V S ) | 5 V |
| Pin 2 (V OUT ) | Pin A0 |
| Pin 3 (GND) | GND |
Per migliorare la stabilità del sensore, il datasheet consiglia di aggiungere un condensatore ceramico da 0,1 μF tra il pin +V S e GND. Quando si usano cavi lunghi, aggiungere una piccola resistenza (es. 750 Ω) in serie alla linea del segnale (V OUT ) può anche ridurre il rumore.
Quando ho testato il sensore con un Arduino Uno, ho ottenuto letture stabili anche senza condensatore e resistenza, ma i tuoi risultati potrebbero variare.
Conversione della tensione di uscita del TMP36 in temperatura
Per convertire la tensione di uscita del sensore in temperatura in gradi Celsius, puoi usare la seguente formula:
Temperatura (°C) = (V OUT – 500) / 10
con V OUT in millivolt (mV). Quindi, se l’uscita del sensore è 750 mV, la temperatura è:
(750 – 500) / 10 = 25°C
Come si vede nello schema di collegamento sopra, l’uscita del TMP36 è collegata a uno degli ingressi analogici di Arduino. Il valore di questo ingresso analogico può essere letto con la funzione analogRead() come vedrai negli esempi di codice qui sotto. Tuttavia, la funzione analogRead(pin) 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 tra le letture di 5 volt / 1024 unità, ovvero 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 * (5000 / 1024)
E se usi un Arduino a 3,3 V:
V OUT = lettura dall’ADC * (3300 / 1024)
Useremo queste formule negli esempi di codice qui sotto.
Esempio di codice per sensore di temperatura analogico TMP36 con Arduino
Con il seguente esempio di codice, puoi leggere la temperatura da un sensore TMP36 e mostrarla nel Serial Monitor.
/* TMP36 analog temperature sensor with Arduino example code.
https://www.makerguides.com */
// Define to which pin of the Arduino the output of the TMP36 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 Celsius:
float temperature = (voltage - 500) / 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 (Ctrl + Shift + M).
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 del programma. Quindi ovunque menzioni sensorPin, il compilatore lo sostituirà con A0 durante la compilazione.
// Define to which pin of the Arduino the output of the TMP36 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 - 500) / 10;
Se usi un Arduino a 3,3 V, come il Arduino Due o il Arduino Nano 33 BLE, devi collegare il pin +V S a 3,3 V e sostituire la riga evidenziata con:
// Convert the reading into voltage: float voltage = reading * (3300 / 1024.0);
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");
Visualizzare le letture di temperatura TMP36 su un LCD I2C
Se vuoi realizzare un termometro autonomo che non richieda un computer, può essere utile sapere come visualizzare le letture di temperatura su un display LCD.
Con l’esempio di codice qui sotto, puoi mostrare le letture di temperatura su un LCD I2C da 16×2 caratteri. Collegare l’LCD I2C è abbastanza semplice come si vede nello schema di collegamento sottostante.
Vedi il How to control a character I2C LCD with Arduino e il How to use a 16×2 character LCD with Arduino Tutorial per maggiori dettagli sui display LCD I2C.
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 TMP36 è collegato come prima.
Installazione delle librerie Arduino necessarie
Per usare un LCD I2C, devi installare la libreria Arduino LiquidCrystal_I2C.
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 TMP36 con LCD I2C
/* TMP36 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 TMP36 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 - 500) / 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 TMP36 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
- LM35 analog temperature sensor with Arduino tutorial
- How to control a character I2C LCD with Arduino
- How to use a 16×2 character LCD with Arduino
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
