Saltar al contenido

Balanza Electronica con HX711 y Arduino

Saludos controlera o controlero, en esta entrada aprenderemos a montar y programar una báscula o balanza electronica empleando la tarjeta de prototipado del Arduino, una celda de carga y el módulo HX711.

Antes de comenzar te hago la invitación para que veas todas las entradas de nuestro CURSO GRATUITO ARDUINO DESDE CERO.

Y que te suscríbas al canal de YouTube si te gusta la programación de sistemas embebidos:

¿Que son las Celdas de Carga?

Una celda de carga (o load cell) es un transductor que convierte la fuerza que se ejerce sobre ella en una salida eléctrica medible. Donde la más común de las celdas de carga utilizan unos sensores piezo resistivos conocidos como galgas extensométricas capaces de variar una resistencia en función a la presión aplicada sobre ellas.

Una «celda de carga» se compone de una o más galgas extensiométricas adheridas a la superficie de una estructura metálica que tiene propiedades elásticas conocidas con precisión (tal como el acero de módulo de elasticidad 2,1 × 10^6  bar). Para la célula de carga la galga puede adherirse con pegamento a la estructura que es sometida a la carga.

Celdas de Carga con PIC
Instalación de una galga extensiométrica sobre una celda de carga (fuente: WikiPedia)

La mayoría de las celdas de carga de galgas extensométricas funcionan de manera muy similar, pero pueden variar en tamaño, material y configuración mecánica, lo que puede llevar a que cada celda tenga diferentes cargas máximas y sensibilidades que pueden manejar.

La conexión de las galgas extensiométricas adheridas a una celula de carga se encuentran en una configuración de puente Wheatstone para poder determinar de forma precisa las variación de resistencia.

Puente de Wheatstone en Celdas de Carga

Módulo HX711

El amplificador empleado para las celdas de carga es una placa cuyo componente central es el circuito integrado HX711 (Datasheet del HX711) que tiene la facilidad de obtener la medida de las celdas de carga usadas en aplicaciones de medición de peso.

El HX711 es un convertidor A/D de 24 bits de alta precisión. Este chip tiene dos canales de entrada analógica, una ganancia programable de 128 integrada. 

El módulo HX711 es un transmisor de celdas de carga de 1kg, 5kg, 20kg y 50kg encargado de enviar los datos hacia el Arduino, para poder determinar el peso del objeto de una forma rápida.

HX711 y Celdas de Carga
HX711 y Celdas de Carga

Si lo deseas puedes adquirir los componentes de este proyecto directamente del portal Chino Aliexpress donde encontrarás los componentes mucho más baratos y con envios a todas partes del mundo:

¿Sabías que muchos sensores se conectan a través del bus I2C? Aprende cómo hacer la conexión I2C en Arduino y simplifica tus proyectos.

HX711 con Arduino

Para este proyecto de balanza electrónica con Arduino y HX711 se van a emplear los siguientes materiales:

  • Arduino (cualquiera)
  • 2 Resistencias 10K
  • 2 Push Butons
  • Modulo I2C LCD
  • LCD 16×2
  • Módulo HX711
  • Celda de Carga de 5Kg
  • Lamina para ser el plato de la balanza
  • un pedazo de madera (soporte)
  • Tornillos y soportes
  • Cables

En la celda de carga es necesario identificar la marca con 5kg y una flecha hacia abajo dado qu eeste extremo es necesario que quede suspendido para permitir que la celda de carga se deforme al momento de colocar un peso sobre ella.

Sobre la cara superior de la celda de carga generalmente se encuentra ubicada una de las galgas extensiométricas la cual puede identificarse por un pegante blanco, por lo tanto, es recomendable colocar unos soportes para separar la lámina donde se coloca el peso de la celda de carga y así evitar que la propia lámina se apoye sobre la galga extensiométrica y afecte su medida.

Balanza HX711
Balanza HX711

El circuito a implementar es el siguiente:

La conexión entre la celda de carga y el HX711 es:

HX711Celda de Carga
E+Cable Rojo
E-Cable Negro
A-Cable Blanco
A+Cable Verde

La conexión entre el HX711 y el ARDUINO es:

HX711ARDUINO
GNDGND
DTPIN 3
SDKPIN 2
VCC+5v

Una fotografia de la balanza con Arduino:

hx711 Arduino

Funcionamiento

El proyecto consta de 2 botones:

  1. Botón MODO: Sirve para entrar al menú de calibración y seleccionar los pesos.
  2. Botón TARA: Sirve para tarar un peso y para entrar al menú de calibración.

Una vez energizado el circuito, si se deja presionado el botón MODO y TARA al mismo tiempo, el sistema entra en la etapa de calibración, donde se coloca un peso conocido en la balanza para ajustar el factor de escalización.

Cuando inicia, el sistema tara el peso inicial y muestra en pantalla el peso, el cual puede mostrar unidades de gramos. En el proyecto puede tararse algún peso por medio del botón TARA.

Código

La librería del HX711 by bodge puede ser descargada directamente desde el IDE del Arduino usando el Library Manager.

El código también puede descargarse a partir de mi GITHUB.

/******************************************************
 * ****************************************************
 * ****     BALANZA ELECTRÓNICA CON HX711         *****
 * ****                                           *****
 * ****  By: SERGIO ANDRES CASTAÑO GIRALDO        *****
 * ****  https://controlautomaticoeducacion.com/  *****
 * ****                                           *****
 * ****************************************************
 */

//Incluye las librerías
#include "HX711.h"
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>

//Define las variables globales
byte DT=3;
byte CLK=2;
byte modo = 7;
byte tara = 6;
int peso_conocido[4] = {500,1000,3000,5000};
long escala;

//Crear el objeto lcd  dirección  0x3F y 16 columnas x 2 filas
LiquidCrystal_I2C lcd(0x27,16,2);  

//Crear el objeto balanza
HX711 balanza;

//Función de Anti-debounce (Evitar el rebote del pulsador)
void anti_debounce(byte boton){
      delay(100);
      while(digitalRead(boton)); //Anti-Rebote
      delay(100);
}

//Función de calibración y ajuste
void calibration(){
  
  int i = 0,cal=1;
  long adc_lecture;
  
  // Escribimos el Mensaje en el LCD
  lcd.setCursor(2, 0);
  lcd.print("Calibracion de");
  lcd.setCursor(4, 1);
  lcd.print("Balanza");
  delay(1500);
  balanza.read();
  balanza.set_scale(); //La escala por defecto es 1
  balanza.tare(20);  //El peso actual es considerado Tara.
  
  lcd.clear();

  //Inicia el proceso de ajuste y calibración
  while(cal == 1){
    
    lcd.setCursor(1, 0);
    lcd.print("Peso Conocido:");
    lcd.setCursor(1, 1);
    lcd.print(peso_conocido[i]);
    lcd.print(" g        ");

    //Busca el peso conocido con el botón tara
    if(digitalRead(tara)){  
      anti_debounce(tara);
      i =(i>2) ? 0:i+1; //if-else en una linea
    }

    //Selecciona el peso conocido con el boton modo
    if(digitalRead(modo)){
      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print("Ponga el Peso");
      lcd.setCursor(1, 1);
      lcd.print("y espere ...");
      delay(2000);

      //Lee el valor del HX711
      adc_lecture = balanza.get_value(100);

      //Calcula la escala con el valor leido dividido el peso conocido
      escala = adc_lecture / peso_conocido[i];

      //Guarda la escala en la EEPROM
      EEPROM.put( 0, escala );
      delay(100);
      cal = 0; //Cambia la bandera para salir del while
      lcd.clear();
    }
    
  }
}

void setup() {
  //Configura la balanza
  balanza.begin(DT, CLK);
  
  //Configura los botones
  pinMode(modo, INPUT);
  pinMode(tara, INPUT);

  // Inicializar el LCD
  lcd.init();
  
  //Encender la luz de fondo.
  lcd.backlight();

  //Lee el valor de la escala en la EEPROM
  EEPROM.get( 0, escala );

  //Pregunta si se desea entrar en calibración
  if(digitalRead(modo) && digitalRead(tara))
    calibration();

  //Mensaje inicial en el LCD
  lcd.setCursor(1, 0);
  lcd.print("Retire el Peso");
  lcd.setCursor(1, 1);
  lcd.print("y Espere");
  delay(2000);
  balanza.set_scale(escala); // Establecemos la escala
  balanza.tare(20);  //El peso actual es considerado Tara.

  lcd.clear();
  lcd.setCursor(1, 0);
  lcd.print("Listo....");  
  delay(1000);
  lcd.clear();
}

void loop() {
  float peso;

  //Mide el peso de la balanza
  peso = balanza.get_units(10);

  //Muestra el resultado
  lcd.setCursor(1, 0);
  lcd.print("Peso: ");
  lcd.print(peso,0);
  lcd.println(" g        ");
  delay(5);

  //Botón de Tara
    if(digitalRead(tara)){  
      anti_debounce(tara);
      balanza.tare(10);  //El peso actual es considerado Tara.
    }
}

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.

Entradas relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Comentarios (13)

buen dia. hola amigo como estas?
como podria consultarte por privado, estoy en la realizacion de un proyecto con una balanza pero tengo que agregar algo mas, un teclado y un relé. quisiera que me ayudes porfavor. necesito de tu orientacion para poder lograr mi proyecto

Responder

Hola, muy buen proyecto, estoy investigando para hacer una balanza para peso maximo de 120 kb para pesar personas y conectarlo a un arduino, pero mi consulta es hay celdas de 120 kg o se pueden usar por ejemplo 6 de 20kg.

Responder

que buen peoyecto
como puedo contactar por interno

Responder

Buenas, me gustaria saber si al utilizar un sensor industrial es decir, una celda de carga de 500kg me serviria igual el codigo?

Responder

El código está diseñado para leer el conversor HX711, si tu sensor emplea el mismo conversor, puedes usarlo. Éxitos.

Responder

Buenos días Sergio, no tienes el código para Raspberry Pico? Estoy intentando hacer una báscula que cálcele el CdG de un <aeromodelo.

Muchas gracias

Responder

Y esto si quisiera adaptarlo para una celda de carga de 10kg?

Responder

Es lo mismo, solo debes comprar las celdas de carga para 10kg.

Responder

hola buenas tardes esta programación también la podría implementar en 4 celdas de 50 kg, ósea el mismo código me servirá ??? como podría ser la conexión eléctrica ???

Responder

Buenas, que otro tipo de control se podría hacer para mejorar la medida?. Es necesario cada tener que calibrar la balanza cada vez que se valla a usar?
Estoy usando un arduino mega, y un lcd de 128×64.

Responder

No, la calibración se hace de vez en cuando. No es necesario estar entrando siempre al menú de calibración pues para eso hemos almacenado el valor del ADC en la memoria interna del arduino.

Responder

Hola Sergio aca hay un error :
//Configura los botones
pinMode(modo, OUTPUT);
pinMode(tara, OUTPUT);

Los pines son INPUT no output, y te queria consultar estoy usando un nano y despues de calibrar con un peso por ejemplo de 1000 siempre me queda pesando de mas por ejemplo 1300, tenes idea que puede ser ?

Gracias

Responder

Gracias Miguel por la observación, ya lo he corregido. Creo que en este caso debes verificar bien la estructura de la balanza, que esté firme y que el plato no toque las galgas extensiométricas. Al comienzo de este proyecto tenia problemas con el sensor los cuales se solucionaron con una correcta instalación de la estructura. Revisa también las conexiones. También puedes probar calibrar la balanza con el máximo peso que esta soporta y ver si te mide bien.

Responder