Gravando dados de temperatura com termistor NTC na memória flash do ESP32

Introdução

O artigo demonstra uma aplicação prática da memória não volátil no ESP32, utilizando um termistor NTC para medir e armazenar temperaturas de forma permanente. Após explicar o funcionamento do sensor e sua leitura analógica, o texto apresenta um circuito com LED e buzzer para sinalizar variações de temperatura e mostra como usar a biblioteca Preferences.h para gravar e recuperar dados na memória flash mesmo após desligamentos. O projeto evidencia como esse recurso torna os sistemas mais autônomos e confiáveis, sendo um passo importante na evolução de projetos didáticos para aplicações profissionais.

O que é um termistor e como funciona

O termistor NTC (Coeficiente de Temperatura Negativo), é um tipo de resistor que varia sua resistência de modo inversamente proporcional à temperatura, ou seja, quanto mais quente, menor a resistência.Esse funcionamento se baseia em efeitos de materiais semicondutores, como óxidos metálicos, cujos portadores de carga (responsáveis pela condução de eletricidade) se tornam mais abundantes com o aumento da temperatura, permitindo a passagem de mais corrente e, consequentemente, reduzindo a resistência. Abaixo, temos um gráfico que explica o funcionamento deste componente.

Fonte: https://www.researchgate.net/figure/Figura-No-6-Comportamiento-de-un-Termistor-NTC-La-relacion-entre-la-resistencia-y-la_fig3_301892238

Circuito básico com NTC

Lista de materiais

• ESP32
• Termistor NTC 10kΩ
• Resistor 10kΩ
• LED
• Resistor 220Ω
• Buzzer
• Protoboard
• Cabos jumper (macho-macho)
• Fonte 5V (ou USB)

Conversão da leitura analógica (ADC) para temperatura

Para realizar a leitura da temperatura em um ESP32, é necessário usar os recursos de leitura analógica disponíveis em seu microcontrolador. Para as finalidades deste artigo, basta aplicar um divisor de tensão com o NTC, conectando-o junto a um pino analógico do ESP32. Para realizar a leitura dos sinais em análise, basta ativar o monitor serial para imprimir os valores de temperatura em um dado intervalo de tempo.

Para fins didáticos, teremos abaixo um exemplo que deixa muito mais claro esse passo do projeto, em que o sinal do termistor é introduzido na entrada analógica do ESP32, que, seguindo os comandos do código (também disponibilizado), informa os valores da temperatura por meio do monitor serial.

double ntc = 4;

void setup() {

  Serial.begin(9600);
}

void loop() {
  
  int ntcValue = analogRead(ntc);
  
  Serial.print("Leitura do NTC: ");
  Serial.println(ntcValue);
  delay(1000);
}

Uma aplicação mais prática, e ainda bem simples, se baseia no uso de alguma sinalização de saída, na qual é acionada após o os valores de temperatura ultrapassarem um limite programado no microcontrolador.

Para fins didáticos, aplicaremos um led e um buzzer para a sinalização de evento.

double ntc = 4;
int buzzer = 2;
int led = 23;


void setup() {

  pinMode(buzzer,OUTPUT);
  pinMode(led,OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int contador = 0;
  int ntcValue = analogRead(ntc);
  bool logicState = 0;
  digitalWrite(led,logicState);
  digitalWrite(buzzer,logicState);

  if(ntcValue < 1650){
    while (contador < 10) {
      contador ++;
      logicState = !logicState;             
      digitalWrite(led, logicState);
      digitalWrite(buzzer, logicState);
      delay(500);
    } 
  }

  Serial.print("Leitura do NTC: ");
  Serial.println(ntcValue);

}

Armazenamento dos dados na memória flash do ESP32 com Preferences.h

Em projetos mais básicos, utilizar a memória flash em um microcontrolador pode não ser estritamente necessário. Entretanto, o problema surge quando existe a necessidade de guardar informações, mesmo após uma interrupção de energia elétrica. Nessa situação, a memória flash aparece como um elemento indispensável, sendo muito útil para aplicações mais avançadas.

A memória flash é um tipo de memória não volátil, ou seja, mesmo após a interrupção da alimentação elétrica do processador, os dados armazenados em seus blocos de memória continuam intactos, o que impulsiona uma grande aplicabilidade para um dispositivo como esse.

Além da flash, existem outras memórias dessa mesma variação, amplamente utilizadas nos mais variados dispositivos eletrônicos, como a PROM, EPROM e a EEPROM.

Para as necessidades do nosso projeto, utilizar dessa tecnologia será de suma importância para armazenar os dados de temperatura para apresentar no monitor serial, e em casos de queda de energia ou de um reset inesperado, não precisaremos nos preocupar com a perda das informações.

Existem variadas bibliotecas para facilitar o uso da flash no ESP32, e neste caso, utilizaremos a preferences,h, que utiliza uma estrutura de dados semelhante a uma tabela hash para guardar as informações, colaborando com a organização dos nossos projetos.

Para simplificar, sem entrar em muitos detalhes, seguem abaixo os principais métodos para o uso da biblioteca preferences:

Inicialização:

Inicialização:

• begin(namespace, readOnly) → abre/cria um espaço de nomes para salvar dados.
• namespace = identificador (até 15 caracteres).
• readOnly = true/false (padrão: false).

Escrita de valores:

• putInt(key, value) → grava inteiro.
• putFloat(key, value) → grava float.
• putString(key, value) → grava string.
• putBool(key, value) → grava booleano.
• putBytes(key, buffer, length) → grava array de bytes.

Leitura de valores

• getInt(key, default)
• getFloat(key, default)

• getString(key, default)
• getBool(key, default)
• getBytes(key, buffer, length)

Gerenciamento

• remove(key) → apaga um valor específico.
• clear() → apaga todos os valores do namespace.
• end() → fecha o acesso à NVS.

Conhecendo as funções explicadas acima, teremos um exemplo que une tanto as aplicações anteriores com o NTC, quanto o que acabou de ser explicado sobre memória não volátil. Basicamente, temos um circuito muito semelhante ao anterior, com diferenças mais evidentes no software, que usará a memória flash do ESP32 para armazenar o valor de temperatura anterior ao atual.

A informação da temperatura será mostrada a cada dois segundos pelo monitor serial, e ainda conta com um led responsável por informar se foi ultrapassado um limite de temperatura.

#include <Preferences.h>

Preferences prefs;

const int ntcPin = 4;   // Pino analógico do NTC
const int ledPin = 23;   // LED indicador 

// parâmetros do NTC e divisor resistivo
const float BETA = 3950.0;
const float R0 = 10000.0;  
const float Tzero = 298.15;   
const float R_SERIE = 10000.0;

float temperaturaAtual = 0.0;
float temperaturaAnterior = 0.0;
const float LIMITE_TEMP = 30.0;

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

  // Inicia o namespace "ntc" na flash (equivalente à EEPROM no ESP32)
  prefs.begin("ntc", false);

  // Lê o último valor analógico armazenado
  int valorADCAnterior = prefs.getInt("adc", -1);

  if (valorADCAnterior != -1) {
    temperaturaAnterior = calcularTemperatura(valorADCAnterior);
    Serial.println("Recuperando dados salvos na EEPROM (Preferences):");
    Serial.print("ADC anterior: ");
    Serial.print(valorADCAnterior);
    Serial.print(" | Temperatura anterior: ");
    Serial.print(temperaturaAnterior);
    Serial.println(" °C");
  } else {
    Serial.println("Nenhum valor anterior encontrado na EEPROM.");
  }

  Serial.println();
}

void loop() {
  // Lê o valor atual do NTC
  int adcAtual = analogRead(ntcPin);
  temperaturaAtual = calcularTemperatura(adcAtual);

  Serial.println("===== Leitura Atual =====");
  Serial.print("Temperatura anterior: ");
  Serial.print(temperaturaAnterior);
  Serial.println(" °C");

  Serial.print("Temperatura atual: ");
  Serial.print(temperaturaAtual);
  Serial.println(" °C");

  // Atualiza LED conforme limite
  if (temperaturaAtual > LIMITE_TEMP) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }

  // Armazena o valor atual (ADC) na EEPROM/NVS
  prefs.putInt("adc", adcAtual);

  // Atualiza a variável de temperatura anterior em RAM
  temperaturaAnterior = temperaturaAtual;

  Serial.println("==========================\n");
  delay(3000);
}

// Função para converter ADC -> Temperatura (°C)
float calcularTemperatura(int adcValue) {
  if (adcValue <= 0 || adcValue >= 4095) return NAN;

  float Vout = adcValue * 3.3 / 4095.0;

  // NTC para GND (resistor fixo no 3.3V)
  float Rntc = R_SERIE * (3.3 / Vout - 1);

  float tempK = 1.0 / ((1.0 / Tzero) + (1.0 / BETA) * log(Rntc / R0));
  return tempK - 273.15;
}

Conclusão

Utilizar recursos de memória não volátil em projetos DIY pode significar um grande passo na sua evolução como maker. Por isso, além da leitura deste artigo, fica como exercício para o leitor colocar as atividades sugeridas em prática, podendo fazer as adaptações que forem necessárias para sua aplicação particular.

Além disso, com o armazenamento permanente das informações adquiridas nos processos de criação, torna-se muito mais fácil a evolução de um projeto de hobbysta para até mesmo profissional. Em outras palavras, quando entramos mais a fundo nas propriedades das tecnologias que utilizamos, torna-se mais fácil a resolução de problemas por meio da eletrônica e da programação.

Esperamos que este conteúdo amplie seus conhecimentos e sirva como inspiração para novas aplicações. Ao compreender melhor os recursos disponíveis, você terá mais autonomia para desenvolver soluções criativas e robustas, transformando ideias em projetos cada vez mais sólidos e eficazes.

Sobre o autor

Lucas Fernando Técnico em Mecatrônica. Apaixonado por eletrônica e programação, sempre buscando aprender mais sobre o fantástico mundo da tecnologia.