Sensor de corrente ACS712: meça corrente CC e CA com Arduino

O sensor de corrente ACS712 é um módulo pequeno e barato que detecta a corrente que passa por um circuito usando o efeito Hall e a transforma em uma tensão que o seu Arduino consegue ler. Sem corrente, a saída fica em cerca de 2,5 V; ela sobe quando a corrente passa em um sentido e desce quando passa no outro. Isso significa que dá para medir corrente contínua (CC) e corrente alternada (CA) com um único pino analógico. Ele é usado para ver quanta corrente um motor consome, acompanhar a descarga de uma bateria, detectar se um aparelho está funcionando ou calcular quanta energia um aparelho de casa consome. Além disso, o caminho da corrente medida fica eletricamente isolado do lado do Arduino.

Neste guia você vai aprender passo a passo o que há dentro do ACS712, como os modelos de 5A, 20A e 30A se diferenciam e qual escolher, como ligar o módulo em série com o seu circuito, o primeiro sketch Arduino que mede corrente CC, como acalmar leituras instáveis com médias, como calcular o RMS da corrente CA e como chegar à potência (W) e à energia (Wh). Depois você vai ver como ligá-lo ao ESP32 e ao Raspberry Pi Pico de 3,3 V por um divisor de tensão, por que é preciso muito cuidado com a tensão da rede e por que o INA219 é uma escolha melhor para correntes pequenas.

O que é o sensor de corrente ACS712 e como ele funciona?

O ACS712 é um chip de 8 pinos fabricado pela Allegro. A corrente medida passa por um caminho grosso de cobre dentro do chip, dos pinos 1 e 2 para os pinos 3 e 4. Esse caminho tem uma resistência de apenas 1,2 mΩ; mesmo com 10 A, ele derruba só 12 mV e dissipa 0,12 W, então quase não afeta o circuito medido. Ao passar por esse condutor, a corrente cria um campo magnético proporcional a ela. Um sensor Hall logo acima do caminho de cobre capta esse campo, e um amplificador dentro do chip o transforma em tensão. Você pode ler mais sobre o básico no nosso guia de sensores de efeito Hall.

Não existe ligação elétrica entre o caminho de cobre que leva a corrente e o lado que alimenta o chip; a única ligação entre eles é o campo magnético. Por isso a linha medida e o Arduino ficam isolados um do outro (isolação galvânica). A tensão de saída segue esta fórmula: Vout = VCC / 2 + Sensibilidade × I. Se a corrente vai de IP+ para IP−, a saída sobe acima de 2,5 V; se vai no sentido contrário, a saída cai abaixo disso. O ACS712 também é raciométrico: tanto o ponto zero quanto a sensibilidade acompanham a tensão de alimentação. Se a alimentação cair para 4,8 V, o ponto zero vira 2,4 V e a sensibilidade do modelo de 5A cai de 185 para cerca de 178 mV/A.

Modelos de 5A, 20A e 30A: sensibilidade e resolução

O ACS712 existe em três versões que por fora são idênticas. Para saber qual você tem, leia a marcação no chip: ELC-05B mede ±5 A, ELC-20A ±20 A e ELC-30A ±30 A. A sensibilidade diz quantos milivolts a saída muda para cada 1 A de corrente. Quanto maior a faixa, menor a sensibilidade, para que nos modelos de 20A e 30A a saída fique entre 0,5 e 4,5 V mesmo com a corrente máxima. A tabela abaixo também mostra quantos miliamperes um passo do ADC de 10 bits do Uno (4,88 mV) representa em cada modelo.

Da tabela saem duas conclusões importantes. Primeiro, o ruído expresso em amperes é de cerca de 0,1 A nos três modelos; se você usar o modelo de 30A para uma carga de 2 A, joga fora dois terços da resolução. A regra é simples: escolha o menor modelo que cubra com segurança a maior corrente que você vai medir (o valor de pico, em CA). Por exemplo, o modelo de 5A serve para um motor CC de 12 V que consome no máximo 2–3 A, e o de 20A serve para um aquecedor de 1500 W. Segundo, o ACS712 não foi feito para correntes pequenas: com ele você não mede um LED que consome alguns miliamperes nem um ESP32 em deep sleep. Para isso, o INA219, apresentado no fim deste guia, é muito melhor.

Ligações do ACS712: Arduino Uno, ESP32 e Pico

O módulo ACS712 tem dois lados. O lado do borne de parafuso pertence ao circuito medido: a corrente precisa entrar por um terminal e sair pelo outro, então o módulo é ligado em série com a carga, como um amperímetro. Geralmente você corta o fio positivo da fonte, liga a ponta que vem da fonte em um lado do borne e a ponta que vai para a carga no outro lado. O lado de três pinos vai ao Arduino. O ACS712 só funciona com 5 V; no ESP32 e no Pico você também alimenta o módulo por um pino que fornece 5 V e lê a saída por um divisor de tensão.

Além do chip, o módulo tem pouquíssimas peças: um capacitor de desacoplamento na linha de alimentação, um capacitor pequeno no pino FILTER que define a largura de banda, o LED de alimentação (D1) e o resistor dele (R1). O 102 impresso no R1 significa 1 kΩ; você decifra essas marcações facilmente com a calculadora de código SMD. Como o ACS712 é isolado, você não precisa ligar o negativo do circuito medido ao GND do Arduino quando está só medindo corrente.

Passo a passo: medindo corrente CC com Arduino

1. Ligue o pino VCC do módulo ao 5V do Arduino, o GND ao GND e o OUT ao A0. O LED de alimentação da placa deve acender.
2. Corte o fio positivo do circuito que você quer medir: ligue a ponta que vem da fonte em um lado do borne e a ponta que vai para a carga (por exemplo, um motor de 12 V ou uma fita de LED) no outro lado.
3. Mantenha a fonte da carga desligada e carregue o sketch abaixo. Ao iniciar, ele mede o ponto zero enquanto não passa corrente.
4. Abra o Monitor Serial em 9600 baud; sem corrente, o valor deve ficar perto de 0,00 A e oscilar no máximo alguns centésimos de ampere.
5. Ligue a fonte da carga. Se a corrente aparecer negativa, troque os dois fios do borne ou multiplique o resultado por −1.
6. Ajuste o SENSITIVITY do código para o seu modelo: 0.185 para 5A, 0.100 para 20A e 0.066 para 30A.

1// ACS712 ile DC akım ölçme / DC current measurement with ACS712
2const int SENSOR_PIN = A0;            // ACS712 OUT pini / ACS712 OUT pin
3const float SENSITIVITY = 0.185;      // V/A: 5A=0.185, 20A=0.100, 30A=0.066
4const float ADC_STEP = 5.0 / 1024.0;  // bir ADC basamağı (V) / one ADC step (V)
5const int SAMPLES = 200;              // ortalama için örnek sayısı / samples to average
6
7float zeroRaw = 512.0;                // akım yokken ham değer / raw value at zero current
8
9// SAMPLES kez okuyup ortalamayı döndürür / reads SAMPLES times and returns the average
10float readAverageRaw() {
11  long sum = 0;
12  for (int i = 0; i < SAMPLES; i++) {
13    sum += analogRead(SENSOR_PIN);
14  }
15  return sum / (float)SAMPLES;
16}
17
18void setup() {
19  Serial.begin(9600);
20  delay(500);                         // sensörün oturmasını bekle / let the sensor settle
21  zeroRaw = readAverageRaw();         // yük KAPALIYKEN sıfır noktası / zero point with the load OFF
22  Serial.print(F("Sifir noktasi / Zero point: "));
23  Serial.print(zeroRaw * ADC_STEP, 3);
24  Serial.println(F(" V"));
25}
26
27void loop() {
28  float raw = readAverageRaw();
29  float current = (raw - zeroRaw) * ADC_STEP / SENSITIVITY;  // amper / amps
30
31  Serial.print(F("Akim / Current: "));
32  Serial.print(current, 2);
33  Serial.println(F(" A"));
34  delay(500);
35}

Para cada leitura, o sketch faz a média de 200 resultados de analogRead; como um analogRead leva cerca de 0,11 ms no Uno, isso dá uns 22 ms. A corrente é calculada com I = (raw − zero) × (5 / 1024) / sensibilidade. Por exemplo, no modelo de 5A com ponto zero 512, uma leitura média de 550 é uma diferença de 38 passos; isso equivale a 38 × 4,88 mV = 185,5 mV, então a corrente é 185,5 / 185 ≈ 1,00 A. Medir o ponto zero ao iniciar, em vez de supor 2,5 V, importa porque o offset do próprio chip e pequenas diferenças na linha de terra da placa o deslocam alguns passos, e esse erro se soma a todas as leituras.

Ruído e médias

A saída do ACS712 continua tremendo mesmo com a corrente estável. O primeiro motivo é o ruído do próprio sensor Hall: o fabricante informa os valores de ruído acima com um capacitor de 47 nF no pino FILTER, o que significa cerca de 2 kHz de largura de banda. A maioria dos módulos, porém, usa 1 nF ali, como no circuito de exemplo do fabricante; a largura de banda sobe para 80 kHz e o ruído fica várias vezes maior. O segundo motivo é o ADC: mesmo no modelo de 5A, o Uno mede em passos de 26 mA, e o último passo sempre oscila para cima e para baixo. O ruído aleatório diminui com a raiz quadrada do número de amostras da média: 16 amostras o reduzem a um quarto, 256 amostras a um dezesseis avos. Para outros métodos de filtragem, veja o nosso guia de filtragem de dados de sensores.

• Média de várias amostras: em CC, faça a média de 100–500 amostras. Se você espalhar as amostras por 20 ms, a interferência de 50 Hz da rede também se cancela na média.
• Média móvel exponencial: misture cada leitura nova à antiga com filtrado = filtrado + 0.1 × (novo − filtrado); quase não usa memória e dá um valor calmo no display.
• Zona morta: se você não quer ver valores como 0,03 A sem nada ligado, trate como 0 os resultados com valor absoluto abaixo de 0,05 A.
• Filtro de hardware: se você sabe soldar, ponha um capacitor de 47 nF em paralelo com o do pino FILTER para baixar a largura de banda para cerca de 2 kHz; é mais do que suficiente para CC e para a corrente de 50 Hz da rede.
• Fique longe de campos magnéticos: o ACS712 é um sensor Hall; um ímã, um alto-falante ou outro fio com corrente alta por perto desloca a leitura.
• Atualize o ponto zero: o ponto zero varia alguns milivolts com a temperatura; em projetos que rodam por muito tempo, meça o zero de novo com a carga desligada.

A média remove o ruído, mas não corrige o erro sistemático. A sensibilidade pode variar alguns por cento de um chip para outro; no modelo de 5A, ela fica entre 180 e 190 mV/A. Para a melhor precisão, ligue um multímetro na escala de corrente em série na mesma linha do ACS712, passe uma corrente conhecida, como 1–2 A, e compare os dois valores. Se o multímetro mostrar 2,00 A e o Arduino 1,94 A, o seu fator de correção é 2,00 / 1,94 = 1,031; divida o SENSITIVITY do código por esse número (0.185 / 1.031 ≈ 0.179) e as suas leituras vão bater com o multímetro.

Medindo corrente CA: o cálculo do RMS

A corrente da rede muda de sentido o tempo todo: a frequência é de 50 Hz na Europa e na maior parte do mundo, e de 60 Hz nos EUA e no Brasil. Por isso a saída do ACS712 desenha uma senoide em torno de 2,5 V cuja média corresponde a corrente zero; se você rodar o sketch de CC em uma carga CA, vai ter valores sem sentido perto de 0 A. A grandeza que importa em CA é o valor RMS (eficaz): ele é igual à corrente CC que produziria o mesmo calor, e é o valor usado por multímetros, fusíveis e etiquetas de aparelhos. O cálculo segue o nome em inglês: subtraia o ponto zero de cada amostra, eleve ao quadrado (Square), faça a média dos quadrados (Mean) e tire a raiz quadrada (Root).

O tamanho da janela de medição importa; se ela não tiver um número inteiro de ciclos, o resultado muda um pouco a cada vez. Um ciclo dura 20 ms em 50 Hz e 16,7 ms em 60 Hz. Uma janela de 100 ms tem exatamente 5 ciclos em 50 Hz e exatamente 6 em 60 Hz, então funciona corretamente nas duas redes, e o Uno faz cerca de 900 amostras nesse tempo. Para uma senoide pura, o pico é 1,414 vez o valor RMS, então você também poderia dividir o pico por √2. Mas cargas como carregadores de celular, lâmpadas de LED ou dimmers consomem corrente em picos, não senoidal, e esse atalho erra com elas; o sketch abaixo calcula o RMS verdadeiro, então é muito mais preciso com essas cargas. O valor de pico precisa ficar dentro da faixa do modelo:

1// ACS712 ile AC akım (RMS) ve görünür güç / AC current (RMS) and apparent power with ACS712
2const int SENSOR_PIN = A0;
3const float SENSITIVITY = 0.100;      // 20A modül: 100 mV/A / 20A module: 100 mV/A
4const float ADC_STEP = 5.0 / 1024.0;
5const unsigned long WINDOW_MS = 100;  // 50 Hz'te 5, 60 Hz'te 6 tam periyot / 5 cycles at 50 Hz, 6 at 60 Hz
6const float MAINS_VOLTAGE = 230.0;    // şebeke gerilimi (V) / mains voltage (V)
7
8float noiseRms = 0.0;                 // yük yokken ölçülen gürültü (A) / noise measured with no load (A)
9
10// Pencere boyunca örnek alır, ortalamayı çıkarıp RMS hesaplar / samples over the window, removes the mean, returns RMS
11float readRmsAmps() {
12  long sum = 0;
13  unsigned long sumSq = 0;
14  unsigned int n = 0;
15  unsigned long start = millis();
16  while (millis() - start < WINDOW_MS) {
17    int d = analogRead(SENSOR_PIN) - 512;  // 2,5 V'u sıfıra yaklaştır / shift 2.5 V to about zero
18    sum += d;
19    sumSq += (long)d * d;
20    n++;
21  }
22  float mean = sum / (float)n;                       // sıfır noktası kayması / zero point offset
23  float variance = sumSq / (float)n - mean * mean;   // yalnız AC kısım / AC part only
24  if (variance < 0) variance = 0;
25  return sqrt(variance) * ADC_STEP / SENSITIVITY;
26}
27
28void setup() {
29  Serial.begin(9600);
30  delay(500);
31  noiseRms = readRmsAmps();           // ilk ölçüm yük KAPALIYKEN / first reading with the load OFF
32  Serial.print(F("Gurultu / Noise: "));
33  Serial.print(noiseRms, 3);
34  Serial.println(F(" A"));
35}
36
37void loop() {
38  float irms = readRmsAmps();
39  float sq = irms * irms - noiseRms * noiseRms;  // gürültüyü karesel çıkar / subtract noise in quadrature
40  irms = (sq > 0) ? sqrt(sq) : 0.0;
41  float apparentPower = MAINS_VOLTAGE * irms;     // VA; dirençli yükte ≈ W / VA; ≈ W for resistive loads
42
43  Serial.print(F("Irms: "));
44  Serial.print(irms, 3);
45  Serial.print(F(" A   Guc / Power: "));
46  Serial.print(apparentPower, 1);
47  Serial.println(F(" VA"));
48  delay(1000);
49}

Este sketch não guarda o ponto zero como um número fixo; em cada janela, ele calcula a média das amostras e a subtrai. Matematicamente, isso é a raiz quadrada da variância: RMS² = média dos quadrados − quadrado da média. Como a corrente CA tem média zero ao longo de um número inteiro de ciclos, a média encontrada é exatamente o erro do ponto zero, e ele se corrige sozinho mesmo quando varia com a temperatura. O ruído medido ao iniciar, com a carga desligada, é subtraído em quadratura, porque o ruído e a corrente real são independentes e valores RMS se somam pelos quadrados. Sem esse passo, você veria valores fantasmas como 0,1 A e 23 VA sem nada ligado. Um exemplo: um ferro de passar de 1000 W consome cerca de 4,35 A em 230 V; o pico de 6,1 A passa da faixa do modelo de 5A, então meça com o modelo de 20A.

Um jeito bem mais seguro de medir a corrente de um aparelho doméstico é um transformador de corrente de núcleo dividido, como o SCT-013, que você usa sem cortar nenhum fio. Ele se fecha em volta do cabo como um alicate amperímetro e nunca tem contato metálico com a rede. O único cuidado é que o alicate abrace só o fio fase ou só o neutro; se abraçar os dois juntos, os campos das correntes opostas se cancelam e o resultado é zero. Transformadores de corrente medem só CA; para CC, você precisa do ACS712 ou do INA219.

Calculando potência (W) e energia (Wh)

Sabendo a corrente, a potência é uma única multiplicação: P = V × I. Se uma bateria de 12 V alimenta um motor que consome 1,5 A, a potência é 12 × 1,5 = 18 W; você pode conferir isso com a calculadora da lei de Ohm. Energia é potência multiplicada pelo tempo: se o motor de 18 W funcionar por 2 horas, ele gasta 36 Wh. O sketch faz isso multiplicando a potência pelo tempo decorrido a cada leitura e somando. Para medir a tensão, você pode usar o módulo vendido como sensor de tensão de 0–25 V; ele tem um divisor de tensão de 30 kΩ e 7,5 kΩ e divide a tensão de entrada por 5. Se quiser projetar um divisor com os seus próprios valores de resistor, use a calculadora de divisor de tensão.

1// ACS712 + gerilim sensörü ile güç (W) ve enerji (Wh) / power (W) and energy (Wh) with ACS712 + voltage sensor
2const int CURRENT_PIN = A0;           // ACS712 OUT
3const int VOLTAGE_PIN = A1;           // 0-25 V gerilim sensörü S pini / 0-25 V voltage sensor S pin
4const float SENSITIVITY = 0.185;      // 5A modül / 5A module (V/A)
5const float DIVIDER_RATIO = 5.0;      // (30k + 7,5k) / 7,5k = 5 / divider ratio
6const float ADC_STEP = 5.0 / 1024.0;
7const int SAMPLES = 200;
8
9float zeroRaw = 512.0;
10float energyWh = 0.0;                 // biriken enerji / accumulated energy
11unsigned long lastMs = 0;
12
13float averageRaw(int pin) {
14  long sum = 0;
15  for (int i = 0; i < SAMPLES; i++) sum += analogRead(pin);
16  return sum / (float)SAMPLES;
17}
18
19void setup() {
20  Serial.begin(9600);
21  delay(500);
22  zeroRaw = averageRaw(CURRENT_PIN);  // yük kapalıyken sıfır noktası / zero point with the load off
23  lastMs = millis();
24}
25
26void loop() {
27  float current = (averageRaw(CURRENT_PIN) - zeroRaw) * ADC_STEP / SENSITIVITY;
28  float voltage = averageRaw(VOLTAGE_PIN) * ADC_STEP * DIVIDER_RATIO;
29  float power = voltage * current;    // P = V x I (W)
30
31  unsigned long now = millis();
32  energyWh += power * (now - lastMs) / 3600000.0;  // W x saat = Wh / W x hours = Wh
33  lastMs = now;
34
35  Serial.print(voltage, 2);  Serial.print(F(" V   "));
36  Serial.print(current, 2);  Serial.print(F(" A   "));
37  Serial.print(power, 1);    Serial.print(F(" W   "));
38  Serial.print(energyWh, 3); Serial.println(F(" Wh"));
39  delay(1000);
40}

Como o módulo de tensão se liga entre o positivo e o negativo do circuito medido, desta vez o negativo do circuito e o GND do Arduino precisam ser unidos; você descobre por quê no nosso guia de GND comum. Para estimar quantas horas uma bateria vai durar, combine a corrente média medida com os cálculos de mAh e Wh ou com a calculadora de autonomia da bateria. No lado CA, as coisas mudam um pouco: Vrms × Irms é a potência aparente, medida em VA; a potência real (W) é esse valor multiplicado pelo fator de potência. Para cargas resistivas, como chaleiras, ferros de passar e lâmpadas incandescentes, o fator de potência é muito próximo de 1, então VA ≈ W. Para motores, adaptadores e lâmpadas de LED, ele pode ficar entre 0,5 e 0,9; para medir a potência real, você também precisa amostrar a forma de onda da tensão ao mesmo tempo, o que se faz com módulos sensores de tensão isolados, como o ZMPT101B.

ACS712 com ESP32: leitura por um divisor de tensão

O ESP32 funciona com 3,3 V e as entradas analógicas dele medem até cerca de 3,1 V; aplicar mais de 3,6 V a um pino pode danificar a placa. Já o ACS712 só funciona com 5 V, e a saída dele pode chegar a 4,5 V nos modelos de 20A e 30A e a quase 5 V em sobrecorrente. Então você alimenta o sensor pelo pino 5V da placa ESP32 (VIN em algumas placas) e passa o OUT por um divisor de tensão. 10 kΩ + 20 kΩ é uma boa escolha: vá do OUT por 10 kΩ até o pino do ESP32 e, desse mesmo ponto, por 20 kΩ até o GND. A razão é 20 / 30 = 0,667, e o total de 30 kΩ atende com folga a carga mínima de 4,7 kΩ do ACS712.

O código tem dois detalhes. Primeiro, o ADC do ESP32 não é linear perto dos extremos, então, em vez dos valores brutos, usamos analogReadMilliVolts(), que aplica os dados de calibração gravados no chip na fábrica. O GPIO 34 fica no ADC1 e funciona com o Wi-Fi ligado; os pinos do ADC2 não podem ser usados junto com o Wi-Fi. Segundo, a comodidade raciométrica do Uno não existe aqui: a referência do ADC do ESP32 é fixa, mas a sensibilidade do ACS712 muda com os 5 V que vêm do USB. A solução é um truque simples: como a saída é metade do VCC sem corrente, multiplique por 2 o ponto zero medido ao iniciar para obter a tensão real de alimentação do sensor e corrija a sensibilidade de acordo. Como o mesmo erro está no ponto zero e no sinal medido, esse método também compensa a tolerância dos resistores do divisor. O sketch amostra por 100 ms e devolve dois resultados juntos: olhe o primeiro número para uma carga CC e o segundo para um aparelho da rede.

1// ESP32 + ACS712 (10k/20k gerilim bölücüyle) / ESP32 + ACS712 (with a 10k/20k voltage divider)
2const int SENSOR_PIN = 34;            // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
3const float DIVIDER = 20.0 / 30.0;    // R2 / (R1 + R2) = 20k / 30k
4const float SENS_AT_5V = 185.0;       // mV/A: 5A=185, 20A=100, 30A=66
5const unsigned long WINDOW_MS = 100;  // 50 Hz'te 5 tam periyot / 5 full cycles at 50 Hz
6
7float zeroMv = 2500.0;                // akım yokken sensör çıkışı (mV) / sensor output at zero current (mV)
8float sensMv = SENS_AT_5V;            // düzeltilmiş hassasiyet (mV/A) / corrected sensitivity (mV/A)
9
10// Bölücüden önceki gerilimin ortalaması (mV) / average voltage before the divider (mV)
11float averageMv(int samples) {
12  uint32_t sum = 0;
13  for (int i = 0; i < samples; i++) sum += analogReadMilliVolts(SENSOR_PIN);
14  return sum / (float)samples / DIVIDER;
15}
16
17// Pencere boyunca okur: DC (ortalama) ve AC (RMS) akım / reads over the window: DC (mean) and AC (RMS) current
18void measure(float &dcAmps, float &acAmps) {
19  double sum = 0, sumSq = 0;
20  uint32_t n = 0;
21  uint32_t start = millis();
22  while (millis() - start < WINDOW_MS) {
23    double d = analogReadMilliVolts(SENSOR_PIN) / DIVIDER - zeroMv;
24    sum += d;
25    sumSq += d * d;
26    n++;
27  }
28  double mean = sum / n;
29  double variance = sumSq / n - mean * mean;
30  if (variance < 0) variance = 0;
31  dcAmps = mean / sensMv;
32  acAmps = sqrt(variance) / sensMv;
33}
34
35void setup() {
36  Serial.begin(115200);
37  analogReadResolution(12);
38  delay(500);
39  zeroMv = averageMv(1000);                    // yük KAPALIYKEN / with the load OFF
40  sensMv = SENS_AT_5V * (2.0 * zeroMv) / 5000.0;  // oransal düzeltme: VCC = 2 x sıfır / ratiometric fix: VCC = 2 x zero
41  Serial.printf("Sifir / Zero: %.0f mV  Hassasiyet / Sensitivity: %.1f mV/A\n", zeroMv, sensMv);
42}
43
44void loop() {
45  float dc, ac;
46  measure(dc, ac);
47  Serial.printf("DC: %.2f A   AC (RMS): %.2f A\n", dc, ac);
48  delay(1000);
49}

ACS712 com Raspberry Pi Pico e MicroPython

O Raspberry Pi Pico também funciona com 3,3 V, então as ligações são as mesmas do ESP32: ligue o VCC do ACS712 ao VBUS (pino 40), que fornece 5 V enquanto o Pico é alimentado pelo USB, e o OUT, pelo mesmo divisor 10k/20k, ao GP26 (ADC0, pino 31). No MicroPython, read_u16() retorna um valor de 0 a 65535, e tensão = raw × 3.3 / 65535. O ADC do Pico é de 12 bits; com o divisor, no papel ele mede em passos de cerca de 6,5 mA no modelo de 5A, umas quatro vezes mais fino que o Uno. O código abaixo mede o ponto zero ao iniciar, aplica a correção raciométrica e depois mostra a corrente CC e a RMS em CA a cada segundo.

1from machine import ADC
2import time
3import math
4
5adc = ADC(26)            # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6VREF = 3.3               # ADC referansı (V) / ADC reference (V)
7DIVIDER = 20 / 30        # 10k/20k bölücü oranı / 10k/20k divider ratio
8SENS_AT_5V = 0.185       # V/A: 5A=0.185, 20A=0.100, 30A=0.066
9
10
11def read_volts(samples=200):
12    # bölücüden önceki ortalama gerilim / average voltage before the divider
13    total = 0
14    for _ in range(samples):
15        total += adc.read_u16()          # 0-65535
16    return total / samples * VREF / 65535 / DIVIDER
17
18
19zero = read_volts(1000)                  # yük KAPALIYKEN / with the load OFF
20sens = SENS_AT_5V * (2 * zero) / 5.0     # oransal düzeltme / ratiometric correction
21print("Sifir / Zero: {:.3f} V".format(zero))
22
23
24def read_rms(window_ms=100):
25    # 100 ms = 50 Hz'te 5 periyot / 5 cycles at 50 Hz
26    n = 0
27    s = 0.0
28    s2 = 0.0
29    start = time.ticks_ms()
30    while time.ticks_diff(time.ticks_ms(), start) < window_ms:
31        v = adc.read_u16() * VREF / 65535 / DIVIDER - zero
32        s += v
33        s2 += v * v
34        n += 1
35    mean = s / n
36    return math.sqrt(max(s2 / n - mean * mean, 0)) / sens
37
38
39while True:
40    dc = (read_volts() - zero) / sens
41    print("DC: {:.2f} A   AC (RMS): {:.2f} A".format(dc, read_rms()))
42    time.sleep(1)

ACS712 ou INA219?

O INA219 é um chip de monitoramento de corrente e tensão da Texas Instruments que se comunica por I2C. Em vez do efeito Hall, ele mede a queda de tensão em um pequeno resistor shunt (geralmente de 0,1 Ω nos módulos) pelo qual a corrente passa. Os módulos populares medem até ±3,2 A com resolução de cerca de 0,8 mA, leem sozinhos a tensão do barramento até 26 V e calculam a potência dentro do chip. Assim, com uma única conexão I2C você tem tensão, corrente e potência juntas, sem mexer com ADC, médias ou calibração de zero. Por outro lado, ele não oferece isolação entre o circuito medido e o Arduino, não mede corrente CA e não passa de 26 V.

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(9600);
8  if (!ina219.begin()) {
9    Serial.println(F("INA219 bulunamadi / INA219 not found"));
10    while (true) delay(10);
11  }
12  // ina219.setCalibration_16V_400mA();  // küçük akımda daha ince çözünürlük / finer resolution for small currents
13}
14
15void loop() {
16  float busV = ina219.getBusVoltage_V();        // yük tarafındaki gerilim / voltage on the load side
17  float current_mA = ina219.getCurrent_mA();    // akım (mA) / current (mA)
18  float power_mW = ina219.getPower_mW();        // güç (mW) / power (mW)
19
20  Serial.print(busV, 2);       Serial.print(F(" V   "));
21  Serial.print(current_mA, 1); Serial.print(F(" mA   "));
22  Serial.print(power_mW, 0);   Serial.println(F(" mW"));
23  delay(1000);
24}

Para o código, instale a biblioteca Adafruit INA219 pelo Gerenciador de Bibliotecas. Ligue os pinos SDA e SCL do módulo ao A4 e ao A5 do Uno; a corrente medida precisa entrar pelo VIN+ e sair pelo VIN− em direção à carga, e o GND do INA219 precisa ser comum com o circuito medido. Resumindo: se você mede corrente CC de alguns miliamperes até 3 A junto com a tensão, escolha o INA219; se precisa de correntes maiores, corrente CA ou isolação, o ACS712 é a escolha certa.

Ideias de projetos com o ACS712

• Proteção contra sobrecorrente do motor: quando um motor CC controlado por um L298N trava, a corrente dispara; pare o motor e toque um alarme quando passar do seu limite.
• Monitor de bateria e painel solar: meça a corrente de carga e descarga com o sentido, multiplique pela tensão, acumule os Wh e mostre os resultados em um display OLED.
• Tomada inteligente: ligue e desligue a tomada com um módulo relé, use o ACS712 para conferir se o aparelho está mesmo funcionando e envie os dados para o Home Assistant por MQTT.
• Aviso de máquina de lavar pronta: quando a corrente ficar abaixo de um valor definido por alguns minutos, faça o ESP32 mandar uma mensagem pelo Telegram.
• Alarme de bomba funcionando a seco: quando a água acaba, a corrente consumida pela bomba cai; detecte isso e desligue a bomba.
• Registrador de energia: grave a corrente e a potência uma vez por minuto em um cartão SD ou no Google Sheets e monte um gráfico do consumo diário.
• Medidor de potência de bancada: acrescente um ACS712 ao projeto do voltímetro com Arduino para montar um instrumento que mostra tensão, corrente e potência em uma só tela.

Erros comuns e soluções

O ACS712 é um ótimo jeito de começar a aprender medição de corrente: com um pino analógico você mede corrente CC e CA, e com algumas linhas de código também tem potência e energia. Se você escolher o modelo certo, medir o ponto zero, fizer a média das amostras e calibrar com um multímetro, terá resultados confiáveis com poucos por cento de erro. Você pode reforçar o básico da leitura analógica no nosso guia de ADC. No app BlueGrays você encontra projetos como leitura de sensor analógico, um voltímetro digital com LCD, controle de uma lâmpada da rede com relé e um datalogger com ESP32, cada um com esquemas de circuito e código passo a passo.