Crea una balanza digital con HX711 y Arduino

Carlos Julián

Monitorear cambios en tu peso puede ser un proceso sencillo y sin complicaciones. A menudo, las personas confían en cómo les queda la ropa o en el ajuste de su cinturón para tener una idea de su estado físico. Sin embargo, para aquellos que buscan un enfoque más preciso y cuantificable, un peso exacto es fundamental. En lugar de gastar dinero en una balanza comercial, ¿por qué no construir la tuya? En este tutorial, aprenderás a construir una balanza digital utilizando una celda de carga, un módulo amplificador HX711 y un Arduino. Empezaremos desde lo básico, explicando cómo funciona la celda de carga y cómo calibrarla para obtener lecturas precisas, antes de adentrarnos en ejemplos prácticos.

Índice de contenido

Fundamentos de la celda de carga

Una **celda de carga** es un dispositivo que convierte una fuerza o presión aplicada en una señal eléctrica. Existen varios tipos de celdas de carga, entre las cuales se destacan las celdas de deformación (strain gauge), hidráulicas, neumáticas, piezoeléctricas y capacitivas. En este tutorial, nos centraremos en las celdas de carga de deformación, que son las más comunes en aplicaciones de pesaje.

Las celdas de carga de deformación utilizan medidores de deformación. Para entender su funcionamiento, es vital conocer qué es un medidor de deformación y cómo opera.

Qué es un medidor de deformación

Un medidor de deformación es un pequeño sensor, generalmente de un material conductor, que está dispuesto en una configuración de zigzag o cuadrícula. Estas pequeñas unidades son más pequeñas que un sello postal y funcionan de la siguiente manera:

Cuando se aplica fuerza al objeto al que está adherido el medidor de deformación, este se estira o comprime ligeramente, lo que provoca un cambio en su resistencia eléctrica. Este cambio es proporcional a la fuerza aplicada, pero es extremadamente pequeño. Por ejemplo, un medidor de deformación con una resistencia de 120 ohmios podría cambiar solo 0.12 ohmios ante una fuerza aplicada, lo que es difícil de detectar. Por ello, necesitamos un dispositivo que pueda medir cambios tan pequeños de manera precisa.

Para ello, utilizaremos un circuito especial llamado **puente de Wheatstone**.

Ponte de Wheatstone

Un puente de Wheatstone es un circuito eléctrico que consta de cuatro resistencias dispuestas en forma de rombo. Cuando las cuatro resistencias tienen el mismo valor (el puente está equilibrado), la tensión de salida es cero. Sin embargo, si el valor de cualquiera de las resistencias cambia (el puente se desbalancea), la tensión de salida se modificará, lo que puede ser medido fácilmente gracias a la ley de Ohm.

Uso de los medidores de deformación en las celdas de carga

En una celda de carga de deformación, uno o más de los resistores en el puente de Wheatstone son reemplazados por medidores de deformación. En las celdas de carga tipo barra, estos medidores están pegados a una barra metálica, que usualmente tiene forma de "Z". Cuando se aplica una fuerza a la barra, esta se deforma ligeramente, lo que genera que algunos medidores se estiren (tensión) y otros se compriman.

Este diseño optimiza la señal de salida, haciendo que la medición de la fuerza sea más precisa.

Conexión de la celda de carga

Una celda de carga típica cuenta con cuatro cables, que corresponden a los puntos de conexión en el puente de Wheatstone:

Excitación+ (E+ o VCC): Generalmente ROJO – Este es donde se aplica la tensión positiva para alimentar el puente.
Excitación- (E- o GND): Usualmente NEGRO o AMARILLO – Esta es la conexión a tierra o tensión negativa.
Salida+ (O+, S+, o A+): Normalmente VERDE o AZUL – Este cable transporta la señal de salida positiva del puente.
Salida- (O-, S-, o A-): Comúnmente BLANCO – Este cable transporta la señal de salida negativa del puente.

Módulo HX711

Hemos visto cómo una celda de carga utiliza medidores de deformación en un puente de Wheatstone para generar una señal de voltaje que refleja la fuerza aplicada. Sin embargo, es importante destacar que, incluso después de usar el puente de Wheatstone, la señal de voltaje resultante es extremadamente baja, a menudo en milivoltios. Los microcontroladores habituales, como Arduino, no pueden leer estas señales de bajo voltaje directamente.

Aquí es donde entra el **HX711**. Este es un chip electrónico especializado diseñado para leer señales de celdas de carga. Su función principal es amplificar la pequeña señal de voltaje producida por el puente de Wheatstone y convertir esa señal analógica amplificada en datos digitales utilizando su convertidor analógico a digital (ADC) de 24 bits, lo que permite que un microcontrolador procese la información con facilidad.

El HX711 se comunica con un microcontrolador a través de una interfaz serial de dos hilos: **DATA (DOUT)** y **CLOCK (SCK)**. El microcontrolador inicia una conversión al llevar el pin SCK a un nivel bajo. Luego, el HX711 calcula el peso y envía el valor digital de 24 bits por el pin DOUT.

El HX711 tiene dos canales de entrada, A y B. Esto significa que puedes conectar dos celdas de carga diferentes, una en cada canal. El canal A puede configurarse con una ganancia de 64 o 128, mientras que el canal B tiene una ganancia fija de 32. En la mayoría de las aplicaciones de celdas de carga, se utiliza el canal A, y la ganancia se establece típicamente en 128 para mayor sensibilidad.

El número de pulsos de reloj enviados al pin SCK controla el canal y la configuración de ganancia para la próxima medición. Por ejemplo, 25 pulsos seleccionan el canal A con ganancia de 128, 26 pulsos seleccionan el canal B con ganancia de 32, y 27 pulsos seleccionan el canal A con ganancia de 64. Sin embargo, no necesitas preocuparte por manejar estos conteos; existen bibliotecas que facilitan todo esto mediante comandos simples.

El HX711 puede operar con un amplio rango de voltajes, desde 2.6V hasta 5.5V, lo que lo hace compatible con microcontroladores comunes como Arduino y Raspberry Pi. Además, consume muy poca energía, normalmente menos de 1.5 mA, y en un modo de bajo consumo, solo utiliza alrededor de 1 µA, lo que lo convierte en una excelente opción para proyectos alimentados por batería.

Pinout del módulo HX711

Ahora, veamos el pinout del HX711.

Pines de conexión de la celda de carga

E+ pin proporciona tensión de excitación positiva a la celda de carga. Se conecta usualmente al cable rojo de la celda de carga.

E- pin proporciona tensión de excitación negativa (tierra) a la celda de carga. Se conecta normalmente al cable negro de la celda de carga.

A+ es la entrada diferencial positiva para el canal A, que es el canal principal utilizado para conectar una celda de carga. Se conecta al cable blanco de la celda de carga.

A- es la entrada diferencial negativa para el canal A. Se conecta al cable verde de la celda de carga. El HX711 mide la pequeña diferencia de voltaje entre A+ y A- para determinar el peso.

B+ es la entrada diferencial positiva para el canal B. Este es un canal secundario que puede usarse para una celda de carga diferente o un sensor separado.

B- es la entrada diferencial negativa para el canal B.

Pines de alimentación y comunicación

GND es la conexión a tierra común para todo el circuito, incluyendo el módulo HX711 y tu microcontrolador.

DT (Data) es el pin de salida de datos serial. Envía el valor digital de 24 bits desde el HX711 a tu microcontrolador.

SCK (Clock) es el pin de entrada de reloj serial. Tu microcontrolador envía pulsos de reloj al HX711 en este pin para leer los datos.

VCC es para la alimentación del módulo HX711. Puede aceptar un voltaje entre 2.6V y 5.5V.

Configuración de la celda de carga

Antes de conectar todo y cargar el código de ejemplo, es importante configurar la celda de carga adecuadamente. Usualmente, al trabajar con una celda de carga tipo barra, se monta entre dos placas planas en una forma de "Z". Esto permite que la celda de carga experimente tensión entre los extremos opuestos cuando se aplica peso.

Este montaje puede hacerse con materiales simples o, para mayor comodidad, puedes adquirir un kit HX711 en línea. Estos kits suelen incluir todo lo necesario: dos placas de acrílico, una celda de carga tipo barra, un módulo HX711 y algunos espaciadores y tornillos. El kit está diseñado para ser fácil de ensamblar, permitiendo que puedas estar listo en cuestión de minutos.

Conexión de la celda de carga al módulo HX711 y Arduino

Comencemos a cablear todo. Primero, toma tu celda de carga. La mayoría de las celdas de carga tipo barra estándar tienen cables de cuatro colores: rojo, negro, blanco y verde. Estos cables deben conectarse a los pines correspondientes en el módulo HX711.

Conéctate de la siguiente manera:

Conecta el cable rojo de la celda de carga al pin E+ del HX711.
Conecta el cable negro al pin E-.
Conecta el cable blanco al pin A-.
Finalmente, conecta el cable verde al pin A+.

Una vez que hayas hecho estas cuatro conexiones, habrás completado el cableado de la celda de carga al HX711.

Ahora, conecta el módulo HX711 a tu Arduino. Conecta el pin VCC del HX711 al pin de 5V de tu Arduino y el pin GND al pin GND del Arduino. Luego, conecta el pin DT del HX711 al pin 2 del Arduino, y por último, conecta el pin SCK del HX711 al pin 3 del Arduino.

Instalación de la biblioteca

Existen varias bibliotecas disponibles para leer mediciones de una celda de carga utilizando el HX711. En este tutorial, utilizaremos la biblioteca HX711 de Bogdan Necula. Es compatible con muchos microcontroladores, incluyendo ESP32, ESP8266, STM32 y Arduino.

Para instalar la biblioteca:

Abre tu programa de Arduino IDE y haz clic en el icono de Library Manager en la barra lateral izquierda.
Escribe “hx711” en la caja de búsqueda para filtrar tus resultados.
Busca la biblioteca “HX711 Arduino library” creada por Bogdan Necula.
Haz clic en el botón Instalar para añadirla a tu IDE de Arduino.

Calibrar la celda de carga

Cada celda de carga es ligeramente diferente, incluso si parecen idénticas. Por ello, antes de que tu celda de carga pueda proporcionar lecturas de peso precisas, es necesario calibrarla utilizando un objeto de peso conocido. La calibración ayuda a tu Arduino a entender cómo los números crudos del sensor se traducen en unidades del mundo real, como gramos o kilogramos.

Prepara un objeto con un peso conocido. Por ejemplo, puedes usar un pequeño bloque de jabón que pese exactamente 50 gramos.

Sube el código de calibración a tu placa Arduino.

#include "HX711.h"

#define DT 2
#define CLK 3

HX711 scale;

void setup() {
  Serial.begin(9600);
  Serial.println("HX711 calibration sketch");

  scale.begin(DT, CLK);
}

void loop() {
  scale.set_scale();
  Serial.println("");
  Serial.println("Remove all weight from scale");
  delay(5000);
  scale.tare();
  Serial.println("Tare done!");

  Serial.println("Place a known weight on the scale...");
  delay(5000);
  long reading = scale.get_units(10);
  Serial.print("Reading: ");
  Serial.println(reading);
  delay(1000);
}

Abre el Monitor Serial en el IDE de Arduino y asegúrate de que esté configurado a una velocidad de 9600 baudios. Luego, presiona el botón de RESET en tu placa Arduino.
Sigue las instrucciones que aparecen en el Monitor Serial. Primero, retira todos los objetos de la celda de carga. El sistema se "tareará" automáticamente, lo que significa que tratará la balanza vacía como cero. Luego, coloca el peso conocido (por ejemplo, el bloque de jabón de 50g) sobre la balanza y espera a que el Monitor Serial muestre un valor.
Calcula tu factor de calibración utilizando la fórmula:
Por ejemplo, si la lectura que ves es 21512 y tu peso conocido es 50 gramos, el factor de calibración sería:
Anota este factor de calibración; lo necesitarás en el próximo código para obtener mediciones de peso precisas.

Como la salida del sensor es proporcional a la fuerza aplicada a la celda de carga, puedes calibrar tu balanza usando cualquier unidad que tenga sentido para tu proyecto. Usamos gramos, pero podrías utilizar libras, kilogramos o incluso algo personalizado, como piezas de alimento para mascotas.

Ten en cuenta que tu factor de calibración puede ser muy positivo o muy negativo, dependiendo de la configuración de tu sistema de balanza y la dirección en que los sensores se desvían del estado cero.

Ejemplo 1 – Medir peso

Una vez que has calculado el factor de calibración para tu configuración de celda de carga, estás listo para usarlo y pesar objetos reales.

Para hacerlo, copia el siguiente código en tu IDE de Arduino. Antes de subirlo a tu placa Arduino, asegúrate de actualizar el calibration_factor en el código con el valor que obtuviste durante la calibración.

#include "HX711.h"

#define DT 2
#define CLK 3

#define calibration_factor 430.24  // Este valor se obtiene usando el código de calibración

HX711 scale;

void setup() {
  Serial.begin(9600);
  Serial.println("HX711 scale demo");

  scale.begin(DT, CLK);

  scale.set_scale(calibration_factor);
  scale.tare();  // Asumiendo que no hay peso en la balanza al inicio, restablecer la balanza a 0
}

void loop() {
  Serial.print("Reading: ");
  Serial.print(scale.get_units(), 1);
  Serial.print(" gm");
  Serial.println();

  delay(1000);
}

Después de subir el código, abre el Monitor Serial en el IDE de Arduino y establece la velocidad en 9600 baudios.

Asegúrate de que la balanza esté completamente vacía al principio. Esto permite que el código tare automáticamente la balanza. Cuando comiencen las lecturas, coloca suavemente tu peso conocido (como el bloque de jabón de 50g que usaste antes) sobre la balanza y observa las lecturas en el Monitor Serial.

Si el valor mostrado no coincide con el peso conocido, es posible que debas repetir el proceso de calibración para obtener un factor de calibración más preciso.

Explicación del código

El sketch comienza incluyendo la biblioteca HX711. Esta biblioteca proporciona todas las funciones necesarias para trabajar con el módulo HX711.

A continuación, definimos los dos pines en el Arduino que están conectados a los pines DT (datos) y CLK (reloj) en el módulo HX711.

#define DT 2
#define CLK 3

Luego, definimos una variable llamada calibration_factor. Este es el número que encontraste durante la calibración, y le dice al Arduino cómo convertir los valores crudos del sensor en unidades de peso legibles, como gramos. Asegúrate de reemplazar el marcador de posición en el código con tu factor de calibración real.

#define calibration_factor 430.24

Después de eso, creamos una instancia de la clase HX711 y la nombramos scale.

Dentro de la función setup(), comenzamos la comunicación serial para poder ver la salida en el Monitor Serial. Luego, inicializamos la balanza llamando al método begin() y pasando los números de pin. Utilizamos el método set_scale() para aplicar el factor de calibración, de modo que el sensor sepa cómo convertir sus lecturas. Justo después, utilizamos el método tare() para restablecer la balanza a cero, asumiendo que no hay peso en ella al arrancar.

void setup() {
  Serial.begin(9600);
  Serial.println("HX711 scale demo");

  scale.begin(DT, CLK);

  scale.set_scale(calibration_factor);
  scale.tare();  // Asumiendo que no hay peso en la balanza al inicio, restablecer la balanza a 0
}

Una vez completada la configuración, la balanza está lista para medir peso. En la función loop(), llamamos continuamente al método get_units() para obtener lecturas de peso de la balanza. El resultado se muestra en el Monitor Serial una vez por segundo.

void loop() {
  Serial.print("Reading: ");
  Serial.print(scale.get_units(), 1);
  Serial.print(" gm");
  Serial.println();

  delay(1000);
}

Ejemplo 2 – Creando una balanza digital simple

En el ejemplo anterior, utilizamos el Monitor Serial para mostrar lecturas de peso. Ahora, llevaremos esto un paso más allá creando una balanza digital simple que muestre las lecturas en un display LCD I2C e incluya un botón para tarar la balanza cuando sea necesario.

Si no has trabajado previamente con un display LCD I2C, puede que desees consultar un tutorial útil sobre el tema.

Cableado

El cableado en este ejemplo es similar al anterior, pero con algunas adiciones. Esta vez, añadimos un LCD I2C y un botón pulsador.

Comienza conectando el LCD I2C al Arduino. Conecta el pin VCC del LCD a la salida de 5V en el Arduino y el pin GND a la tierra del Arduino. Luego, conecta el pin SDA del LCD a A4 en el Arduino y el pin SCL a A5. En las placas Arduino con diseño R3, también puedes encontrar SDA y SCL etiquetados cerca del pin AREF; cualquiera de las dos ubicaciones funcionará.

Después, conecta el botón pulsador. Un extremo del botón debe conectarse a GND y el otro extremo debe conectarse al pin digital 4 en el Arduino.

Código de Arduino

A continuación, se presenta el sketch de Arduino.

#include "HX711.h"
#include <LiquidCrystal_I2C.h>

#define DT 2
#define CLK 3
#define buttonPin 4
#define calibration_factor 430.24  // Este valor se obtiene usando el código de calibración

LiquidCrystal_I2C lcd(0x3F, 16, 2);
HX711 scale;

float reading;
float lastReading = -999;     // Inicializado a un valor que no coincidirá con la primera lectura
unsigned long lastEvent = 0;  // Para el rebote del botón
bool lastButtonState = HIGH;  // Estado anterior del botón (HIGH cuando se utiliza INPUT_PULLUP)

void setup() {
  Serial.begin(9600);
  pinMode(buttonPin, INPUT_PULLUP);

  lcd.init();
  lcd.clear();
  lcd.backlight();

  // Mostrar título
  lcd.setCursor(0, 0);
  lcd.print("Digital Scale");

  // Inicializar la balanza
  scale.begin(DT, CLK);
  scale.set_scale(calibration_factor);
  scale.tare();  // Restablecer la balanza a 0 al inicio

  // Mostrar peso inicial
  lcd.setCursor(0, 1);
  lcd.print("Weight: 0g   ");
}

void loop() {
  // Leer el estado actual del botón
  bool currentButtonState = digitalRead(buttonPin);

  // Comprobar si se presionó el botón (con rebote)
  if (lastButtonState == HIGH && currentButtonState == LOW) {
    // El botón fue presionado (bajada)
    if (millis() - lastEvent > 50) {  // Retardo de rebote de 50 ms
      Serial.println("Tare!");
      scale.tare();

      // Limpiar pantalla y mostrar "Tarando..."
      lcd.setCursor(0, 1);
      lcd.print("Taring...       ");
      delay(500);  // Breve pausa para mostrar el mensaje de tare

      lastReading = -999;  // Forzar actualización de pantalla después de tare
    }
    lastEvent = millis();
  }

  // Actualizar estado anterior del botón
  lastButtonState = currentButtonState;

  // Leer peso
  reading = round(scale.get_units());

  // Solo actualizar la pantalla si la lectura ha cambiado significativamente (reducir parpadeo)
  if (abs(reading - lastReading) > 0.01) {  // Umbral de 0.01g
    lcd.setCursor(0, 1);
    lcd.print("Weight: ");
    lcd.print(reading, 0);  // Mostrar con 2 decimales
    lcd.print("g    ");     // Espacios adicionales para limpiar valores anteriores más largos

    // También imprimir en serial para depuración
    Serial.print("Weight: ");
    Serial.print(reading, 2);
    Serial.println("g");

    lastReading = reading;
  }

  delay(100);  // Pequeño retraso para evitar abrumar la pantalla y serial
}

Demostración

Una vez que has subido el código a tu Arduino, estás listo para empezar a usar tu balanza digital. Cuando coloques un objeto sobre la celda de carga, el peso aparecerá directamente en la pantalla LCD I2C. Si deseas restablecer la balanza a cero—por ejemplo, al cambiar de contenedor o al quitar todo el peso—simplemente presiona el botón y la balanza se tareará automáticamente.

Para probarlo, pesé mi reloj de pulsera en esta balanza digital y luego verifiqué el mismo reloj usando una balanza de cocina normal. Los resultados coincidieron perfectamente, lo que demuestra que esta configuración es tanto precisa como confiable.

Explicación del código

El código es similar al ejemplo anterior, pero esta vez añadimos soporte para un display LCD I2C y un botón pulsador.

Al inicio del sketch, incluimos dos bibliotecas: la biblioteca HX711.h, que nos permite comunicarnos con el módulo HX711, y la biblioteca LiquidCrystal_I2C.h, que se utiliza para controlar la pantalla LCD I2C.

#include "HX711.h"
#include <LiquidCrystal_I2C.h>

Definimos los pines para el módulo HX711: DT está conectado al pin digital 2 y CLK al pin 3, como antes. Luego definimos buttonPin y lo asignamos al pin digital 4, que es el pin conectado al botón pulsador. A continuación, establecemos el calibration_factor, que debe ser el valor que encontraste durante el proceso de calibración.

#define DT 2
#define CLK 3
#define buttonPin 4
#define calibration_factor 430.24  // Este valor se obtiene usando el código de calibración

Después de eso, creamos dos objetos importantes. El primero es lcd, que es una instancia de la clase LiquidCrystal_I2C y se utilizará para mostrar datos en la pantalla LCD. La dirección 0x3F es una dirección I2C común para estas pantallas, y 16, 2 significa que la pantalla tiene 16 columnas y 2 filas. El segundo objeto es scale, que es nuestra instancia de HX711.

LiquidCrystal_I2C lcd(0x3F, 16, 2);
HX711 scale;

También creamos algunas variables para ayudarnos más adelante. reading almacenará la lectura de peso actual. lastReading se inicializa con un valor que está lejos de las lecturas normales para que no coincida con la primera lectura real cuando comparemos valores. También configuramos lastEvent y lastButtonState para ayudar con el rebote del botón.

float reading;
float lastReading = -999;     // Inicializado a un valor que no coincidirá con la primera lectura
unsigned long lastEvent = 0;  // Para el rebote del botón
bool lastButtonState = HIGH;  // Estado anterior del botón (HIGH cuando se utiliza INPUT_PULLUP)

Dentro de la función setup(), comenzamos la comunicación serial a 9600 baudios para que aún podamos ver la salida en el Monitor Serial. Establecemos el pin del botón como INPUT_PULLUP, lo que significa que el botón está normalmente en HIGH y se vuelve LOW cuando se presiona.

Serial.begin(9600);
pinMode(buttonPin, INPUT_PULLUP);

A continuación, inicializamos la pantalla LCD usando lcd.init(), limpiamos cualquier cosa en ella y encendemos la retroiluminación. Mostramos un título “Digital Scale” en la primera línea para que el usuario sepa que la balanza está lista. Luego, inicializamos la balanza HX711 usando scale.begin(DT, CLK), establecemos el factor de calibración, y llamamos a scale.tare() para restablecer la balanza a 0 al inicio. En la segunda línea del LCD, mostramos “Weight: 0g” como lectura inicial.

lcd.init();
lcd.clear();
lcd.backlight();

// Mostrar título
lcd.setCursor(0, 0);
lcd.print("Digital Scale");

// Inicializar la balanza
scale.begin(DT, CLK);
scale.set_scale(calibration_factor);
scale.tare();  // Restablecer la balanza a 0 al inicio

// Mostrar peso inicial
lcd.setCursor(0, 1);
lcd.print("Weight: 0g   ");

En la función loop(), primero comprobamos el estado actual del botón. Luego, verificamos si el botón se ha presionado. Si el botón fue presionado y han pasado más de 50 milisegundos desde la última pulsación, ejecutamos la operación de tare.

Al tarar, imprimimos “¡Tare!” en el Monitor Serial para obtener retroalimentación y llamamos a scale.tare() para restablecer la lectura de la balanza a cero. En la pantalla LCD, mostramos brevemente “Taring…” para que el usuario sepa lo que está ocurriendo. Luego, forzamos la actualización de la pantalla reiniciando lastReading.

// Leer el estado actual del botón
bool currentButtonState = digitalRead(buttonPin);

// Comprobar si se presionó el botón (con rebote)
if (lastButtonState == HIGH && currentButtonState == LOW) {
  // El botón fue presionado (bajada)
  if (millis() - lastEvent > 50) {  // Retardo de rebote de 50 ms
    Serial.println("Tare!");
    scale.tare();

    // Limpiar pantalla y mostrar "Tarando..."
    lcd.setCursor(0, 1);
    lcd.print("Taring...       ");
    delay(500);  // Breve pausa para mostrar el mensaje de tare

    lastReading = -999;  // Forzar actualización de pantalla después de tare
  }
  lastEvent = millis();
}

// Actualizar estado anterior del botón
lastButtonState = currentButtonState;

Después de la lógica del botón, leemos el peso actual usando scale.get_units() y redondeamos el resultado. Para evitar el parpadeo en el LCD, solo actualizamos la pantalla si la nueva lectura es significativamente diferente de la última. Si el peso ha cambiado, actualizamos la pantalla LCD con el nuevo valor y también lo imprimimos en el Monitor Serial.

// Leer peso
reading = round(scale.get_units());

// Solo actualizar la pantalla si la lectura ha cambiado significativamente (reducir parpadeo)
if (abs(reading - lastReading) > 0.01) {  // Umbral de 0.01g
  lcd.setCursor(0, 1);
  lcd.print("Weight: ");
  lcd.print(reading, 0);  // Mostrar con 2 decimales
  lcd.print("g    ");     // Espacios adicionales para limpiar valores anteriores más largos

  // También imprimir en serial para depuración
  Serial.print("Weight: ");
  Serial.print(reading, 2);
  Serial.println("g");

  lastReading = reading;
}

Finalmente, terminamos con un breve retraso para evitar que la pantalla y el Monitor Serial se actualicen demasiado rápido.

delay(100);  // Pequeño retraso para evitar abrumar la pantalla y serial

Carlos Julián

Carlos Julián es el fundador de Ingtelecto, es Ingeniero Mecatrónico, Profesor y Programador, cuenta con una Maestria en Ciencias de la Educación, creador de contenido educativo en redes sociales. Lee más sobre mi trayectoria aquí.

Estos temas te pueden interesar

Deja una respuesta Cancelar la respuesta