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.

¿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
extensiomé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.

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 fotografía 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.
}
}