Índice:
O ESP32 possui conversores analógico-digitais, conectividade Wi-Fi e capacidade suficiente para hospedar uma página web. Neste projeto vamos juntar esses recursos para construir um multímetro digital conectado ao Wi-Fi, que pode ser acessado diretamente pelo navegador do celular ou computador.
O projeto terá três funções:
- Medidor de bateria AAA: mostra tensão e uma estimativa visual da carga.
- Ohmímetro: mede resistores e apresenta automaticamente Ω, kΩ ou MΩ.
- Teste de continuidade: identifica baixa resistência e aciona um buzzer.
O mais interessante é que não precisamos instalar nenhum aplicativo. O próprio ESP32 cria o servidor web e disponibiliza o painel do multímetro pelo navegador.
Visão geral do projeto
Nossa montagem utiliza um ESP32 DevKit com ESP-WROOM-32.
A distribuição final dos pinos ficou:
| Função | ESP32 |
| Medição da bateria | GPIO34 / D34 |
| Resistência e continuidade | GPIO35 / D35 |
| Buzzer | GPIO26 / D26 |
| Alimentação do divisor | 3V3 |
| Referência | GND |
Os GPIO34 e GPIO35 são interessantes para esse projeto porque pertencem ao ADC1 do ESP32.
Isso é particularmente importante porque estamos utilizando Wi-Fi. No ESP32 clássico, o ADC2 possui restrições de utilização quando o Wi-Fi está funcionando.
Componentes necessários
Para construir o projeto você precisará de:
- 1 × ESP32 DevKit / ESP-WROOM-32
- 1 × resistor de 10 kΩ para referência
- 1 × buzzer ativo compatível com 3,3 V e de baixa corrente
- 1 × protoboard
- jumpers
- duas pontas de prova
- bateria AAA para teste
- alguns resistores conhecidos para calibração/testes
- cabo USB
Um multímetro convencional também será bastante útil durante a calibração.
Como funciona a medição da bateria
Uma pilha AAA alcalina normalmente apresenta uma tensão muito inferior ao limite de entrada do ESP32.
Como estamos trabalhando especificamente com uma única célula AAA, podemos fazer a leitura diretamente:
PILHA AAA
+ ───────────── GPIO34
– ───────────── GND
Importante: essa ligação direta é apropriada para a pilha de aproximadamente 1,5 V deste projeto. Não conecte baterias ou fontes com tensão superior ao permitido pelo GPIO do ESP32.
O programa realiza várias leituras e calcula uma média.
Além de apresentar a tensão, o dashboard mostra uma estimativa do estado da bateria.
Por exemplo:
1,50 V
██████████████████░
95%
Essa porcentagem não deve ser interpretada como uma medição laboratorial da capacidade restante. A tensão de uma pilha alcalina varia com carga, química, temperatura e histórico de descarga.
Construindo o ohmímetro
Para medir resistência precisamos transformar resistência em uma tensão que o ADC consiga medir.
Para isso utilizamos um divisor resistivo.
A montagem é:
3V3
│
│
[ 10 kΩ ]
│
│
├──────── GPIO35
│
│
[Rx]
│
│
GND
O resistor de 10 kΩ é conhecido e funciona como nossa referência.
Rx é o resistor que queremos descobrir.
Na prática, podemos utilizar duas pontas de prova:
3V3
│
10 kΩ
│
├──────── GPIO35
│
└──────── PONTA 1
GND ─────────── PONTA 2
O resistor desconhecido é colocado entre as duas pontas.
Exemplo com 10 kΩ
Se colocarmos outro resistor de 10 kΩ:
3,3 V
│
10k
│
├──── ADC
│
10k
│
GND
Como os dois resistores possuem aproximadamente o mesmo valor, esperamos encontrar aproximadamente metade da tensão no ponto central.
Em nossos testes reais encontramos: GPIO35 ≈ 1,662 V
Isso confirmou que o divisor estava funcionando corretamente.
Calculando a resistência
A relação do divisor resistivo permite descobrir o resistor desconhecido.
Considerando:
- Rref = resistor conhecido
- Rx = resistor desconhecido
- VADC = tensão medida
- VCC = alimentação
podemos determinar Rx a partir da proporção medida no divisor.
O problema é que, na prática, o ADC do ESP32 não é um instrumento de bancada perfeitamente ideal.
Foi justamente isso que encontramos durante o desenvolvimento.
Calibração real do ESP32
Inicialmente o projeto apresentou um comportamento curioso.
Um resistor real de: 10 kΩ
estava sendo apresentado com valores completamente incorretos.
Então fizemos três medições diretamente no GPIO35.
Pontas abertas
Encontramos: 3171 mV
Resistor de 10 kΩ
Encontramos: 1662 mV
Curto entre GPIO35 e GND
Encontramos: 142 mV
Esse último valor é particularmente interessante.
Teoricamente esperaríamos algo próximo de: 0 mV
mas nosso sistema estava retornando aproximadamente: 142 mV
Por isso não faria sentido simplesmente assumir que a faixa medida fosse exatamente: 0 → 3300 mV
No projeto final utilizamos os valores obtidos experimentalmente para normalizar a leitura:
const float TENSAO_CURTO = 0.142;
const float TENSAO_ABERTO = 3.171;
Isso melhorou muito o comportamento do ohmímetro.
Teste de continuidade
A mesma entrada utilizada para medir resistência também pode ser usada para detectar continuidade.
Isso significa que não precisamos de outra entrada analógica.
A montagem continua sendo:
3V3
│
10k
│
├──────── GPIO35
│
│
pontas de prova
│
GND
Com as pontas abertas:
GPIO35 ≈ 3,17 V
→ circuito aberto
→ buzzer desligado
Ao encostar as pontas:
GPIO35 ≈ 0,142 V
→ curto
→ buzzer ligado
No software adotamos:
const float LIMITE_CONTINUIDADE_VOLTS = 0.250;
Portanto, quando a tensão ficar abaixo de aproximadamente 250 mV, consideramos que existe continuidade.
Ligação do buzzer
Utilizamos o GPIO26:
ESP32 BUZZER
GPIO26 ──────────────── (+)
GND ─────────────────── (-)
Neste tutorial estamos considerando um buzzer ativo de 3,3 V e baixa corrente. Para cargas que exijam corrente maior do que o GPIO pode fornecer com segurança, deve-se utilizar um estágio de acionamento apropriado, como transistor.
Diagrama completo
A montagem final fica:
ESP32
┌─────────────┐
PILHA AAA (+) ───┤ GPIO34 │
│ │
│ GPIO35 ─────┼──── ponto de medição
│ │
BUZZER (+) ──────┤ GPIO26 │
│ │
│ 3V3 │
│ GND │
└─────────────┘
Circuito do GPIO35:
ESP32 3V3
│
│
[10 kΩ]
│
├──────────────── GPIO35
│
└──── PONTA VERMELHA
GND ──────────────────── PONTA PRETA
Bateria:
AAA (+) ───────── GPIO34
AAA (-) ───────── GND
Buzzer:
GPIO26 ───────── (+)
BUZZER
GND ──────────── (-)
Configurando a Arduino IDE
Com o suporte ao ESP32 já instalado, selecione sua placa ESP32 correspondente em:
Ferramentas → Placa → ESP32 Arduino
Selecione a porta COM correta.
Não precisamos instalar biblioteca externa para o servidor web deste projeto. Utilizamos:
#include <WiFi.h>
#include <WebServer.h>
Essas bibliotecas fazem parte do suporte ao ESP32.
Configurando seu Wi-Fi
No começo do programa você encontrará:
const char* ssid = “SEU_WIFI”;
const char* password = “SUA_SENHA”;
Substitua pelos dados da sua rede.
Por exemplo:
const char* ssid = “MinhaRede”;
const char* password = “MinhaSenha”;
O ESP32 e o dispositivo utilizado para abrir o dashboard precisam conseguir se comunicar pela rede local.
Código completo
#include <WiFi.h>
#include <WebServer.h>
// =====================================================
// WIFI
// =====================================================
const char* ssid = "SEU_WIFI";
const char* password = "SUA_SENHA";
// =====================================================
// PINOS
// =====================================================
#define PIN_BATERIA 34
#define PIN_RESISTENCIA 35
#define PIN_BUZZER 26
// =====================================================
// CALIBRAÇÃO
// =====================================================
const float R_REFERENCIA = 10000.0;
// Valores obtidos experimentalmente
const float TENSAO_CURTO = 0.142;
const float TENSAO_ABERTO = 3.171;
const float LIMITE_CONTINUIDADE_VOLTS = 0.250;
// =====================================================
WebServer server(80);
enum Modo {
MODO_BATERIA,
MODO_RESISTENCIA,
MODO_CONTINUIDADE
};
Modo modoAtual = MODO_BATERIA;
// =====================================================
// ADC
// =====================================================
float lerTensaoADC(int pino) {
const int AMOSTRAS = 40;
uint32_t soma_mV = 0;
for (int i = 0; i < AMOSTRAS; i++) {
soma_mV += analogReadMilliVolts(pino);
delay(2);
}
float media_mV =
soma_mV / (float)AMOSTRAS;
return media_mV / 1000.0;
}
// =====================================================
// BATERIA
// =====================================================
float lerTensaoBateria() {
return lerTensaoADC(PIN_BATERIA);
}
int calcularPorcentagem(float v) {
if (v >= 1.55) return 100;
if (v >= 1.50) return 95;
if (v >= 1.45) return 85;
if (v >= 1.40) return 75;
if (v >= 1.35) return 65;
if (v >= 1.30) return 50;
if (v >= 1.25) return 40;
if (v >= 1.20) return 30;
if (v >= 1.15) return 20;
if (v >= 1.10) return 10;
if (v >= 1.05) return 5;
return 0;
}
// =====================================================
// RESISTÊNCIA
// =====================================================
float lerResistencia() {
float tensao =
lerTensaoADC(PIN_RESISTENCIA);
// circuito aberto
if (tensao >= 3.05) {
return -1;
}
// curto
if (tensao <= LIMITE_CONTINUIDADE_VOLTS) {
return 0;
}
float tensaoCorrigida =
tensao - TENSAO_CURTO;
float faixaCorrigida =
TENSAO_ABERTO - TENSAO_CURTO;
float proporcao =
tensaoCorrigida / faixaCorrigida;
if (proporcao <= 0)
return 0;
if (proporcao >= 0.99)
return -1;
float resistencia =
R_REFERENCIA *
proporcao /
(1.0 - proporcao);
return resistencia;
}
// =====================================================
// CONTINUIDADE
// =====================================================
bool temContinuidade() {
float tensao =
lerTensaoADC(PIN_RESISTENCIA);
return tensao <= LIMITE_CONTINUIDADE_VOLTS;
}
// =====================================================
// BUZZER
// =====================================================
void atualizarBuzzer() {
if (modoAtual != MODO_CONTINUIDADE) {
digitalWrite(PIN_BUZZER, LOW);
return;
}
digitalWrite(
PIN_BUZZER,
temContinuidade() ? HIGH : LOW
);
}
// =====================================================
// PÁGINA WEB
// =====================================================
const char pagina[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width,initial-scale=1">
<title>ESP32 Smart Meter</title>
<style>
*{
box-sizing:border-box;
}
body{
margin:0;
min-height:100vh;
display:flex;
justify-content:center;
align-items:center;
background:
radial-gradient(
circle at top,
#263238,
#080b0d
);
font-family:Arial;
color:white;
}
.multimetro{
width:390px;
padding:25px;
border-radius:35px;
background:
linear-gradient(
145deg,
#353b3f,
#15191c
);
border:4px solid #454d52;
box-shadow:
0 30px 70px rgba(0,0,0,.75);
text-align:center;
}
.marca{
font-size:12px;
letter-spacing:4px;
opacity:.6;
}
.titulo{
font-size:23px;
font-weight:bold;
margin:8px 0 18px;
}
.display{
min-height:200px;
padding:18px;
border-radius:12px;
border:8px solid #090b0c;
background:
linear-gradient(
145deg,
#b9cba8,
#8fa581
);
color:#152014;
display:flex;
flex-direction:column;
align-items:center;
justify-content:center;
}
.modo{
font-size:13px;
letter-spacing:2px;
font-weight:bold;
}
.valor{
font-family:"Courier New";
font-size:50px;
font-weight:bold;
margin-top:10px;
}
.unidade{
font-size:20px;
font-weight:bold;
}
.info{
font-size:13px;
font-weight:bold;
margin-top:10px;
}
/* BATERIA */
.bateriaArea{
display:none;
margin-top:15px;
}
.bateria{
width:175px;
height:35px;
border:3px solid #172116;
border-radius:5px;
padding:3px;
position:relative;
}
.bateria::after{
content:"";
position:absolute;
right:-10px;
top:8px;
width:7px;
height:14px;
background:#172116;
}
.carga{
height:100%;
width:0%;
background:#168a35;
transition:
width .6s,
background .6s;
}
/* SELETOR */
.seletorArea{
display:flex;
justify-content:center;
margin-top:25px;
}
.seletor{
width:155px;
height:155px;
border-radius:50%;
border:5px solid #080909;
background:
radial-gradient(
circle,
#555 0%,
#252525 55%,
#111 58%
);
position:relative;
}
.ponteiro{
position:absolute;
width:8px;
height:57px;
top:18px;
left:69px;
background:#f44336;
border-radius:5px;
transform-origin:4px 59px;
transition:transform .4s;
}
/* BOTÕES */
.botoes{
display:flex;
gap:8px;
margin-top:25px;
}
button{
flex:1;
padding:14px 4px;
border:2px solid #444;
border-radius:10px;
background:#24292c;
color:white;
font-weight:bold;
cursor:pointer;
}
button.ativo{
background:#c62828;
border-color:#ff7979;
}
</style>
</head>
<body>
<div class="multimetro">
<div class="marca">
SARA EDUCACAO
</div>
<div class="titulo">
ESP32 SMART METER
</div>
<div class="display">
<div id="modo" class="modo">
BATERIA
</div>
<div id="valor" class="valor">
--.--
</div>
<div id="unidade" class="unidade">
V
</div>
<div id="info" class="info">
Aguardando...
</div>
<div id="bateriaArea"
class="bateriaArea">
<div class="bateria">
<div id="carga"
class="carga">
</div>
</div>
</div>
</div>
<div class="seletorArea">
<div class="seletor">
<div id="ponteiro"
class="ponteiro">
</div>
</div>
</div>
<div class="botoes">
<button id="btnBat"
onclick="selecionar('bateria')">
BATERIA
</button>
<button id="btnOhm"
onclick="selecionar('resistencia')">
Ω OHMS
</button>
<button id="btnCont"
onclick="selecionar('continuidade')">
CONT.
</button>
</div>
</div>
<script>
let modoAtual="bateria";
async function selecionar(novoModo){
modoAtual=novoModo;
await fetch(
"/modo?valor="+novoModo
);
configurarTela();
}
function configurarTela(){
document
.querySelectorAll("button")
.forEach(
b=>b.classList.remove("ativo")
);
const bateria =
document.getElementById(
"bateriaArea"
);
const ponteiro =
document.getElementById(
"ponteiro"
);
bateria.style.display="none";
if(modoAtual==="bateria"){
btnBat.classList.add("ativo");
modo.innerHTML="BATERIA AAA";
ponteiro.style.transform=
"rotate(-55deg)";
bateria.style.display="block";
}
if(modoAtual==="resistencia"){
btnOhm.classList.add("ativo");
modo.innerHTML="RESISTENCIA";
ponteiro.style.transform=
"rotate(0deg)";
}
if(modoAtual==="continuidade"){
btnCont.classList.add("ativo");
modo.innerHTML="CONTINUIDADE";
ponteiro.style.transform=
"rotate(55deg)";
}
}
async function atualizar(){
try{
const resposta =
await fetch("/dados");
const d =
await resposta.json();
modoAtual=d.modo;
configurarTela();
if(modoAtual==="bateria"){
valor.innerHTML=
d.tensao.toFixed(2);
unidade.innerHTML="V";
info.innerHTML=
d.porcentagem+
"% - ESTIMATIVA";
carga.style.width=
d.porcentagem+"%";
if(d.porcentagem>60)
carga.style.background="#168a35";
else if(d.porcentagem>25)
carga.style.background="#d6a400";
else
carga.style.background="#c62828";
}
if(modoAtual==="resistencia"){
if(d.resistencia<0){
valor.innerHTML="OL";
unidade.innerHTML="";
info.innerHTML=
"CIRCUITO ABERTO";
}
else if(d.resistencia>=1000000){
valor.innerHTML=
(d.resistencia/1000000)
.toFixed(2);
unidade.innerHTML="MΩ";
info.innerHTML="RESISTENCIA";
}
else if(d.resistencia>=1000){
valor.innerHTML=
(d.resistencia/1000)
.toFixed(2);
unidade.innerHTML="kΩ";
info.innerHTML="RESISTENCIA";
}
else{
valor.innerHTML=
d.resistencia.toFixed(1);
unidade.innerHTML="Ω";
info.innerHTML="RESISTENCIA";
}
}
if(modoAtual==="continuidade"){
if(d.continuidade){
valor.innerHTML="0";
unidade.innerHTML="Ω";
info.innerHTML=
"CONTINUIDADE - BEEP";
}
else{
if(d.resistencia<0){
valor.innerHTML="OL";
unidade.innerHTML="";
}
else{
valor.innerHTML=
d.resistencia.toFixed(1);
unidade.innerHTML="Ω";
}
info.innerHTML=
"SEM CONTINUIDADE";
}
}
}catch(e){
console.log(e);
}
}
setInterval(atualizar,500);
configurarTela();
atualizar();
</script>
</body>
</html>
)rawliteral";
// =====================================================
// ALTERAÇÃO DO MODO
// =====================================================
void receberModo(){
if(!server.hasArg("valor")){
server.send(
400,
"text/plain",
"Modo ausente"
);
return;
}
String modo =
server.arg("valor");
if(modo=="bateria")
modoAtual=MODO_BATERIA;
else if(modo=="resistencia")
modoAtual=MODO_RESISTENCIA;
else if(modo=="continuidade")
modoAtual=MODO_CONTINUIDADE;
digitalWrite(
PIN_BUZZER,
LOW
);
server.send(
200,
"text/plain",
"OK"
);
}
// =====================================================
// ENVIO DOS DADOS
// =====================================================
void enviarDados(){
float tensao =
lerTensaoBateria();
int porcentagem =
calcularPorcentagem(tensao);
float resistencia =
lerResistencia();
bool continuidade =
temContinuidade();
String nomeModo;
if(modoAtual==MODO_BATERIA)
nomeModo="bateria";
else if(modoAtual==MODO_RESISTENCIA)
nomeModo="resistencia";
else
nomeModo="continuidade";
String json="{";
json +=
"\"modo\":\""+
nomeModo+
"\",";
json +=
"\"tensao\":"+
String(tensao,3)+
",";
json +=
"\"porcentagem\":"+
String(porcentagem)+
",";
json +=
"\"resistencia\":"+
String(resistencia,2)+
",";
json +=
"\"continuidade\":";
json +=
continuidade ?
"true" :
"false";
json += "}";
server.send(
200,
"application/json",
json
);
}
// =====================================================
// SETUP
// =====================================================
void setup(){
Serial.begin(115200);
delay(1000);
pinMode(
PIN_BATERIA,
INPUT
);
pinMode(
PIN_RESISTENCIA,
INPUT
);
pinMode(
PIN_BUZZER,
OUTPUT
);
digitalWrite(
PIN_BUZZER,
LOW
);
analogReadResolution(12);
analogSetPinAttenuation(
PIN_BATERIA,
ADC_11db
);
analogSetPinAttenuation(
PIN_RESISTENCIA,
ADC_11db
);
WiFi.mode(WIFI_STA);
WiFi.begin(
ssid,
password
);
Serial.print(
"Conectando ao WiFi"
);
while(
WiFi.status()!=WL_CONNECTED
){
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println(
"WiFi conectado!"
);
Serial.print(
"Acesse: http://"
);
Serial.println(
WiFi.localIP()
);
server.on(
"/",
[](){
server.send_P(
200,
"text/html",
pagina
);
}
);
server.on(
"/dados",
enviarDados
);
server.on(
"/modo",
receberModo
);
server.begin();
Serial.println(
"Smart Meter iniciado!"
);
}
// =====================================================
// LOOP
// =====================================================
void loop(){
server.handleClient();
atualizarBuzzer();
delay(20);
}Gravando o programa
Depois de colocar o nome e a senha do Wi-Fi, envie o código para o ESP32.
Abra:
Ferramentas → Monitor Serial
Configure:
115200 baud
Depois da inicialização deverá aparecer algo semelhante a:
Conectando ao WiFi….
WiFi conectado!
Acesse:
http://192.168.0.105
Smart Meter iniciado!
O endereço será diferente dependendo da sua rede.
Abrindo o multímetro no celular
Pegue o endereço mostrado no Monitor Serial.
Por exemplo:
http://192.168.0.105
Digite no navegador.
O dashboard apresentará três opções:
BATERIA
Ω OHMS
CONT.
Não existe aplicativo instalado no celular. A página está sendo entregue pelo próprio ESP32 através do Wi-Fi.
Testando uma bateria AAA
Selecione:
BATERIA
Conecte:
AAA (+) → GPIO34
AAA (-) → GND
O display poderá mostrar, por exemplo:
1.42 V
75% – ESTIMATIVA
E o desenho da bateria será preenchido proporcionalmente.
Testando um resistor
Selecione:
OHMS
Coloque um resistor entre as pontas de prova.
Com um resistor de aproximadamente 10 kΩ, devemos obter algo próximo de:
10.0 kΩ
O programa muda automaticamente a unidade de apresentação:
470 Ω
4.70 kΩ
100 kΩ
1.00 MΩ
Dentro das limitações da faixa e da calibração utilizadas.
Um ponto importante: um único resistor de referência de 10 kΩ não oferece a mesma precisão em todas as décadas de resistência. Um multímetro comercial utiliza diferentes escalas e circuitos justamente para melhorar a precisão em uma faixa muito maior.
Testando continuidade
Selecione:
CONT.
Com as pontas separadas:
OL
SEM CONTINUIDADE
O buzzer permanece desligado.
Agora encoste uma ponta na outra.
A tensão no GPIO35 cai para perto do valor de curto utilizado na calibração.
O dashboard apresenta:
0 Ω
CONTINUIDADE – BEEP
e o ESP32 aciona:
GPIO26 → HIGH
fazendo o buzzer tocar.
Por que utilizamos GPIO34 e GPIO35?
Esse detalhe é importante.
Nos primeiros testes, poderíamos ser tentados a utilizar entradas como GPIO4 ou GPIO15 para deixar a montagem fisicamente mais conveniente.
Entretanto, no ESP32 clássico esses pinos estão associados ao ADC2.
Como o projeto utiliza Wi-Fi, isso pode causar problemas.
Por isso nossa versão final utiliza:
GPIO34 → ADC1
GPIO35 → ADC1
e:
GPIO26 → saída digital do buzzer
Essa combinação permite manter o Wi-Fi funcionando enquanto realizamos as medições analógicas.
Cuidados importantes
Este projeto é educacional e não substitui um multímetro comercial, especialmente em aplicações de segurança.
Nunca utilize esta montagem para medir diretamente:
127 V
220 V
rede elétrica
fontes de alta tensão
baterias acima do limite da entrada
Além disso, não meça resistência ou continuidade de um circuito energizado.
Nos modos de resistência e continuidade, nosso próprio circuito aplica uma tensão através do resistor de referência.
Para trabalhar com tensões maiores seria necessário desenvolver um circuito de entrada apropriado, incluindo divisão de tensão, proteção contra sobretensão e outras medidas de segurança.
O que aprendemos com este projeto?
Apesar de parecer apenas um “multímetro com ESP32”, esse projeto envolve vários conceitos muito interessantes:
Eletrônica analógica: divisor resistivo e conversão resistência → tensão.
Conversão A/D: utilização do ADC do ESP32.
Calibração: compensação de diferenças observadas entre o comportamento ideal e as medições reais.
Sistemas embarcados: processamento das medições diretamente no microcontrolador.
Wi-Fi: conexão do ESP32 à rede.
Servidor web: o próprio microcontrolador hospeda a interface.
HTML, CSS e JavaScript: criação de um dashboard interativo.
IoT: um instrumento físico sendo monitorado através de uma interface web.
E esse talvez seja o ponto mais interessante do projeto: o ESP32 não está apenas medindo uma grandeza elétrica. Ele mede, processa, interpreta e publica o resultado através da rede Wi-Fi.
A partir dessa base podemos evoluir o projeto adicionando novas escalas, medição de tensão DC maior com divisor resistivo apropriado, seleção automática de faixa, registro histórico das medições e até envio dos dados para um servidor na nuvem.
Saiba mais sobre a parceria Saravati e Sara Educação
Este “Guia de Montagem” é uma colaboração especial entre a Saravati e a Sara Educação, criado pelo Professor Felipe Rosa. Nosso objetivo é enriquecer a comunidade de entusiastas da eletrônica, IoT e automação com recursos educacionais de alta qualidade. Através dessa parceria, buscamos inspirar e capacitar criadores em seus projetos, disponibilizando esses guias em nosso blog e nas redes sociais.