Saltar al contenido
Todo Sobre Microcontroladores

Sensor de temperatura LM35 para Arduino

← Tu opinión es importante

Cuando se trata de arduino no sólo el LM35 puede utilizarse para medir la temperatura, también se puede encontrar en el mercado sensores como el DHT11 que mide humedad y temperatura. Este post está enfocado solo en el sensor de temperatura para arduino LM35.

[Imagen]

Contenidos del post

¿Qué es?

Es un circuito integrado con un encapsulado similar al de los transistores que a su salida proporciona un voltaje lineal proporcional a la temperatura en grados centígrados. Para calcular la temperatura que está sensando el LM35 se debe considerar que cada 10 mV es 1 °C.

\[Temperatura = {{LecturaSensor*VoltajeDeReferencia \over 1023} \over 0.01}\]

Con la fórmula anterior, a partir del valor leído y el voltaje al que está conectado el sensor, se puede calcular la temperatura en grados centígrados dividiendo para los 0.01 V o 10 mV por cada grado. Más adelante podrás ver esta fórmula puesta en código para enviarla a un arduino, aunque también sirve para cualquier otro microcontrolador con entrada analógica.

Por ejemplo, con una lectura de 44 y un voltaje de 5 V como referencia el resultado en grados sería:

\[Temperatura = {{44*5 \over 1023} \over 0.01} = 21.501 °C\]

Datasheet y caracteristicas

Ya se explicaron algunas de las características del sensor de temperatura LM35, aún así es importante que conozcas más a detalle sus características técnicas.

  • Temperatura de salida: Grados centígrados o Celsius.
  • Escala: 10 mV -> 1 °C
  • Precisión del sensor: ± 0.5 °C
  • Rango de medida: -55 °C hasta 150 °C

Si quieres conocer más a detalle sobre el sensor, puedes también visitar el datasheet del LM35 dando click al botón a continuación.

Ahí podrás encontrar medidas del sensor, el circuito interno encapsulado, voltajes a los que funciona, etc.

Como conectar un sensor de temperatura a un arduino

El sensor LM35 lo puedes encontrar en 2 diferentes presentaciones, una que es tipo sonda y la otra que se parece mucho a un transistor.

tipos de sensor lm35, sonda y pines expuestos

Aunque tengan presentaciones diferentes tendrán las mismas 3 conexiones disponibles, para el caso de la sonda el cable negro es para GND y el rojo para el voltaje (VCC). Por otro lado, cuanto tienes el sensor con los pines expuestos puedes basarte en la siguiente imagen para hacer su conexión.

Pines de conexión para sensor de temperatura arduino lm35

La conexión básica entre un arduino y el sensor de temperatura la verás a continuación pero cabe recalcar que el pin a donde va conectada la salida del sensor en el arduino lo escoge el usuario según la placa que tenga disponible y será ese pin el que se defina al momento de la programación.

Sensor de temperatura y display 7 segmentos a arduino

Para que sea algo más práctica y no solo mostrar la programación de la lectura del sensor, puedes añadirle más dificultad agregándole un display de 7 segmentos a tu circuito como lo verás en la figura a continuación.

sensor de temperatura display 7 segmentos arduino

Programación de arduino para sensor de temperatura

Tomando el ejemplo anterior al que se le agregó el display, tienes el siguiente código. Al ser este circuito solo con un display este no mostrará la temperatura como tal sino que dependiendo de la temperatura medida se mostrará un número u otro.

// Matriz para representar los números de 0 a 9:
int numero[11][8] = { // 11 filas, 8 colunas
 { 1,1,1,1,1,1,0,0 }, // 0
 { 0,1,1,0,0,0,0,0 }, // 1
 { 1,1,0,1,1,0,1,0 }, // 2
 { 1,1,1,1,0,0,1,0 }, // 3
 { 0,1,1,0,0,1,1,0 }, // 4
 { 1,0,1,1,0,1,1,0 }, // 5
 { 1,0,1,1,1,1,1,0 }, // 6
 { 1,1,1,0,0,0,0,0 }, // 7
 { 1,1,1,1,1,1,1,0 }, // 8
 { 1,1,1,1,0,1,1,0 }, // 9
 { 0,0,0,0,0,0,0,1 } // Punto decimal (No se usa en este ejemplo)
};

void mostrarNumero(int valor) { // Índice de la fila (número a mostrar)
 int pin = 2; // Comienza a contar desde el PIN 2
 for (int i = 0; i < 8; i++) {
 digitalWrite(pin, numero[valor][i]); // Muestra el número según fila y columna
 pino++;
 }
}

int mapaTemp(float temp){ // Condiciona según las temperaturas para mostrar del 0-9
 
  if (temp>=0 && temp<25){
    return 0;
  }
  if (temp>= 25&& temp<50){
     return 1;
  }
  if (temp>=50 && temp<75){
     return 2;
  }
  if (temp>=75 && temp<100){
      return 3;
  }
  if (temp>=100 && temp<125){
     return 4;
  }
  if (temp>=125 && temp<150){
      return 5;
  }
  if (temp>=150 && temp<175){
      return 6;
  }
  if (temp>=175 && temp<200){
      return 7;
  }
  if (temp>=200 && temp<225){
     return 8;
  }
  if (temp>=225){
      return 9;
  }
}


void setup() 
{  
  pinMode(2, OUTPUT); //Pin 2 de Arduino conectado al segmento A  
  pinMode(3, OUTPUT); //Pin 3 de Arduino conectado al segmento B
  pinMode(4, OUTPUT); //Pin 4 de Arduino conectado al segmento C
  pinMode(5, OUTPUT); //Pin 5 de Arduino conectado al segmento D
  pinMode(6, OUTPUT); //Pin 6 de Arduino conectado al segmento E
  pinMode(7, OUTPUT); //Pin 7 de Arduino conectado al segmento F
  pinMode(8, OUTPUT); //Pin 8 de Arduino conectado al segmento G
  pinMode(9, OUTPUT); //Pin 9 de Arduino conectado al segmento del PUNTO

  Serial.begin(9600);
}


void loop() 
{
 
  float temp = analogRead(0); // Leer el dato del sensor de temperatura
  //Serial.println(temp);
  temp = map(temp, 0, 358, 0, 255); // Conversión de la temperatura (Mapeando)
 // Serial.println(temp);
  mostraNumero(mapaTemp(temp));

Programación del sensor y un ventilador

La electrónica se aprende creando, por eso mientras más ejemplos se puedan tener en nuestras publicaciones las verás en cada post para que puedas experimentar con ellas. El código a continuación enciende un ventilador cuando la temperatura excede cierto rango.

int Sensor = 0 ;              // Número de PIN para el sensor
int umbral = 28 ;            // Nivel max de temperatura para encender el ventilador
const int control = 9 ;    // Controla el ventilador

void setup()
{
    Serial.begin(115200);
    pinMode(control, OUTPUT) ;
}

void loop()
{
    int lectura = analogRead(Sensor);
    float voltaje = 5.0 /1024 * lectura ; // Convertimos a voltaje
    float temp = voltaje * 0.01; // Convertimos el voltaje a temperatura
    Serial.println(temp) ;
    if (temp >= umbral){ // Condicionamos si la temperatura se excede
        digitalWrite(control, HIGH); // Encendemos el ventilador conectado
    } else {
       digitalWrite(control, LOW); // Si no excede, permanece apagado

    }
    delay(200);
}

Las conexiones para este ejemplo van a ser similares a las del ejemplo anterior con el display a diferencia de que sólo habrá un PIN que enciende el ventilador.