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.

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.

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.

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

No products found.

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.

El circuito a implementar es el siguiente:

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

HX711	Celda de Carga
E+	Cable Rojo
E-	Cable Negro
A-	Cable Blanco
A+	Cable Verde

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

HX711	ARDUINO
GND	GND
DT	PIN 3
SDK	PIN 2
VCC	+5v

Una fotografia de la balanza con 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.

No products found.

/******************************************************
 * ****************************************************
 * ****     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.