HX711 Arduino: celda de carga, calibración y báscula digital

La pareja HX711 y Arduino es la forma más popular y barata de leer la señal de microvoltios de una celda de carga y convertirla en un peso en gramos. Una báscula de cocina, una báscula de baño, una báscula para colmenas, un comedero que vigila la comida de tu mascota o un banco de empuje para motores se basan en la misma idea: la celda de carga se dobla una cantidad invisible bajo el peso, el HX711 convierte ese cambio diminuto en un número de 24 bits y el Arduino lo pasa a gramos con un factor de calibración.

En esta guía aprenderás cómo funciona el puente de Wheatstone dentro de una celda de carga, qué significan los colores de los cables (E+, E-, A+, A-), cómo conectar cuatro celdas de medio puente de 50 kg sacadas de una báscula de baño y cómo hacer la tara y encontrar el factor de calibración paso a paso con la librería HX711. Después montarás una báscula digital con pantalla LCD y botón de tara, verás por qué las lecturas tiemblan y cómo estabilizarlas, y al final harás lo mismo con un ESP32 con pantalla OLED y con una Raspberry Pi Pico (MicroPython).

¿Qué es una celda de carga y cómo funciona?

Una celda de carga es una pieza de aluminio o acero con galgas extensiométricas (strain gauges) pegadas encima. Una galga es una resistencia grabada en zigzag sobre una lámina fina: cuando el metal se estira, la pista se alarga y se estrecha y su resistencia aumenta; cuando se comprime, disminuye. El cambio es increíblemente pequeño. Una galga con un factor de galga de aproximadamente 2 cambia su resistencia solo un 0,2 por ciento con una deformación de una milésima; en una galga de 1000 Ω son 2 Ω, algo que un analogRead() normal nunca podría detectar.

Para que ese cambio diminuto se pueda medir, cuatro galgas se conectan formando un puente de Wheatstone. El puente son simplemente dos divisores de tensión uno al lado del otro: la alimentación va entre E+ y E-, y A+ y A- son los puntos medios de los dos divisores. Sin carga, las cuatro resistencias son iguales, ambos puntos medios están a la misma tensión y la salida es cero. Al aplicar carga, dos galgas se estiran y dos se comprimen; un punto medio sube y el otro baja. Si llamamos R1 y R2 a las resistencias superior e inferior del divisor izquierdo y R3 y R4 a las del derecho, la salida es Vsal = Vexc × (R4/(R3+R4) − R2/(R1+R2)) y crece en proporción al peso. Puedes probar la idea del divisor con la calculadora de divisor de tensión.

Un valor como 1 mV/V en la etiqueta de una celda de carga es su sensibilidad: a plena capacidad, la celda da 1 mV por cada voltio de excitación. Como el módulo HX711 alimenta el puente con unos 4,3 V, una celda de 5 kg produce solo 4,3 mV con 5 kg y apenas 0,86 µV por gramo. Por eso hace falta un ADC específico de 24 bits con ganancia de 128.

En la tabla hay un detalle importante: el valor bruto no depende de la tensión de alimentación. El HX711 usa la tensión que alimenta el puente (AVDD) también como referencia de medida; si la alimentación baja un poco, la salida del puente baja en la misma proporción y el resultado no cambia. A esto se le llama medida ratiométrica. Como regla aproximada, la plena capacidad de una celda de 1 mV/V equivale a unas 2.147.000 cuentas. Si lo divides entre la capacidad de la celda en gramos, obtienes un factor de calibración aproximado: ≈ 2150 para 1 kg, ≈ 430 para 5 kg y ≈ 107 para 20 kg.

¿Qué es el módulo HX711? Características técnicas

El HX711 es un ADC sigma-delta de 24 bits fabricado por Avia Semiconductor para aplicaciones de pesaje. Incluye un amplificador de ganancia programable (PGA), un regulador que alimenta el puente y un oscilador interno, y se comunica con el exterior por solo dos cables mediante un protocolo serie propio y sencillo. Ese protocolo no es I2C: cuando la línea DT (DOUT) pasa a LOW, hay un dato listo, y el Arduino lee los 24 bits uno a uno enviando de 25 a 27 pulsos por la línea SCK. El número de pulsos elige el canal y la ganancia de la siguiente lectura: 25 pulsos significan canal A con ganancia 128, 26 pulsos canal B con 32 y 27 pulsos canal A con 64.

En la mayoría de los módulos verdes baratos, el pin RATE está unido a GND en la placa, así que el módulo hace 10 lecturas por segundo. 10 SPS tiene menos ruido y además rechaza las interferencias de la red de 50/60 Hz, por lo que suele ser la mejor opción para pesar. Si la línea SCK se queda en HIGH más de 60 µs, el HX711 entra en modo de reposo y también corta la alimentación del puente. En proyectos a batería esto resulta útil con las funciones power_down() y power_up().

Tipos de celda de carga: ¿qué capacidad elegir?

Elige una capacidad de aproximadamente 1,5 veces la carga más pesada que vayas a medir. Una celda demasiado grande reduce la resolución: con una celda de 20 kg puedes pesar una carta de 50 g, pero la lectura será cuatro veces más basta que con una de 5 kg. Sobrecargar una celda pequeña es peor; las celdas de barra suelen aguantar con seguridad un 120 por ciento de su capacidad, pero por encima del 150 por ciento el metal puede doblarse de forma permanente y la celda ya no volverá a cero. La capacidad total también depende de entre cuántas celdas se reparte el peso: cuatro celdas de 50 kg en las esquinas soportan juntas 200 kg.

Colores de los cables y conexión del HX711

Los colores pueden variar según el fabricante; algunas celdas usan amarillo en lugar de negro o azul en lugar de verde, o intercambian el papel del blanco y el verde. Para asegurarte, pon el multímetro en ohmios: el par de excitación (E+, E-) y el par de señal (A+, A-) suelen marcar unos 1000 Ω, y los pares cruzados alrededor de tres cuartos de ese valor. Invertir los cables de señal no estropea nada; simplemente el valor baja al añadir peso. Lo corriges intercambiando los cables o poniendo el factor de calibración en negativo. B+ y B- son del segundo canal y quedan libres en los proyectos con una sola celda.

Conexión de cuatro celdas de carga de 50 kg de medio puente (báscula de personas)

Las celdas de 50 kg de las básculas de baño, las que tienen el centro en forma de E, solo llevan dos galgas y 3 cables, así que cada una es medio puente. Los cables suelen ser rojo, blanco y negro, pero identifica siempre la toma central midiendo: entre los dos cables exteriores hay unos 2 kΩ, y entre el central y cada exterior, alrededor de 1 kΩ. En la mayoría de las celdas la toma central es la roja. Si unes las cuatro celdas formando un anillo, obtienes un puente de Wheatstone completo.

1. Coloca las celdas en las cuatro esquinas de la plataforma y numera las esquinas 1 (delante izquierda), 2 (delante derecha), 3 (detrás derecha) y 4 (detrás izquierda).
2. Une los cables exteriores del mismo color de las celdas vecinas: los blancos de 1 y 2, los negros de 2 y 3, los blancos de 3 y 4 y los negros de 4 y 1.
3. Conecta los cables rojos de las celdas en diagonal 1 y 3 a E+ y E-.
4. Conecta los cables rojos de la otra diagonal, celdas 2 y 4, a A+ y A-.
5. Mide antes de soldar: entre E+ y E- y entre A+ y A- debe haber unos 2 kΩ. Si el valor es muy distinto, alguna unión está mal.
6. Si el valor baja al añadir peso, intercambia los cables A+ y A- o usa un factor negativo.

Instalar la librería HX711

1. En el Arduino IDE abre Herramientas > Administrar bibliotecas y escribe HX711 en el buscador.
2. Instala HX711 Arduino Library de Bogdan Necula. Si es la primera vez que instalas una librería, echa un vistazo a la guía cómo añadir librerías en Arduino.
3. Tras instalarla, encontrarás los ejemplos HX711_basic_example y HX711_full_example en Archivo > Ejemplos > HX711 Arduino Library; el código de abajo usa las mismas funciones.

¿Cómo hacer la tara y encontrar el factor de calibración?

El HX711 no te da gramos, te da un número bruto. Para convertirlo en peso necesitas dos valores: el offset (tara) que marca la báscula vacía y las cuentas por gramo, es decir, el factor de calibración. La fórmula es sencilla: peso = (valor bruto − offset) / factor. La función tare() calcula el offset; el factor lo calculas una sola vez con un objeto cuyo peso conoces. Por ejemplo, si la báscula vacía marca 84.120 y al poner una pesa de 500 g el valor pasa a 298.870, la diferencia es 214.750 y el factor es 214.750 / 500 = 429,5.

1. Monta la celda firmemente en la plataforma; la calibración debe hacerse con la báscula en su forma definitiva.
2. Sube el código de abajo, abre el Monitor Serie a 9600 baudios y espera a que se haga la tara con la báscula vacía.
3. Pon en el centro un objeto de peso conocido. Una botella de agua pesada en otra báscula sirve perfectamente; un peso cercano a la mitad de la capacidad da el mejor resultado.
4. Escribe en el Monitor Serie el peso del objeto en gramos (p. ej. 500) y pulsa Intro. El código calcula y muestra el factor y hace enseguida una medida de comprobación.
5. Apunta el factor y escríbelo en el código de tu báscula. Repetir varias veces con pesos distintos y promediar mejora la precisión.

1#include "HX711.h"
2
3const int DT_PIN = 2;                      // HX711 DT (DOUT)
4const int SCK_PIN = 3;                     // HX711 SCK (PD_SCK)
5
6HX711 scale;
7
8void setup() {
9  Serial.begin(9600);
10  scale.begin(DT_PIN, SCK_PIN);            // kanal A, kazanç 128 / channel A, gain 128
11  if (!scale.wait_ready_timeout(1000)) {   // modül cevap vermiyor / module not answering
12    Serial.println("HX711 bulunamadi / HX711 not found");
13    while (true) {}
14  }
15  scale.set_scale();                       // faktör 1: ham sayı / factor 1: raw counts
16  Serial.println("Tarti bos olsun, dara aliniyor... / Keep it empty, taring...");
17  delay(2000);
18  scale.tare(20);                          // 20 ölçümün ortalaması sıfır / average of 20 readings = zero
19  Serial.println("Bilinen agirligi koy, gramini yaz (or. 500) / Place a known weight, type its grams (e.g. 500)");
20}
21
22void loop() {
23  if (Serial.available()) {
24    float bilinen = Serial.parseFloat();   // Seri Monitör'den gram / grams from Serial Monitor
25    if (bilinen > 0) {
26      double fark = scale.get_value(20);   // dara düşülmüş ham fark / tared raw difference
27      float faktor = fark / bilinen;
28      Serial.print("Ham fark / raw difference: ");
29      Serial.println(fark, 0);
30      Serial.print("Kalibrasyon faktoru / calibration factor: ");
31      Serial.println(faktor, 2);
32      scale.set_scale(faktor);             // hemen kontrol et / check right away
33      Serial.print("Kontrol / check: ");
34      Serial.print(scale.get_units(10), 1);
35      Serial.println(" g");
36    }
37  }
38}

El código toma como cero la media de 20 lecturas con tare(20); a 10 SPS eso tarda unos 2 segundos. Al poner el peso, get_value(20) devuelve la diferencia bruta tras la tara, y al dividirla entre los gramos conocidos sale el factor. No te preocupes si el factor sale negativo: solo significa que los cables de señal están invertidos, y la báscula mide bien igualmente con un factor negativo. Para no tener que introducir el factor en cada arranque, puedes guardarlo en la memoria permanente del Arduino con EEPROM.put() y leerlo con EEPROM.get(); tienes los detalles en el artículo EEPROM de Arduino.

Báscula digital con Arduino: gramos en la LCD y botón de tara

Ahora vamos a construir una báscula de verdad con tu factor. El peso se muestra en una LCD I2C de 16x2 y un botón en D4 hace la tara en cualquier momento, así puedes poner primero el recipiente, hacer la tara y pesar solo el contenido. La LCD se conecta a A4 (SDA) y A5 (SCL); consulta el artículo pantalla LCD I2C para los detalles y el de conexión de un botón para usar la resistencia pull-up interna.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include "HX711.h"
4
5const int DT_PIN = 2;                      // HX711 DT
6const int SCK_PIN = 3;                     // HX711 SCK
7const int DARA_BUTON = 4;                  // dara butonu, diğer ucu GND / tare button, other leg to GND
8const float FAKTOR = 429.5;                // kendi faktörünü yaz / use your own factor
9
10HX711 scale;
11LiquidCrystal_I2C lcd(0x27, 16, 2);       // adres, sütun, satır / address, columns, rows
12float filtreli = 0;                        // filtrelenmiş ağırlık / filtered weight
13
14void setup() {
15  pinMode(DARA_BUTON, INPUT_PULLUP);
16  lcd.init();
17  lcd.backlight();
18  lcd.print("Dara aliniyor...");
19  scale.begin(DT_PIN, SCK_PIN);
20  scale.set_scale(FAKTOR);
21  scale.tare(20);                          // açılışta terazi boş olmalı / scale must be empty at start
22  lcd.clear();
23  lcd.print("Agirlik:");
24}
25
26void loop() {
27  if (digitalRead(DARA_BUTON) == LOW) {    // butona basıldı / button pressed
28    lcd.setCursor(0, 1);
29    lcd.print("Dara...         ");
30    scale.tare(20);
31    filtreli = 0;
32    while (digitalRead(DARA_BUTON) == LOW) {}   // bırakılmasını bekle / wait for release
33    delay(50);                             // kontak sıçramasını atla / skip contact bounce
34  }
35
36  if (scale.is_ready()) {
37    float w = scale.get_units(4);          // 4 ölçümün ortalaması / average of 4 readings
38    if (fabs(w - filtreli) > 5.0) {
39      filtreli = w;                        // büyük değişim: filtreyi atla / big change: skip the filter
40    } else {
41      filtreli = 0.7 * filtreli + 0.3 * w; // üstel ortalama (EMA) / exponential moving average
42    }
43    float goster = filtreli;
44    if (fabs(goster) < 0.5) goster = 0;    // sıfırdaki titremeyi gizle / hide jitter around zero
45
46    char yazi[12];
47    dtostrf(goster, 8, 1, yazi);           // 8 karakter, 1 ondalık / 8 chars, 1 decimal
48    lcd.setCursor(0, 1);
49    lcd.print(yazi);
50    lcd.print(" g");
51  }
52}

El código usa tres pequeños trucos. El primero es una media móvil exponencial (EMA): cada lectura nueva solo aporta un 30 por ciento al resultado, lo que suaviza el temblor. El segundo: si el peso cambia de golpe más de 5 g, se salta el filtro y la pantalla pasa directamente al nuevo valor; el filtro solo actúa con carga estable. El tercero es una banda muerta: los valores por debajo de ±0,5 g se muestran como 0, para que desaparezcan los dígitos que bailan, como 0.3, -0.2, 0.1, con la báscula vacía. Como get_units(4) espera cuatro lecturas en cada llamada, a 10 SPS la pantalla se actualiza unas 2,5 veces por segundo.

Lecturas inestables: temblor, deriva y soluciones

La mayoría de los problemas en proyectos con HX711 vienen de la mecánica, no del código. Una celda de barra funciona como una viga en voladizo: un extremo se atornilla a la base y el otro a la bandeja superior, con un separador de unos milímetros (arandelas o un bloque impreso en 3D) en cada extremo. Así la celda queda en forma de Z y su centro puede doblarse libremente. Si el centro de la celda toca la base o la bandeja, si los tornillos están demasiado apretados o si la bandeja se flexiona, las lecturas derivarán sin parar. Asegúrate de que la flecha de la celda apunta en la dirección de la fuerza (hacia abajo) y no dejes que nada toque la zona central donde están las galgas.

• Base rígida: La base y la bandeja no deben flexionarse; usa contrachapado grueso, MDF o una chapa de aluminio. Las vibraciones de la mesa también se notan en la lectura.
• Cables cortos y sujetos: Mantén cortos los cables de la celda, trénzalos y fíjalos. Un cable colgando empuja la celda y cambia el valor.
• Alimentación limpia: El USB de un portátil puede ser ruidoso. Añadir condensadores de 100 nF y 10 µF entre VCC y GND del módulo y alejarlo de motores, relés y la antena Wi-Fi ayuda.
• Tiempo de calentamiento: En los primeros minutos tras encender, mientras la celda y el módulo se calientan, el cero puede desplazarse unos gramos; espera antes de medir con precisión y luego haz la tara.
• Promedia: get_units(10) reduce el ruido unas tres veces, pero a 10 SPS tarda 1 segundo. Busca el equilibrio entre velocidad y estabilidad; para otros métodos de filtrado, mira el artículo filtrado de datos de sensores.
• Fluencia (creep): Con una carga que permanece mucho tiempo, el valor puede cambiar unos gramos en cuestión de minutos. Es algo propio de la celda y se nota más en las baratas.
• Expectativas realistas: 0,5–1 g de estabilidad con una celda de 5 kg bien montada, y 50–100 g en una báscula de personas con cuatro celdas de 50 kg, son buenos resultados.

Báscula con ESP32: pantalla OLED y calibración permanente

La misma librería funciona sin cambios en el ESP32. El ejemplo de abajo muestra el peso con dígitos grandes en una OLED SSD1306 de 0,96 pulgadas, hace la tara con un botón en el GPIO 27 y guarda el factor de calibración en la flash con la librería Preferences. Basta con escribir en el Monitor Serie el peso conocido en gramos para que el nuevo factor se calcule y se guarde de forma permanente. Para la conexión de la OLED (SDA GPIO 21, SCL GPIO 22) y sus librerías, consulta el artículo pantalla OLED.

1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Preferences.h>
5#include "HX711.h"
6
7const int DT_PIN = 25;                     // HX711 DT
8const int SCK_PIN = 26;                    // HX711 SCK
9const int DARA_BUTON = 27;                 // dara butonu, diğer ucu GND / tare button, other leg to GND
10
11HX711 scale;
12Adafruit_SSD1306 display(128, 64, &Wire, -1);
13Preferences ayar;
14float faktor;
15
16void agirlikGoster(float g) {
17  display.clearDisplay();
18  display.setTextSize(1);
19  display.setCursor(0, 0);
20  display.print(F("BlueGrays Terazi"));
21  display.setTextSize(2);                  // büyük rakamlar / big digits
22  display.setCursor(0, 28);
23  if (fabs(g) < 1000) {
24    display.print(g, 1);
25    display.print(F(" g"));
26  } else {
27    display.print(g / 1000.0, 3);          // 1 kg üstü kilogram / kilograms above 1 kg
28    display.print(F(" kg"));
29  }
30  display.display();
31}
32
33void setup() {
34  Serial.begin(115200);
35  pinMode(DARA_BUTON, INPUT_PULLUP);
36  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);   // SDA 21, SCL 22
37  display.setTextColor(SSD1306_WHITE);
38
39  ayar.begin("terazi", false);             // flash'ta ayar alanı / settings namespace in flash
40  faktor = ayar.getFloat("faktor", 429.5); // kayıt yoksa varsayılan / default if nothing saved
41
42  scale.begin(DT_PIN, SCK_PIN);
43  scale.set_scale(faktor);
44  scale.tare(20);
45  Serial.println("Kalibrasyon: agirligi koy, gramini yaz / Calibrate: place a weight, type its grams");
46}
47
48void loop() {
49  if (digitalRead(DARA_BUTON) == LOW) {
50    scale.tare(20);
51    while (digitalRead(DARA_BUTON) == LOW) delay(10);   // bırakılmasını bekle / wait for release
52    delay(50);                             // kontak sıçramasını atla / skip contact bounce
53  }
54
55  if (Serial.available()) {
56    float bilinen = Serial.parseFloat();
57    if (bilinen > 0) {
58      faktor = scale.get_value(20) / bilinen;  // yeni faktör / new factor
59      scale.set_scale(faktor);
60      ayar.putFloat("faktor", faktor);     // elektrik kesilse de kalır / survives power loss
61      Serial.printf("Yeni faktor / new factor: %.2f\n", faktor);
62    }
63  }
64
65  if (scale.wait_ready_timeout(200)) {
66    agirlikGoster(scale.get_units(5));
67  }
68}

Si alimentas el HX711 desde el pin 3V3 del ESP32, el regulador del módulo no puede llegar a 4,3 V y el puente funciona con algo menos de 3,3 V. Como la medida es ratiométrica, el factor apenas cambia; solo aumenta un poco el ruido. El ESP32 además está listo para Wi-Fi: mostrar el peso en una página web o enviar un aviso al móvil cuando el comedero se vacía son solo unas líneas más. Para empezar, lee ¿Qué es el ESP32?. En una báscula de colmena a batería, entre medidas duermes el HX711 con scale.power_down() y el ESP32 con deep sleep. Para que SCK siga en HIGH mientras el ESP32 duerme, bloquea el pin con gpio_hold_en(); si no, queda flotante y el HX711 puede despertarse solo. Recuerda también descartar las lecturas de los primeros 400 ms tras despertar.

HX711 con la Raspberry Pi Pico (MicroPython)

MicroPython no trae un módulo para el HX711, pero el protocolo es tan sencillo que puedes escribir el driver tú mismo en pocas líneas. La clase de abajo espera a que DT pase a LOW, lee los datos enviando 24 pulsos por SCK, envía de 1 a 3 pulsos extra para elegir la ganancia y convierte el resultado de complemento a dos a un número con signo. Durante la lectura se desactivan brevemente las interrupciones, de modo que SCK nunca se queda en HIGH más de 60 µs y el HX711 no se duerme por accidente. Para instalar MicroPython, consulta ¿Qué es la Raspberry Pi Pico?.

1from machine import Pin
2import machine
3import time
4
5class HX711:
6    def __init__(self, dt, sck, gain=128):
7        self.dt = Pin(dt, Pin.IN)
8        self.sck = Pin(sck, Pin.OUT, value=0)
9        self.extra = {128: 1, 64: 3, 32: 2}[gain]   # toplam 25, 27, 26 darbe / 25, 27, 26 pulses in total
10        self.offset = 0
11        self.scale = 1.0
12        self.read()                                 # kazancı ayarla / set the gain
13
14    def read(self, timeout_ms=1000):
15        start = time.ticks_ms()
16        while self.dt.value() == 1:                 # DT LOW ise veri hazır / data ready when DT is LOW
17            if time.ticks_diff(time.ticks_ms(), start) > timeout_ms:
18                raise OSError("HX711 yanit vermiyor / not responding")
19        irq = machine.disable_irq()                 # SCK 60 µs'den uzun HIGH kalmasın / keep SCK HIGH under 60 µs
20        value = 0
21        for _ in range(24):
22            self.sck.value(1)
23            value = (value << 1) | self.dt.value()
24            self.sck.value(0)
25        for _ in range(self.extra):                 # sonraki ölçümün kanalı ve kazancı / next channel and gain
26            self.sck.value(1)
27            self.sck.value(0)
28        machine.enable_irq(irq)
29        if value & 0x800000:                        # ikiye tümleyen / two's complement
30            value -= 0x1000000
31        return value
32
33    def read_average(self, times=10):
34        return sum(self.read() for _ in range(times)) / times
35
36    def tare(self, times=15):
37        self.offset = self.read_average(times)
38
39    def get_units(self, times=5):
40        return (self.read_average(times) - self.offset) / self.scale
41
42
43hx = HX711(dt=15, sck=14)                           # DT -> GP15, SCK -> GP14
44print("Tarti bos, dara aliniyor... / Scale empty, taring...")
45hx.tare()
46hx.scale = 429.5                                    # kendi faktörün / your own factor
47
48while True:
49    print("{:.1f} g".format(hx.get_units()))
50    time.sleep_ms(200)

La calibración funciona igual que en Arduino: con hx.scale = 1.0, pon el peso conocido y divide el resultado de get_units() entre su peso en gramos para obtener el factor. En la Pico, alimenta también el HX711 desde el pin 3V3(OUT). Si quieres mostrar el peso en una pantalla, añade una OLED con el driver ssd1306.py y escribe el valor con oled.text().

Ideas de proyectos con el HX711 y una celda de carga

• Báscula de cocina: Celda de 5 kg, botón de tara y pantalla OLED para pesar con resolución de 1 g.
• Báscula de baño: Las cuatro celdas de una báscula vieja, un HX711 y una LCD I2C que muestre kilos.
• Comedero inteligente: Cuando el peso del cuenco baja de un valor, el ESP32 envía un aviso y un servomotor abre una trampilla para echar comida.
• Báscula para macetas: Calcula cuánta agua necesita la planta a medida que la maceta pesa menos y compara el resultado con un sensor de humedad del suelo.
• Control de colmenas: Pon 4 celdas bajo la colmena, sigue la entrada de néctar por el aumento diario de peso y registra los datos por Wi-Fi.
• Contador de piezas: Enséñale el peso de un solo tornillo y calcula cuántos hay en la caja a partir del peso total.
• Registro de datos: Envía las lecturas al ordenador por el puerto serie y haz gráficas con el método de pasar datos a Excel.

Errores frecuentes y soluciones

Una vez montada y calibrada correctamente, una celda de carga con HX711 te da un instrumento que mide al gramo con piezas baratas. Guarda tu factor de calibración, construye una mecánica sólida y ajusta el filtro a la velocidad de tu proyecto; el resto depende de tu imaginación. Para una visión más amplia de la medición, echa un vistazo a la guía de sensores para Arduino. En la app BlueGrays encontrarás proyectos para leer sensores, mostrar valores en pantallas LCD y OLED y registrar datos con el ESP32, con esquema y código paso a paso, para combinarlos con tu báscula.