Sensor de temperatura LM35 no Arduino: fórmula, resolução e o atraso da leitura

O monitor serial mostra -25 numa sala de 25 graus. Você revisa os fios, troca o sensor, e o número continua absurdo. O código veio de um tutorial do TMP36; o sensor na protoboard é um LM35. Os dois têm a mesma cara de transistor e entregam 10 mV por grau, mas o TMP36 soma 500 mV de deslocamento. A fórmula errada transforma 25 °C em -25 °C.

A resposta curta: no LM35, a temperatura em graus Celsius é a tensão de saída em milivolts dividida por 10. No Uno, com a referência padrão de 5 V, cada passo do conversor vale cerca de 0,49 °C; com a referência interna de 1,1 V, cerca de 0,1 °C. Faça média de várias leituras, compare uma vez com um termômetro confiável no lugar de uso e espere o sensor estabilizar antes de acreditar no número.

Por que o número na tela engana

O sensor não entrega graus. Entrega uma tensão, e o seu código transforma tensão em graus com uma fórmula que depende do componente. LM35: 0 mV a 0 °C, 10 mV por grau. TMP36: 500 mV a 0 °C, 10 mV por grau. Termistor NTC: curva não linear que depende do resistor do divisor. DHT11 e DS18B20: comunicação digital, nada de tensão proporcional. Antes de qualquer conta, leia a folha de dados do componente que está na sua mão.

Depois vem a resolução. O conversor do Uno tem 10 bits: divide a referência em 1024 passos. Com 5 V, cada passo vale 4,88 mV, quase meio grau no LM35. A leitura pula de 24,4 para 24,9 sem passar pelo meio, e a casa decimal no monitor dá uma falsa impressão de precisão.

Por fim, o atraso. O encapsulamento plástico precisa esquentar ou esfriar junto com o ar. No ar parado, isso pode levar minutos. Um sensor que acabou de sair da sua mão mostra a temperatura da sua mão por um bom tempo.

Ligação e conta com números

O exemplo que vai atravessar o texto: um gabinete de rack caseiro com um cooler que deve ligar acima de 30 °C. O LM35 tem três terminais: alimentação, saída e terra. A ordem física aparece no desenho da folha de dados, vista pela face plana; confira antes de ligar, porque invertido ele esquenta.

Referência de 5 V:
  passo = 5000 mV / 1024 = 4,88 mV   -> 0,49 °C por passo
  leitura 61  -> 61 × 4,88 = 298 mV  -> 29,8 °C

Referência interna de 1,1 V (Uno):
  passo = 1100 mV / 1024 = 1,07 mV   -> 0,11 °C por passo
  leitura 278 -> 278 × 1,07 = 298 mV -> 29,9 °C
  limite: 1100 mV = 110 °C, suficiente para ambiente

A referência interna melhora a resolução quase cinco vezes. O custo: o valor exato dela varia de chip para chip, numa faixa de cerca de 10% para cima ou para baixo de 1,1 V. Por isso ela precisa de uma calibração simples, feita no passo 5 abaixo.

Como montar uma leitura confiável

1. Confirme o modelo pela inscrição no corpo do sensor e escolha a fórmula correspondente.
2. Ligue o LM35 no 5 V, no GND e a saída no A0. Mantenha-o longe do regulador da placa, do driver de motor e de qualquer resistor que esquente.
3. Use a referência interna com analogReference(INTERNAL) e descarte as primeiras leituras depois de trocar a referência. Com a referência interna, não ligue nenhuma tensão externa no pino AREF.
4. Faça média de 16 leituras para reduzir o ruído.
5. Calibre: deixe o sensor e um termômetro confiável lado a lado, no gabinete, por 15 minutos. Se o Arduino mostra 29,1 e o termômetro mostra 28,3, o ajuste é -0,8.
6. Leia a cada 2 segundos, não em todo ciclo do loop(). A temperatura não muda tão depressa, e você libera o processador.
7. Ligue o cooler com folga: acima de 30 °C liga, abaixo de 28 °C desliga.

const int PINO_LM35 = A0;
const int PINO_COOLER = 6;            // aciona um transistor ou MOSFET, não o cooler direto

const float VREF_MV = 1100.0;         // ajuste se medir a referência real
const float AJUSTE_C = -0.8;          // diferença medida contra o termômetro
const float LIGAR_ACIMA_C = 30.0;
const float DESLIGAR_ABAIXO_C = 28.0;
const unsigned long INTERVALO_MS = 2000;

bool coolerLigado = false;
unsigned long ultimaLeitura = 0;

float lerTemperaturaC() {
  long soma = 0;
  for (int i = 0; i < 16; i++) {
    soma += analogRead(PINO_LM35);
    delay(5);
  }
  float milivolts = (soma / 16.0) * VREF_MV / 1024.0;
  return milivolts / 10.0 + AJUSTE_C;   // LM35: 10 mV por grau Celsius
}

void setup() {
  pinMode(PINO_COOLER, OUTPUT);
  digitalWrite(PINO_COOLER, LOW);
  Serial.begin(9600);

  analogReference(INTERNAL);            // 1,1 V no Uno (ATmega328P)
  for (int i = 0; i < 5; i++) {         // descarta leituras logo após trocar a referência
    analogRead(PINO_LM35);
    delay(10);
  }
}

void loop() {
  if (millis() - ultimaLeitura < INTERVALO_MS) {
    return;
  }
  ultimaLeitura = millis();

  float t = lerTemperaturaC();

  if (!coolerLigado && t > LIGAR_ACIMA_C) {
    coolerLigado = true;
    digitalWrite(PINO_COOLER, HIGH);
  } else if (coolerLigado && t < DESLIGAR_ABAIXO_C) {
    coolerLigado = false;
    digitalWrite(PINO_COOLER, LOW);
  }

  Serial.print("temp_C=");
  Serial.print(t, 1);
  Serial.print(" cooler=");
  Serial.println(coolerLigado ? "ligado" : "desligado");
}

O cooler consome mais do que um pino aguenta; por isso o pino 6 aciona um transistor ou MOSFET com diodo, e o cooler bebe de uma fonte própria. A lógica de dois limiares é a mesma do sensor de luz LDR: sem folga, o cooler liga e desliga a cada nuvem de ruído.

Atraso e posição: o que a calibração não corrige

Teste o atraso uma vez: segure o sensor entre os dedos até a leitura passar de 32 °C, solte e cronometre quanto tempo leva para voltar a 1 grau do valor anterior. Esse tempo é o atraso do seu sistema. Se o cooler precisa reagir em segundos, o sensor no ar parado não serve; encostá-lo no componente que esquenta, com pasta térmica, encurta o atraso.

A posição muda o que você mede. Um LM35 colado na protoboard ao lado do regulador mede o regulador. No gabinete, ele deve ficar no fluxo de ar que você quer controlar. Se a necessidade é umidade junto com temperatura, ou uma leitura digital sem conta de tensão, o assunto muda de sensor; veja o que esperar do DHT11.

Erros comuns

• Usar a fórmula de outro sensor: LM35 com fórmula de TMP36 dá -25 °C onde há 25 °C.
• Confiar na casa decimal com referência de 5 V: cada passo vale quase meio grau, e a decimal é ilusão.
• Calibrar segurando o sensor na mão: a referência vira a temperatura da sua pele.
• Montar o sensor ao lado do regulador ou do driver: ele mede o calor da placa, não o ambiente.
• Ligar tensão externa no AREF com referência interna: pode danificar o conversor do microcontrolador.
• Cooler com limiar único: liga e desliga sem parar na fronteira.

Checklist

• Conferiu o modelo do sensor e a fórmula da folha de dados.
• Sabe quanto vale um passo do conversor na referência que está usando.
• Descarta as primeiras leituras após mudar a referência.
• Faz média de várias leituras.
• Calibrou contra um termômetro confiável, lado a lado, no lugar de uso.
• Mediu o atraso do sensor uma vez e sabe se ele serve para a reação que você precisa.
• O sensor está longe de fontes de calor da própria montagem.
• O controle usa dois limiares, com folga.

Coloque um termômetro confiável ao lado do seu sensor e espere 15 minutos. Qual é a diferença entre os dois números? Se você não sabe, a casa decimal do monitor ainda não significa nada.