Sensor de corriente ACS712: medir corriente DC y AC con Arduino

El sensor de corriente ACS712 es un módulo pequeño y barato que detecta la corriente que pasa por un circuito mediante el efecto Hall y la convierte en una tensión que tu Arduino puede leer. Sin corriente, su salida está en unos 2,5 V; sube cuando la corriente circula en un sentido y baja cuando circula en el otro. Así puedes medir tanto corriente continua (DC) como corriente alterna (AC) con un solo pin analógico. Se usa para ver cuánta corriente consume un motor, seguir la descarga de una batería, saber si un aparato está funcionando o calcular la potencia que gasta un electrodoméstico. Además, la línea medida queda aislada eléctricamente del lado del Arduino.

En esta guía aprenderás paso a paso qué hay dentro del ACS712, en qué se diferencian los modelos de 5A, 20A y 30A y cuál elegir, cómo conectar el módulo en serie con tu circuito, el primer código de Arduino para medir corriente continua, cómo calmar las lecturas inestables promediando, cómo calcular el valor RMS de la corriente alterna y cómo obtener la potencia (W) y la energía (Wh). Después verás cómo conectarlo al ESP32 y a la Raspberry Pi Pico de 3,3 V con un divisor de tensión, por qué debes tener muchísimo cuidado con la red de 220–230 V y por qué el INA219 es mejor opción para corrientes pequeñas.

¿Qué es el sensor de corriente ACS712 y cómo funciona?

El ACS712 es un chip de 8 pines fabricado por Allegro. La corriente que mides atraviesa un camino grueso de cobre dentro del chip, de los pines 1 y 2 a los pines 3 y 4. Ese camino tiene una resistencia de solo 1,2 mΩ; incluso a 10 A cae apenas 12 mV y disipa 0,12 W, así que casi no afecta al circuito que mides. Al pasar la corriente por este conductor se crea un campo magnético proporcional a ella. Un sensor Hall situado justo encima del cobre detecta ese campo y un amplificador interno lo convierte en tensión. Puedes ver los fundamentos con más detalle en nuestra guía de sensores de efecto Hall.

No hay conexión eléctrica entre el camino de cobre por el que pasa la corriente y el lado que alimenta el chip; el único vínculo es el campo magnético. Por eso la línea medida y el Arduino están aislados entre sí (aislamiento galvánico). La tensión de salida sigue esta fórmula: Vout = VCC / 2 + Sensibilidad × I. Si la corriente va de IP+ a IP−, la salida sube por encima de 2,5 V; si va en sentido contrario, baja. El ACS712 también es ratiométrico: tanto el punto cero como la sensibilidad cambian con la tensión de alimentación. Si la alimentación baja a 4,8 V, el punto cero pasa a 2,4 V y la sensibilidad del modelo de 5A cae de 185 a unos 178 mV/A.

Modelos de 5A, 20A y 30A: sensibilidad y resolución

El ACS712 tiene tres versiones que por fuera son idénticas. Para saber cuál tienes, mira la marca del chip: ELC-05B mide ±5 A, ELC-20A ±20 A y ELC-30A ±30 A. La sensibilidad indica cuántos milivoltios cambia la salida por cada amperio. Cuanto mayor es el rango, menor es la sensibilidad, de modo que en los modelos de 20A y 30A la salida se mantiene entre 0,5 y 4,5 V incluso con la corriente máxima. La tabla también muestra a cuántos miliamperios equivale un paso del ADC de 10 bits del Uno (4,88 mV) en cada modelo.

De la tabla salen dos conclusiones importantes. Primero, el ruido expresado en amperios es de unos 0,1 A en los tres modelos; si usas el de 30A para una carga de 2 A, desperdicias dos tercios de la resolución. La regla es sencilla: elige el modelo más pequeño que cubra con margen la corriente máxima que vas a medir (en AC, el valor de pico). Por ejemplo, para un motor de 12 V que consume como mucho 2–3 A va bien el de 5A, y para una estufa de 1500 W, el de 20A. Segundo, el ACS712 no está pensado para corrientes pequeñas: no podrás medir con él un LED de pocos miliamperios ni un ESP32 en sueño profundo. Para eso, el INA219 que verás al final de esta guía es mucho mejor.

Conexión del ACS712: Arduino Uno, ESP32 y Pico

El módulo ACS712 tiene dos lados. El lado de la bornera pertenece al circuito que mides: la corriente debe entrar por un terminal y salir por el otro, así que el módulo se conecta en serie con la carga, igual que un amperímetro. Normalmente cortas el cable positivo de la fuente, conectas el extremo que viene de la fuente a un lado de la bornera y el extremo que va a la carga al otro. El lado de tres pines va al Arduino. El ACS712 solo funciona con 5 V; en el ESP32 y la Pico también lo alimentas desde un pin de 5 V y lees su salida a través de un divisor de tensión.

Aparte del chip, el módulo lleva muy pocos componentes: un condensador de desacoplo en la alimentación, un pequeño condensador en el pin FILTER que fija el ancho de banda, el LED de encendido (D1) y su resistencia (R1). El 102 impreso en R1 significa 1 kΩ; puedes descifrar estos códigos fácilmente con la calculadora de códigos SMD. Como el ACS712 está aislado, si solo mides corriente no hace falta unir el negativo del circuito medido con el GND del Arduino.

Paso a paso: medir corriente continua con Arduino

1. Conecta VCC del módulo al pin 5V del Arduino, GND a GND y OUT a A0. El LED de encendido de la placa debería iluminarse.
2. Corta el cable positivo del circuito que quieres medir: el extremo que viene de la fuente va a un lado de la bornera y el que va a la carga (por ejemplo, un motor de 12 V o una tira LED), al otro.
3. Deja la fuente de la carga apagada y sube el código de abajo. Al arrancar mide el punto cero mientras no circula corriente.
4. Abre el Monitor Serie a 9600 baudios; sin corriente, el valor debe quedarse cerca de 0,00 A y variar como mucho unas centésimas de amperio.
5. Enciende la fuente de la carga. Si la corriente sale negativa, intercambia los dos cables de la bornera o multiplica el resultado por −1.
6. Ajusta SENSITIVITY en el código según tu modelo: 0.185 para 5A, 0.100 para 20A y 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}

En cada medición el código promedia 200 lecturas de analogRead; como un analogRead tarda unos 0,11 ms en el Uno, son unos 22 ms. La corriente se calcula con I = (bruto − cero) × (5 / 1024) / sensibilidad. Por ejemplo, en el modelo de 5A con un punto cero de 512, una media de 550 supone una diferencia de 38 pasos; eso son 38 × 4,88 mV = 185,5 mV y la corriente es 185,5 / 185 ≈ 1,00 A. Medir el punto cero al arrancar en lugar de suponer 2,5 V es importante, porque el desvío propio del chip y pequeñas diferencias en la línea de masa lo mueven unos pasos, y ese error se suma a cada lectura.

Ruido y promediado

La salida del ACS712 tiembla sin parar incluso con corriente constante. La primera causa es el ruido propio del sensor Hall: el fabricante da las cifras de ruido de arriba con un condensador de 47 nF en el pin FILTER, es decir, unos 2 kHz de ancho de banda. Sin embargo, la mayoría de los módulos llevan ahí 1 nF, como el circuito de ejemplo del fabricante; el ancho de banda sube a 80 kHz y el ruido es varias veces mayor. La segunda causa es el ADC: incluso con el modelo de 5A, el Uno mide en pasos de 26 mA y el último paso siempre baila arriba y abajo. El ruido aleatorio baja con la raíz cuadrada del número de muestras promediadas: 16 muestras lo reducen a la cuarta parte y 256 a la dieciseisava parte. Para otros métodos de filtrado, consulta nuestra guía para filtrar datos de sensores.

• Promedio de muchas muestras: En DC, promedia 100–500 muestras. Si las repartes en 20 ms, la interferencia de 50 Hz de la red también se anula en la media.
• Media móvil exponencial: Mezcla cada lectura nueva con la anterior usando filtro = filtro + 0,1 × (nuevo − filtro); casi no usa memoria y da un valor estable en pantalla.
• Zona muerta: Si no quieres ver valores como 0,03 A sin nada conectado, toma como 0 los resultados cuyo valor absoluto sea menor que 0,05 A.
• Filtro por hardware: Si sabes soldar, añade un condensador de 47 nF en paralelo con el del pin FILTER para bajar el ancho de banda a unos 2 kHz; es más que suficiente para DC y para la corriente de red de 50 Hz.
• Aléjalo de campos magnéticos: El ACS712 es un sensor Hall; un imán, un altavoz u otro cable con mucha corriente cerca desplazan la lectura.
• Renueva el punto cero: El punto cero se desplaza unos milivoltios con la temperatura; en proyectos que funcionan mucho tiempo, vuelve a medirlo con la carga apagada.

Promediar elimina el ruido, pero no corrige el error sistemático. La sensibilidad puede variar unos pocos por ciento de un chip a otro; en el modelo de 5A está entre 180 y 190 mV/A. Para la mejor precisión, conecta un multímetro en la escala de corriente en serie en la misma línea que el ACS712, haz pasar una corriente conocida de 1–2 A y compara los dos valores. Si el multímetro marca 2,00 A y el Arduino 1,94 A, tu factor de corrección es 2,00 / 1,94 = 1,031; divide SENSITIVITY en el código entre ese número (0,185 / 1,031 ≈ 0,179) y tu medida coincidirá con la del multímetro.

Medir corriente alterna: el cálculo RMS

La corriente de la red cambia de sentido continuamente: 50 Hz en España, Argentina o Chile, y 60 Hz en México, Colombia o EE. UU. Por eso la salida del ACS712 dibuja una onda senoidal alrededor de 2,5 V cuya media corresponde a corriente cero; si ejecutas el código de DC con una carga de AC, verás valores sin sentido cercanos a 0 A. En alterna lo que importa es el valor RMS (eficaz): equivale a la corriente continua que produciría el mismo calor y es el valor que usan multímetros, fusibles y etiquetas de los aparatos. El cálculo sigue su nombre en inglés: resta el punto cero a cada muestra, elévala al cuadrado (Square), calcula la media de los cuadrados (Mean) y saca la raíz cuadrada (Root).

La duración de la ventana de medida importa; si no contiene un número entero de ciclos, el resultado cambia un poco cada vez. Un ciclo dura 20 ms a 50 Hz y 16,7 ms a 60 Hz. Una ventana de 100 ms contiene exactamente 5 ciclos a 50 Hz y 6 a 60 Hz, así que funciona bien en ambas redes, y el Uno toma unas 900 muestras en ese tiempo. En una senoide pura el pico es 1,414 veces el valor RMS, por lo que también podrías dividir el pico entre √2. Pero cargas como cargadores de móvil, bombillas LED o reguladores de luz consumen corrientes en picos, no senoidales, y ese atajo falla; el código de abajo calcula el RMS verdadero y es mucho más preciso con ellas. El valor de pico debe quedar dentro del rango del 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 código no guarda el punto cero como un número fijo; en cada ventana calcula la media de las muestras y la resta. Matemáticamente es la raíz cuadrada de la varianza: RMS² = media de los cuadrados − cuadrado de la media. Como la corriente alterna promedia cero en un número entero de ciclos, la media obtenida es justo el error del punto cero y se corrige sola aunque varíe con la temperatura. El ruido medido al arrancar con la carga apagada se resta de forma cuadrática, porque el ruido y la corriente real son independientes y los valores RMS se suman por sus cuadrados. Sin este paso verías valores fantasma como 0,1 A y 23 VA sin nada conectado. Un ejemplo: una plancha de 1000 W consume unos 4,35 A a 230 V; su pico de 6,1 A supera el rango del modelo de 5A, así que mídela con el de 20A.

Una forma mucho más segura de medir la corriente de un electrodoméstico es un transformador de corriente de núcleo partido como el SCT-013, que se usa sin cortar ningún cable. Se coloca alrededor del cable como una pinza amperimétrica y no tiene ningún contacto metálico con la red. Lo único que debes vigilar es que la pinza rodee solo la fase o solo el neutro; si rodeas los dos conductores a la vez, los campos de las corrientes opuestas se anulan y el resultado es cero. Los transformadores de corriente solo miden alterna; para continua necesitas el ACS712 o el INA219.

Cálculo de potencia (W) y energía (Wh)

Una vez conoces la corriente, la potencia es una simple multiplicación: P = V × I. Si una batería de 12 V alimenta un motor que consume 1,5 A, la potencia es 12 × 1,5 = 18 W; puedes comprobarlo con la calculadora de la ley de Ohm. La energía es la potencia por el tiempo: si el motor de 18 W funciona 2 horas, gasta 36 Wh. El código lo hace multiplicando en cada lectura la potencia por el tiempo transcurrido y sumándolo. Para medir la tensión puedes usar el módulo que se vende como sensor de voltaje de 0–25 V; lleva un divisor de tensión de 30 kΩ y 7,5 kΩ que divide la tensión de entrada entre 5. Si quieres diseñar un divisor con tus propios valores, usa la calculadora de divisor de tensión.

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 el módulo de tensión se conecta entre el positivo y el negativo del circuito medido, esta vez el negativo del circuito y el GND del Arduino deben estar unidos; el porqué lo explicamos en la guía sobre la masa común. Para estimar cuántas horas durará una batería, combina la corriente media que mides con los cálculos de mAh y Wh o con la calculadora de duración de batería. En alterna la cosa cambia un poco: Vrms × Irms es la potencia aparente, en VA; la potencia real (W) es eso multiplicado por el factor de potencia. En cargas resistivas como hervidores, planchas y bombillas incandescentes el factor de potencia es casi 1, así que VA ≈ W. En motores, adaptadores y bombillas LED puede estar entre 0,5 y 0,9; para medir la potencia real hay que muestrear también la forma de onda de la tensión al mismo tiempo, y para ello se usan módulos sensores de tensión aislados como el ZMPT101B.

ACS712 con ESP32: lectura con divisor de tensión

El ESP32 funciona a 3,3 V y sus entradas analógicas miden hasta unos 3,1 V; aplicar más de 3,6 V a un pin puede dañar la placa. El ACS712, en cambio, solo funciona a 5 V, y su salida puede llegar a 4,5 V en los modelos de 20A y 30A y casi a 5 V con sobrecorriente. Por eso alimentas el sensor desde el pin 5V de la placa ESP32 (VIN en algunas placas) y pasas OUT por un divisor de tensión. 10 kΩ + 20 kΩ es una buena elección: de OUT a través de 10 kΩ al pin del ESP32, y desde ese mismo punto a través de 20 kΩ a GND. La relación es 20 / 30 = 0,667, y los 30 kΩ totales cumplen de sobra la carga mínima de 4,7 kΩ que pide el ACS712.

El código tiene dos detalles. Primero, el ADC del ESP32 no es lineal en los extremos, así que en lugar de valores brutos usamos analogReadMilliVolts(), que aplica los datos de calibración grabados en el chip en fábrica. GPIO 34 pertenece al ADC1 y funciona con el Wi-Fi activo; los pines del ADC2 no se pueden usar junto con el Wi-Fi. Segundo, aquí no existe la ventaja ratiométrica del Uno: la referencia del ADC del ESP32 es fija, pero la sensibilidad del ACS712 cambia con los 5 V que llegan del USB. La solución es un truco sencillo: como sin corriente la salida es la mitad de VCC, multiplicas por 2 el punto cero medido al arrancar, obtienes la tensión real de alimentación del sensor y corriges la sensibilidad en consecuencia. Como el mismo error está tanto en el punto cero como en la señal medida, este método compensa también la tolerancia de las resistencias del divisor. El código muestrea durante 100 ms y devuelve dos resultados a la vez: mira el primero con una carga de continua y el segundo con un aparato de red.

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 con Raspberry Pi Pico y MicroPython

La Raspberry Pi Pico también funciona a 3,3 V, así que la conexión es igual que en el ESP32: conecta VCC del ACS712 a VBUS (pin 40), que da 5 V cuando la Pico se alimenta por USB, y OUT a GP26 (ADC0, pin 31) a través del mismo divisor 10k/20k. En MicroPython, read_u16() devuelve un valor de 0 a 65535 y la tensión = bruto × 3,3 / 65535. El ADC de la Pico es de 12 bits; con el divisor, en teoría mide en pasos de unos 6,5 mA con el modelo de 5A, unas cuatro veces más fino que el Uno. El código de abajo mide el punto cero al arrancar, aplica la corrección ratiométrica y luego imprime cada segundo la corriente DC y la corriente AC en RMS.

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 o INA219?

El INA219 es un chip de medida de corriente y tensión de Texas Instruments que se comunica por I2C. En lugar del efecto Hall, mide la caída de tensión en una pequeña resistencia shunt (normalmente 0,1 Ω en los módulos) por la que pasa la corriente. Los módulos populares miden hasta ±3,2 A con una resolución de unos 0,8 mA, leen ellos mismos la tensión del bus hasta 26 V y calculan la potencia dentro del chip. Es decir, con una sola conexión I2C obtienes tensión, corriente y potencia juntas, sin pelearte con el ADC, el promediado ni la calibración del cero. A cambio, no hay aislamiento entre el circuito medido y el Arduino, no mide corriente alterna y no pasa 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 el código, instala la librería Adafruit INA219 desde el Gestor de Librerías. Conecta SDA y SCL del módulo a A4 y A5 en el Uno; la corriente medida debe entrar por VIN+ y salir por VIN− hacia la carga, y el GND del INA219 debe ser común con el circuito medido. En resumen: si vas a medir corriente continua desde unos pocos miliamperios hasta 3 A junto con la tensión, elige el INA219; si necesitas corrientes mayores, corriente alterna o aislamiento, el ACS712 es la opción correcta.

Ideas de proyectos con el ACS712

• Protección de motor contra sobrecorriente: Cuando un motor de continua controlado con un L298N se bloquea, la corriente se dispara; detén el motor y haz sonar un aviso al superar tu umbral.
• Monitor de batería y panel solar: Mide la corriente de carga y descarga con su sentido, multiplícala por la tensión, acumula los Wh y muestra los resultados en una pantalla OLED.
• Enchufe inteligente: Conmuta el enchufe con un módulo de relé, comprueba con el ACS712 si el aparato funciona de verdad y envía los datos a Home Assistant por MQTT.
• Aviso de lavadora terminada: Cuando la corriente se mantiene unos minutos por debajo de un valor, el ESP32 te envía un mensaje por Telegram.
• Alarma de bomba en seco: Cuando se acaba el agua, baja la corriente que consume la bomba; detéctalo y apágala.
• Registrador de energía: Guarda la corriente y la potencia una vez por minuto en una tarjeta SD o en Hojas de cálculo de Google y dibuja el consumo diario.
• Medidor de potencia de banco: Añade un ACS712 al proyecto de voltímetro con Arduino y crea un instrumento que muestre tensión, corriente y potencia en una misma pantalla.

Errores comunes y soluciones

El ACS712 es una forma estupenda de empezar a medir corriente: con un solo pin analógico mides corriente continua y alterna, y con unas pocas líneas de código obtienes también potencia y energía. Si eliges el modelo adecuado, mides el punto cero, promedias y calibras con un multímetro, conseguirás resultados fiables con un error de pocos por ciento. Puedes reforzar los fundamentos de la lectura analógica en nuestra guía del ADC. En la app BlueGrays encontrarás proyectos como lectura de sensores analógicos, un voltímetro digital con LCD, el control de una bombilla de 220 V con relé y un registrador de datos con ESP32, cada uno con su esquema y su código paso a paso.