Using TMP36 Temperature Sensor: Arduino Interfacing Guide

A simple and cost-effective method to incorporate temperature sensing into your Arduino project is by utilizing the TMP36 Temperature Sensor. These sensors offer good precision and require no additional components to function. With just a few connections and some Arduino code, you can start sensing temperature quickly!

Parts Required

Component Name	Buy Now
Arduino Uno REV3	Amazon
TMP36 Temperature Sensor	Amazon
I2C TWI 1602 Serial LCD Module Display	Amazon
Breadboards Kit	Amazon

TMP36 Temperature Sensor

The TMP36, crafted by Analog Devices, is a precision centigrade temperature sensor operating at low voltage. It produces a voltage output directly proportional to the temperature in degrees Celsius, making it exceptionally compatible with Arduino projects.

This sensor boasts remarkable precision, enduring performance, and versatility across various environmental conditions. Remarkably, it operates without the need for supplementary components. Moreover, calibration isn’t necessary, and it maintains a typical accuracy of ±1°C at 25°C, with a deviation of ±2°C across temperatures ranging from -40°C to +125°C.

Operating within a power supply range of 2.7V to 5.5V, the TMP36 consumes a mere 50µA during active temperature conversions, ensuring minimal self-heating (below 0.1°C in stagnant air). Furthermore, it features a shutdown function that reduces supply current to less than 0.5µA.

Below are the comprehensive specifications:

Power supply	2.7V to 5.5V
Current draw	50µA
Temperature range	-40°C to 125°C
Accuracy	±2°C
Output scale factor	10mV/°C
Output range	0.1V (-40°C) to 1.75V (125°C)
Output at 25°C	750mV

For more information, please refer below datasheet.

Working Principle

The TMP36 operates on a solid-state method for temperature measurement. It capitalizes on the principle that the voltage drop across the base and emitter (known as forward voltage – Vbe) of the Diode-connected transistor decreases at a consistent rate with temperature rise. Through precise amplification of this voltage alteration, an analog signal directly correlating to temperature is effortlessly generated.

The linear correlation between forward voltage and temperature is why diode-connected transistors serve as effective temperature measurement tools. Essentially, this method forms the basis of temperature measurement, though there have been advancements in the technique over time. Further details on this approach can be explored here.

The advantageous aspect is that all intricate calculations are internally handled within the TMP36. It simply produces a voltage output that linearly corresponds to temperature.

Temperature Measurement Procedure

Utilizing the TMP36 is straightforward. Simply connect the left pin to a power source (within the range of 2.7-5.5V) and the right pin to ground (assuming the sensor’s flat side is oriented towards you). Subsequently, the middle pin will yield an analog voltage directly proportional (linearly) to the temperature in degrees Celsius. This correlation is readily observable in the voltage versus temperature characteristic. Notably, the analog output voltage remains unaffected by variations in the power supply.

Converting the voltage to temperature involves employing the basic formula:

Temperature (°C) = (Vout – 0.5) * 100

For instance, if the output voltage is 1V, the temperature is calculated as (1 – 0.5) * 100 = 50 °C.

Testing the TMP36 Sensor

Assessing the TMP36 is relatively straightforward. To begin, connect the left pin to a power source ranging from 2.7V to 5.5V (such as two AA batteries), and the right pin to the ground (ensuring the sensor’s flat side is facing towards you). Then, connect your multimeter in DC voltage mode to the ground and the middle pin. Under standard room temperature conditions (25°C), the voltage reading should stabilize around 0.75V.

Experiment by gently exerting pressure on the plastic casing of the sensor to observe a temperature increase.

Alternatively, test by touching the sensor with an ice cube (placed in a plastic bag to prevent water from contacting your circuit) and observe the temperature decrease.

TMP36 Sensor Pinout

The TMP36 is available in three distinct form factors, with the most prevalent being the 3-pin TO-92 package, resembling a transistor. Here’s an overview of its pinout:

+Vs: This pin serves as the power supply for the sensor, accommodating voltages ranging from 2.7V to 5.5V.

Vout: This pin generates an analog voltage that linearly correlates with the temperature. It should be linked to an Analog (ADC) input.

GND: This pin serves as the ground connection.

Connecting the TMP36 Temperature Sensor to an Arduino

The process of linking the TMP36 to an Arduino is remarkably simple. You’ll only need to establish connections for three pins: two for power and one for reading the sensor’s value.

The sensor can be powered from either a 3.3V or 5V output. Connect the positive voltage to the ‘+Vs’ pin, and ground should be connected to ‘GND’. The middle pin, ‘Vout’, functions as the analog signal output from the sensor and should be linked to the A0 analog input of the Arduino.

Below is the setup for conducting experiments with the TMP36:

To measure air temperature, place the sensor in open air or attach it to an object whose temperature you wish to monitor, such as a heat sink.

Interpreting Analog Temperature Data

As depicted in the above wiring diagram, the TMP36’s output is linked to one of the Arduino’s analog inputs. The value of this analog input can be retrieved using the analogRead() function.

However, the analogRead() function doesn’t directly provide the sensor’s output voltage. Instead, it maps the input voltage between 0 and the ADC reference voltage (typically the operating voltage, either 5V or 3.3V unless modified) to 10-bit integer values ranging from 0 to 1023. To revert this value to the sensor’s output voltage, employ this formula:

Vout = (reading from ADC) * (5 / 1024)

This equation converts the ADC’s 0-1023 reading into a 0-5V range.

For users employing a 3.3V Arduino, the formula becomes:

Vout = (reading from ADC) * (3.3 / 1024)

This calculation translates the ADC’s 0-1023 reading into a 0-3.3V range.

Subsequently, to convert volts into temperature, employ this formula:

Temperature (°C) = (Vout – 0.5) * 100

Arduino Code – Basic Thermometer

The provided sketch offers a swift method to retrieve data from a TMP36 temperature sensor, serving as a foundation for further experimentation and project development. It straightforwardly captures the TMP36 value via analog port A0 and displays the current temperature (in both °C and °F) on the serial monitor. Feel free to upload it to your Arduino.

// Define the analog pin, the TMP36's Vout pin is connected to
#define sensorPin A0

void setup() {
  // Begin serial communication at 9600 baud rate
  Serial.begin(9600);
}

void loop() {
  // Get the voltage reading from the TMP36
  int reading = analogRead(sensorPin);

  // Convert that reading into voltage
  // Replace 5.0 with 3.3, if you are using a 3.3V Arduino
  float voltage = reading * (5.0 / 1024.0);

  // Convert the voltage into the temperature in Celsius
  float temperatureC = (voltage - 0.5) * 100;

  // Print the temperature in Celsius
  Serial.print("Temperature: ");
  Serial.print(temperatureC);
  Serial.print("\xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");
  
  // Print the temperature in Fahrenheit
  float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
  Serial.print(temperatureF);
  Serial.print("\xC2\xB0"); // shows degree symbol
  Serial.println("F");

  delay(1000); // wait a second between readings
}

You should see the following output in the serial monitor.

Code Explanation:

The sketch begins by defining the Arduino pin connected to the sensor’s Vout pin.

#define sensorPin A0

In the setup function, we initialize the serial connection with the computer.

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

Within the loop, we first read the analog signal from the TMP36 using the analogRead() function.

int reading = analogRead(sensorPin);

Then, we employ the formulas discussed earlier to convert the analog reading into voltage and subsequently into temperature.

float voltage = reading * (5.0 / 1024.0);

float temperatureC = (voltage - 0.5) * 100;

The obtained results are then printed on the Serial Monitor.

Serial.print("Temperature: ");
Serial.print(temperatureC);
Serial.print("\xC2\xB0"); // shows degree symbol
Serial.print("C  |  ");

The temperature value obtained is in Celsius (°C). We convert it to Fahrenheit (°F) using a straightforward formula and display it on the Serial Monitor.

T_(°F) = T_(°C) × 9/5 + 32

float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
Serial.print(temperatureF);
Serial.print("\xC2\xB0"); // shows degree symbol
Serial.println("F");

Enhancing the Accuracy of the TMP36 Sensor

Since we haven’t configured the reference voltage (ARef) for analog input (the default analog reference on 5V Arduino boards is 5 volts), the maximum resolution from the ADC is 5/1024 = 4.88 mV or 0.49°C.

For improved precision, utilizing the 3.3V reference voltage as ARef instead of the 5V option will yield more accurate and less noisy results. With 3.3V as the reference voltage, the resolution becomes 3.3/1024 = 3.22 mV or 0.32°C.

To utilize the 3.3V pin as the analog reference, connect it to the AREF (Analog Reference) input as follows:

Additionally, certain changes are required in the code. The lines needing modification or addition are highlighted below:

// Define the analog pin, the TMP36's Vout pin is connected to
#define sensorPin A0

// Tie ARef to 3.3V
#define aref_voltage 3.3
void setup() {
  // Begin serial communication at 9600 baud rate
  Serial.begin(9600);

  // If you want to set the aref to something other than 5v
  analogReference(EXTERNAL);}

void loop() {
  // Get the voltage reading from the TMP36
  int reading = analogRead(sensorPin);

  // Convert that reading into voltage
  float voltage = reading * (aref_voltage / 1024.0);
  // Convert the voltage into the temperature in Celsius
  float temperatureC = (voltage - 0.5) * 100;

  // Print the temperature in Celsius
  Serial.print("Temperature: ");
  Serial.print(temperatureC);
  Serial.print("\xC2\xB0"); // shows degree symbol
  Serial.print("C  |  ");
  
  // Print the temperature in Fahrenheit
  float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
  Serial.print(temperatureF);
  Serial.print("\xC2\xB0"); // shows degree symbol
  Serial.println("F");

  delay(1000); // wait a second between readings
}

You should observe the following output in the serial monitor.

This adjustment provides a slight enhancement in accuracy, but for many projects, this may still be insufficient.

An alternative to the TMP36 is employing a digital temperature sensor like the DS18B20, which shares the same package. Digital temperature sensors offer superior noise immunity, especially beneficial when placed at a distance or in electrically noisy environments.

Arduino Project – Standalone Thermometer with TMP36 and an I2C LCD

Occasionally, you may conceive an idea where displaying real-time temperature readings and issuing alerts when the temperature exceeds specified thresholds is necessary. In such cases, utilizing a 16×2 character LCD instead of a serial monitor becomes advantageous.

In this instance, we’ll connect an I2C LCD to the Arduino alongside the TMP36.

Connecting the I2C LCD is straightforward, as depicted in the wiring diagram below. If you’re unfamiliar with 16×2 character I2C LCDs, it’s advisable to peruse the tutorial provided.

The following diagram illustrates the wiring setup.

The ensuing sketch will display temperature values on the 16×2 character I2C LCD. The code closely resembles the initial example, albeit with values printed on the I2C LCD.

// Include the LiquidCrystal_I2C library
#include <LiquidCrystal_I2C.h>

// Create a new instance of the LiquidCrystal_I2C class
LiquidCrystal_I2C lcd(0x3F, 16, 2);

// Define a custom degree character
byte Degree[] = {
  B00111,
  B00101,
  B00111,
  B00000,
  B00000,
  B00000,
  B00000,
  B00000
};

// Define the analog pin, the TMP36's Vout pin is connected to
#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 the voltage reading from the TMP36
  int reading = analogRead(sensorPin);

  // Convert that reading into voltage
  // Replace 5.0 with 3.3, if you are using a 3.3V Arduino
  float voltage = reading * (5.0 / 1024.0);

  // Convert the voltage into the temperature in Celsius
  float temperatureC = (voltage - 0.5) * 100;

  // Print the temperature on the LCD;
  lcd.setCursor(0, 0);
  lcd.print("Temperature:");
  lcd.setCursor(0, 1);
  lcd.print(temperatureC, 1);
  lcd.write(0); // print the custom degree character
  lcd.print("C ");
  
  // Print the temperature in Fahrenheit
  float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
  lcd.print(temperatureF, 1);
  lcd.write(0); // print the custom degree character
  lcd.print("F ");

  delay(1000); // wait a second between readings
}

You should observe the following output on the LCD screen:

Related article

• Arduino LCD Tutorial: How to Interface a 16×2 Character LCD Module
• Step-by-Step Guide: LM35 Temperature Sensor Interfacing with Arduino
• Arduino DHT11 Sensor Tutorial: How to Interface and Read Data
• DHT11/DHT22 Interface with ESP8266 NodeMCU Web Server: Step-by-Step