INA219 com Arduino: como medir corrente, tensão e potência
Como ligar o sensor de corrente INA219 ao Arduino, ESP32 e Pico? Shunt de 0,1 Ω, limite de 26 V/3,2 A, calibração, medição de painel solar e bateria e comparação com o ACS712.
O INA219 é a forma mais prática de medir corrente, tensão e potência ao mesmo tempo em projetos com Arduino. Este pequeno chip da Texas Instruments calcula digitalmente a corrente que passa por um resistor shunt ligado em série com o seu circuito, a tensão do lado da carga e a potência, que é o produto das duas. Ele envia os resultados por apenas dois fios I2C. Os módulos típicos têm um shunt de 0,1 Ω e, dessa forma, o sensor consegue medir uma linha de até 26 V e correntes de até cerca de ±3,2 A, em passos de aproximadamente 0,1 mA.
Se você quer saber quanta potência um painel solar produz ao longo do dia, em quantas horas um projeto com ESP32 vai esgotar a bateria ou quanta corrente um motor puxa sob carga, este é exatamente o sensor de que você precisa. Neste post você vai aprender, passo a passo, como o shunt funciona, as faixas de medição, a conta da calibração, códigos que funcionam no Arduino Uno, no ESP32 e no Raspberry Pi Pico, e como ele se diferencia do ACS712.
O que é o INA219 e como ele funciona?
O INA219 se baseia na lei de Ohm. Um resistor de precisão de valor muito baixo (o shunt) é colocado no caminho da corrente; quando a corrente passa por ele, surge entre seus terminais uma pequena queda de tensão proporcional à corrente. Com um shunt de 0,1 Ω, 1 A gera 100 mV e 250 mA geram 25 mV (V = I × R). O amplificador de ganho programável (PGA) e o ADC de 12 bits do chip leem essa tensão na casa dos milivolts e a guardam no registrador de tensão do shunt em passos de 10 µV. O chip também mede, com resolução de 4 mV, a tensão entre o terminal do shunt do lado da carga (Vin−) e o GND; isso se chama tensão do barramento (bus voltage). Depois que o valor correto é gravado no registrador de calibração, o INA219 calcula corrente e potência internamente, e o microcontrolador não precisa multiplicar nem dividir nada. Como o shunt fica entre o positivo da fonte e a carga, isso se chama medição no lado alto (high-side), e o GND da carga não é alterado. A corrente é medida nos dois sentidos: a que vai de Vin+ para Vin− é positiva, e a do sentido contrário aparece negativa.
| Característica | Valor |
|---|---|
| Chip | Texas Instruments INA219 (versões A e B) |
| Comunicação | I2C / SMBus, com suporte ao modo rápido de 400 kHz |
| Alimentação (VCC) | 3,0–5,5 V |
| Tensão de barramento medível | 0–26 V (faixa do registrador definida em 16 V ou 32 V) |
| Faixa de tensão do shunt | ±40, ±80, ±160 ou ±320 mV (selecionada pelo PGA) |
| Shunt do módulo | 0,1 Ω (marcado R100) |
| Corrente máxima (com 0,1 Ω) | Cerca de ±3,2 A |
| ADC | 12 bits, tempo de conversão de 532 µs, média interna de até 128 amostras |
| Precisão | INA219B: erro máximo de 0,5% em toda a faixa de temperatura (1% na versão A) |
| Endereço I2C | 0x40 (0x41, 0x44, 0x45 com as pontes A0/A1) |
Resistor shunt e faixa de medição
A corrente máxima que o INA219 consegue medir é definida pelo valor do shunt e pela configuração do PGA: I_max = V_shunt,max / R_shunt. Numa faixa estreita, tensões pequenas são lidas com menos erro, enquanto uma faixa larga permite chegar a correntes maiores. A potência dissipada no shunt é P = I² × R: com 3,2 A, um shunt de 0,1 Ω transforma cerca de 1 W em calor, e a queda de 320 mV sobre ele também reduz a tensão que chega à carga. Para correntes maiores, dá para trocar o shunt por um menor, como 0,01 Ω, mas as trilhas finas de cobre e os bornes do módulo normalmente são projetados para cerca de 3 A. Para correntes muito pequenas, um shunt de 1 Ω deixa o passo dez vezes mais fino: 10 µV / 1 Ω = 10 µA. Com o shunt de 0,1 Ω do módulo, as quatro opções são:
| Ajuste do PGA | Faixa de tensão do shunt | Corrente máx. (0,1 Ω) | Quando usar |
|---|---|---|---|
| /1 | ±40 mV | ±400 mA | Sensores, placas microcontroladoras, circuitos de baixa corrente |
| /2 | ±80 mV | ±800 mA | Fitas de LED curtas, um único servo motor |
| /4 | ±160 mV | ±1,6 A | Motores CC pequenos, minibombas |
| /8 (padrão) | ±320 mV | ±3,2 A | Painéis solares, motores, uso geral |
Ligação do INA219: Arduino Uno, ESP32 e Pico
| Pino do INA219 | Arduino Uno | ESP32 | Raspberry Pi Pico | Função |
|---|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT), pino 36 | Alimentação do chip |
| GND | GND | GND | GND | GND comum (também deve ser ligado ao negativo da carga) |
| SCL | A5 | GPIO 22 | GP5 (pino 7) | Linha de clock do I2C |
| SDA | A4 | GPIO 21 | GP4 (pino 6) | Linha de dados do I2C |
| Vin+ | Positivo da fonte | Positivo da fonte | Positivo da fonte | Por onde a corrente entra |
| Vin− | Positivo da carga | Positivo da carga | Positivo da carga | Por onde a corrente sai |
Pense no caminho da corrente como uma corrente de elos: positivo da fonte, Vin+, shunt, Vin−, positivo da carga, negativo da carga e, por fim, negativo da fonte. O INA219 entra nessa sequência em série, igual a um amperímetro. O negativo da fonte, o negativo da carga e o pino GND do módulo precisam estar todos ligados entre si; caso contrário, a leitura da tensão do barramento não faz sentido, mesmo que a corrente pareça correta (veja o post sobre GND comum para mais detalhes). No Uno, você também pode usar os pinos SDA/SCL perto do canto superior da placa em vez de A4/A5; são as mesmas linhas. A maioria dos módulos já vem com resistores de pull-up no I2C, então não é preciso resistor extra. No ESP32 e no Pico, se você alimentar o módulo pelo 3V3, esses pull-ups também puxam para 3,3 V e seus pinos ficam protegidos.
Passo a passo: sua primeira medição com o Arduino Uno
- Abra o Gerenciador de Bibliotecas no Arduino IDE, busque a biblioteca Adafruit INA219 e aceite a dependência Adafruit BusIO quando for solicitado. Se você nunca instalou uma biblioteca, veja como instalar bibliotecas.
- Ligue os pinos VCC, GND, SDA e SCL do módulo ao Uno conforme a tabela.
- Escolha a carga que você quer medir: por exemplo, um LED vermelho com resistor de 220 Ω numa bateria de 9 V, ou um pequeno motor CC. Ligue o positivo da bateria ao Vin+ e o Vin− ao positivo da carga.
- Ligue o negativo da bateria tanto ao negativo da carga quanto ao pino GND do INA219, para que Uno, bateria e carga compartilhem um GND comum.
- Carregue o código, abra o Monitor Serial em 115200 baud e compare a corrente lida com a de um multímetro ligado em série.
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219; // varsayılan adres 0x40 / default address 0x40
5
6void setup() {
7 Serial.begin(115200);
8 if (!ina219.begin()) { // sensörü ve I2C'yi başlat / start sensor and I2C
9 Serial.println(F("INA219 bulunamadi / INA219 not found"));
10 while (1) { delay(10); }
11 }
12 // ina219.setCalibration_32V_1A(); // daha ince adım / finer steps
13 // ina219.setCalibration_16V_400mA(); // küçük akımlar / small currents
14 Serial.println(F("INA219 hazir / ready"));
15}
16
17void loop() {
18 float shunt_mV = ina219.getShuntVoltage_mV(); // şönt üzerindeki gerilim / voltage across the shunt
19 float bus_V = ina219.getBusVoltage_V(); // Vin- ile GND arası / Vin- to GND
20 float current_mA = ina219.getCurrent_mA(); // akım / current
21 float power_mW = ina219.getPower_mW(); // güç / power
22 float source_V = bus_V + shunt_mV / 1000.0; // kaynak gerilimi / source voltage
23
24 Serial.print(F("Kaynak: ")); Serial.print(source_V, 2); Serial.print(F(" V "));
25 Serial.print(F("Yuk: ")); Serial.print(bus_V, 2); Serial.print(F(" V "));
26 Serial.print(F("Sont: ")); Serial.print(shunt_mV, 2); Serial.print(F(" mV "));
27 Serial.print(F("Akim: ")); Serial.print(current_mA, 1); Serial.print(F(" mA "));
28 Serial.print(F("Guc: ")); Serial.print(power_mW, 0); Serial.println(F(" mW"));
29 delay(1000);
30}| Função | Valor retornado |
|---|---|
| ina219.begin() (inicialização) | Retorna true se o sensor for encontrado; também inicia o barramento I2C |
| getShuntVoltage_mV() (tensão do shunt) | Tensão sobre o shunt (mV) |
| getBusVoltage_V() (tensão do barramento) | Tensão entre Vin− e GND, ou seja, a tensão que a carga recebe (V) |
| getCurrent_mA() (corrente) | Corrente calculada a partir da calibração (mA), negativa no sentido inverso |
| getPower_mW() (potência) | Produto da corrente pela tensão do barramento (mW) |
| bus_V + shunt_mV / 1000 (tensão da fonte) | A tensão da própria fonte, antes do shunt (V) |
No exemplo com bateria de 9 V e LED vermelho com resistor de 220 Ω, a corrente fica em torno de (9 − 2) / 220 ≈ 32 mA; cerca de 3,2 mV caem sobre o shunt e a potência total do circuito é 9 V × 32 mA ≈ 290 mW. À medida que a bateria se desgasta, você pode acompanhar ao vivo a tensão caindo para 8 V e a corrente diminuindo junto. Ver valores pequenos como 0,1–0,5 mA sem nenhuma carga ligada é normal; eles vêm de um pequeno offset na entrada do chip e não significam que a sua medição esteja com defeito.
Calibração: a chave para uma medição precisa
Quando o INA219 é ligado, o registrador de calibração está em zero; por isso, embora você consiga ler as tensões do shunt e do barramento imediatamente, os registradores de corrente e potência ficam em zero. O valor de calibração vem de duas fórmulas do datasheet: primeiro calcule Current_LSB = corrente máxima esperada / 32768 e arredonde para um número conveniente; depois encontre Cal = 0,04096 / (Current_LSB × R_shunt). O passo do registrador de potência é sempre 20 vezes o Current_LSB. Com o shunt de 0,1 Ω do módulo e 3,2 A, Current_LSB = 3,2 / 32768 ≈ 97,7 µA, que se arredonda para 100 µA; Cal = 0,04096 / (0,0001 × 0,1) = 4096 e o passo de potência é 2 mW. A biblioteca da Adafruit oferece três perfis prontos que fazem essa conta para você:
| Função | Faixa do barramento | Faixa do shunt | Corrente máx. | Passo de corrente |
|---|---|---|---|---|
| setCalibration_32V_2A() (padrão) | 32 V | ±320 mV | ≈3,2 A | 0,1 mA |
| setCalibration_32V_1A() (perfil de 1 A) | 32 V | ±320 mV | ≈1,3 A | 0,04 mA |
| setCalibration_16V_400mA() (perfil de 400 mA) | 16 V | ±40 mV | ≈400 mA | 0,05 mA |
O “32 V” da tabela é apenas a faixa do registrador; o limite real do chip continua sendo 26 V. Se você trocou o shunt, os perfis prontos vão dar resultados errados. A solução mais fácil é calcular a corrente você mesmo: corrente (mA) = getShuntVoltage_mV() / R_shunt (Ω). Por exemplo, se você lê 15 mV com um shunt de 1 Ω, a corrente é 15 mA. Para fazer um ajuste fino com uma referência confiável, use a fórmula de correção do datasheet: Cal_novo = Cal × (corrente mostrada pelo multímetro / corrente mostrada pelo INA219). Se o multímetro mostra 500 mA e o INA219 mostra 495 mA, você grava 4096 × 500 / 495 ≈ 4137. Como o registrador de calibração zera quando a alimentação é cortada, a biblioteca da Adafruit regrava o valor antes de cada leitura de corrente; se você escrever o seu próprio código, também deve reenviar a calibração toda vez que iniciar o sensor. Você vai ver a gravação direta no registrador na seção do Pico.
Consumo de bateria com o ESP32: contador de mAh e mWh
Para saber quanto tempo uma bateria vai durar, o consumo total importa mais do que a corrente instantânea. A carga total é o acúmulo da corrente ao longo do tempo: multiplique a corrente (mA) pelo tempo decorrido (horas) a cada medição e some tudo para obter mAh; faça o mesmo com a potência para obter mWh. O código abaixo usa os pinos I2C padrão do ESP32 (SDA 21, SCL 22), seleciona o perfil 32V_1A para ter passos mais finos e atualiza os totais a cada meio segundo. Como não usa nenhuma função que dependa de versão, ele compila sem alterações com o core ESP32 Arduino 2.x e 3.x.
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219(0x40);
5
6float totalmAh = 0.0; // toplam yük / total charge
7float totalmWh = 0.0; // toplam enerji / total energy
8unsigned long lastMs = 0;
9
10void setup() {
11 Serial.begin(115200);
12 Wire.begin(21, 22); // SDA, SCL
13 if (!ina219.begin(&Wire)) {
14 Serial.println("INA219 bulunamadi / not found");
15 while (true) { delay(10); }
16 }
17 ina219.setCalibration_32V_1A(); // 1,3 A'e kadar, 0,04 mA adım / up to 1.3 A, 0.04 mA steps
18 lastMs = millis();
19}
20
21void loop() {
22 unsigned long now = millis();
23 if (now - lastMs >= 500) {
24 float hours = (now - lastMs) / 3600000.0; // geçen süre (saat) / elapsed time (hours)
25 lastMs = now;
26
27 float busV = ina219.getBusVoltage_V();
28 float currentmA = ina219.getCurrent_mA();
29 float powermW = ina219.getPower_mW();
30
31 totalmAh += currentmA * hours; // mA x saat = mAh / mA x hours = mAh
32 totalmWh += powermW * hours; // mW x saat = mWh / mW x hours = mWh
33
34 Serial.printf("%.2f V %.1f mA %.0f mW | %.3f mAh %.2f mWh\n",
35 busV, currentmA, powermW, totalmAh, totalmWh);
36 }
37}Por exemplo, se um nó sensor puxa 45 mA em média, uma célula 18650 de 2500 mAh dura, em teoria, 2500 / 45 ≈ 55 horas; na prática, por causa das perdas de conversão e de não descarregar a célula totalmente, é realista contar com 70–80% disso. Você pode fazer essa conta rapidamente com a calculadora Autonomia da bateria. Cuidado com testes de deep sleep: com um shunt de 0,1 Ω, o passo real é de cerca de 0,1 mA, então uma corrente de repouso na casa dos microampères aparece como zero. A maioria das placas de desenvolvimento puxa alguns mA mesmo dormindo, por causa do chip USB-serial e do regulador, e o INA219 mostra isso com facilidade. Para ver a corrente de repouso de cerca de 10 µA de um módulo ESP32 sozinho, você precisa de um shunt de 1–10 Ω; a corrente máxima então cai para algo entre 320 mA e 32 mA, e você não consegue medir a corrente com o ESP32 acordado na mesma configuração.
Raspberry Pi Pico e MicroPython: o INA219 pelos registradores
No MicroPython, controlar o INA219 diretamente pelos registradores, sem nenhuma biblioteca, é fácil e muito instrutivo. O valor 0x399F que gravamos no registrador de configuração (0x00) seleciona a faixa de 32 V, PGA /8, resolução de 12 bits e modo de medição contínua; esse também é o padrão do chip ao ligar. Em seguida, 4096 é gravado no registrador de calibração (0x05). A tensão do shunt (0x01) e a corrente (0x04) são números de 16 bits com sinal; no registrador de tensão do barramento (0x02), os 3 bits mais baixos são descartados e o valor é multiplicado por 4 mV. Se você salvar o código no Thonny como main.py, o Pico começa a medir toda vez que for ligado. Se trocar o shunt, basta atualizar R_SHUNT e CURRENT_LSB; o Cal é calculado automaticamente. Se você está começando no MicroPython, o post fundamentos do MicroPython é um bom ponto de partida.
1from machine import Pin, I2C
2import time
3
4ADDR = 0x40 # A0, A1 boşta / A0, A1 open
5R_SHUNT = 0.1 # ohm, modüldeki R100 / the module's R100
6CURRENT_LSB = 0.0001 # 0,1 mA/bit
7CAL = round(0.04096 / (CURRENT_LSB * R_SHUNT)) # = 4096
8
9i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
10
11def write_reg(reg, value):
12 i2c.writeto_mem(ADDR, reg, bytes([(value >> 8) & 0xFF, value & 0xFF]))
13
14def read_reg(reg, signed=False):
15 d = i2c.readfrom_mem(ADDR, reg, 2)
16 v = (d[0] << 8) | d[1]
17 if signed and v > 32767: # ikiye tümleyen / two's complement
18 v -= 65536
19 return v
20
21print("Bulunan / found:", [hex(a) for a in i2c.scan()])
22write_reg(0x00, 0x399F) # 32 V, PGA /8, 12 bit, sürekli / 32 V, PGA /8, 12-bit, continuous
23write_reg(0x05, CAL) # kalibrasyon / calibration
24
25while True:
26 shunt_mv = read_reg(0x01, True) * 0.01 # 10 uV/bit
27 bus_v = (read_reg(0x02) >> 3) * 0.004 # 4 mV/bit
28 current_ma = read_reg(0x04, True) * CURRENT_LSB * 1000
29 power_mw = read_reg(0x03) * CURRENT_LSB * 20 * 1000 # güç adımı = 20 x LSB / power step = 20 x LSB
30 print("{:.2f} V {:.2f} mV {:.1f} mA {:.0f} mW".format(bus_v, shunt_mv, current_ma, power_mw))
31 time.sleep(1)Medição de painéis solares e carga de baterias
Em projetos com painel solar, o INA219 é ligado entre o positivo do painel e o circuito de carga ou a carga, e mostra a potência real que o painel está produzindo naquele momento. Lembre-se de que você só vê a potência nominal com uma carga adequada: sem carga, a corrente é zero e a tensão é a tensão de circuito aberto (Voc). Um pequeno painel de 6 V e 2 W fornece cerca de 330 mA em sol pleno; num dia nublado, isso pode cair para um décimo. Registrando medições uma vez por minuto, você pode calcular a produção diária de energia em Wh, ver o efeito do ângulo do painel ou comparar um painel fixo com um seguidor solar. Painéis vendidos como “12 V” têm tensão de circuito aberto em torno de 21–22 V; isso ainda é seguro para o INA219, mas se você ligar dois painéis em série, ultrapassa o limite de 26 V. Em sistemas com painel e bateria, se você colocar o INA219 entre a bateria e o circuito, com Vin+ voltado para a bateria e Vin− para o circuito, aproveita a medição bidirecional: a corrente aparece positiva enquanto a bateria alimenta o circuito e negativa enquanto ela carrega. Assim você também consegue ver quanta corrente um módulo carregador como o TP4056 realmente entrega à bateria.
INA219 ou ACS712?

| Característica | INA219 | ACS712 (5 A) |
|---|---|---|
| Princípio de medição | Resistor shunt + ADC | Efeito Hall |
| Saída | Digital (I2C) | Tensão analógica (VCC/2 com corrente zero) |
| O que mede | Corrente, tensão e potência | Só corrente |
| Tipo de corrente | Só DC | AC e DC |
| Faixa | ±3,2 A (com shunt de 0,1 Ω), até 26 V | ±5 A (também existem versões de 20 A e 30 A) |
| Resolução | Cerca de 0,1 mA | 185 mV/A; cerca de 26 mA por passo com o ADC do Uno |
| Isolação | Nenhuma | Sim (2,1 kV RMS) |
| Alimentação | 3,0–5,5 V | 5 V |
Resumindo: para circuitos DC abaixo de alguns ampères, para medir baterias e painéis solares e para projetos com microcontrolador de baixa corrente, o INA219 é muito mais preciso e prático; além disso, não ocupa nenhum pino analógico e até quatro sensores podem compartilhar o mesmo barramento I2C. Monitorar corrente AC do lado da rede elétrica, passar de 5 A ou querer isolação elétrica entre o circuito medido e o microcontrolador é território do ACS712; veja o post sobre o sensor de corrente ACS712 para mais detalhes. Se você precisa de tensões acima de 26 V ou de mais resolução, o INA226 (36 V, 16 bits), da mesma família, é a melhor escolha, e o INA3221 reúne três canais num só chip. Se quiser medir tensões numa faixa maior, o método do divisor de tensão do post sobre voltímetro com Arduino também é um bom complemento.
Ideias de projetos com o INA219
- Medidor de potência USB: passe a linha de 5 V de um cabo USB pelo INA219 e mostre num display OLED quantos mA um carregador de celular ou uma placa Arduino puxa.
- Registrador de energia solar: meça a potência do painel uma vez por minuto com um ESP32, salve num cartão SD e calcule a produção diária em Wh.
- Testador de capacidade de bateria: descarregue uma célula 18650 por uma carga de resistor fixo até 3,0 V e descubra a capacidade real pelos mAh acumulados (veja o que é mAh).
- Alarme de travamento do motor: pare o motor CC quando a corrente dele dobrar; ideal para detectar uma roda presa em carrinhos robô.
- Proteção contra funcionamento a seco da bomba: quando a água acaba, a corrente de uma minibomba cai visivelmente; detecte essa queda e desligue a bomba para prolongar a vida útil dela.
- Display para fonte de bancada: mostre ao vivo, num LCD I2C, a tensão, a corrente e a potência de saída de uma fonte ajustável.
Erros comuns e como corrigir
| Sintoma | Causa provável | Solução |
|---|---|---|
| Mensagem “INA219 not found” (INA219 não encontrado) | SDA/SCL invertidos, VCC desligado ou endereço diferente | Confira os fios e descubra o endereço com um scanner I2C (0x40–0x45) |
| Corrente aparece negativa | Vin+ e Vin− estão invertidos | Ligue a fonte ao Vin+ e a carga ao Vin−, ou inverta o sinal no software |
| Corrente certa, tensão em 0 ou sem sentido | O negativo da carga e o GND do INA219 não estão em comum | Una os GNDs da fonte, da carga e do módulo |
| Corrente sempre em 0 | Nenhuma carga ligada, módulo ligado em paralelo ou corrente abaixo do passo | Confira a ligação em série; use um shunt maior para correntes muito pequenas |
| Valor travado em torno de 3,2 A | Faixa de tensão do shunt ultrapassada | Reduza a carga ou use um shunt menor e calcule a corrente você mesmo |
| Leituras ficam pulando | Motor ou LED acionado por PWM, ruído nos fios | Tire uma média, aumente o número de amostras internas, aplique um filtro no software |
| Módulo esquentou ou queimou | Ligação em paralelo (curto-circuito) ou corrente acima de 3 A | Ligue sempre o módulo em série e use um fusível na linha |
Com um único módulo pequeno, o INA219 dá ao seu projeto um voltímetro, um amperímetro e um wattímetro de uma vez; por trás de muitas ideias, de painéis solares e autonomia de bateria a proteção de motores e medidores de potência USB, está uma medição precisa. No app BlueGrays você encontra projetos como voltímetro digital com LCD, deep sleep no ESP32, registrador de temperatura e irrigação inteligente, com esquemas do circuito e códigos passo a passo, e pode adicionar o INA219 a eles para começar a medir o consumo na hora.
Perguntas frequentes
Quantos ampères o INA219 consegue medir no máximo?
Com o shunt de 0,1 Ω dos módulos prontos, o INA219 mede até cerca de ±3,2 A, porque o limite de tensão do shunt do chip é ±320 mV. Se você trocar o shunt por um resistor menor, como 0,01 Ω, a faixa teórica sobe para 32 A; mas, como as trilhas de cobre e os bornes do módulo não são feitos para essa corrente, você precisaria levar o shunt e fios grossos para fora da placa.
O INA219 mede corrente AC?
Não. O INA219 foi projetado para circuitos DC, e a tensão nos terminais dele deve ficar entre 0–26 V; ligá-lo à rede elétrica destruiria o chip e colocaria sua vida em risco. Para corrente AC, usam-se sensores de efeito Hall com isolação, como o ACS712, ou transformadores de corrente, como o SCT-013.
Como mudar o endereço I2C do INA219?
As pontes de solda A0 e A1 do módulo definem o endereço: 0x40 com as duas abertas, 0x41 só com A0 fechada, 0x44 só com A1 fechada e 0x45 com as duas fechadas. No código, basta indicar o endereço como Adafruit_INA219 ina219(0x41);. Assim você pode ligar quatro INA219 diferentes no mesmo barramento I2C.
Qual é a diferença entre o INA219 e o INA226?
O INA226 é o membro mais avançado da mesma família: a tensão do barramento vai até 36 V e o ADC de 16 bits dá uma resolução muito maior. O INA219 é mais barato e mais comum, com um suporte muito amplo de bibliotecas para Arduino. Para projetos hobby abaixo de 26 V e de alguns ampères, o INA219 é mais do que suficiente.
O INA219 funciona com 3,3 V?
Sim, a faixa de alimentação do INA219 é de 3,0–5,5 V. No ESP32 e no Raspberry Pi Pico, alimentar o módulo pelo pino 3V3 mantém as linhas I2C também em 3,3 V. A tensão de alimentação não limita a linha medida; um INA219 alimentado com 3,3 V continua medindo uma linha de até 26 V.
Por que o INA219 mostra uma corrente pequena mesmo sem carga?
A entrada do shunt do chip tem um offset de algumas dezenas de microvolts; com um shunt de 0,1 Ω, isso significa uma leitura pequena de 0,1–0,5 mA. Você pode eliminar esse erro registrando o valor lido sem carga e subtraindo-o das medições seguintes, ou tirando a média de várias leituras.
Projetos para montar depois desta leitura
Ver todos os projetos
Voltímetro digital com display LCD
Descubra a tensão de uma pilha ou de um adaptador de alimentação com um medidor feito por você.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

Uso do display LCD com I2C
Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

Display LCD I2C com ESP32 (16x2)
Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

