BALANZA DIGITAL CON ARDUINO
Hoy en día existe una gran variedad de balanzas digitales comerciales, que son económicas y muy precisas para su valor. Entonces, ¿Qué sentido tiene realizar una balanza digital con Arduino? Bueno aquí te dejamos unas cuantas razones:
1. Como proyecto de escuela o universidad.
2. Para mejorar tus habilidades de programación.
3. Para realizar la balanza con las medidas y precisión que quieras.
4. Para comprender cómo funciona un sensor de peso y una galga extensiométrica.
5. Para agregar componentes que desees, luces, pantallas, botones y lo que se te ocurra.
6. Para poder conectarlo a otros dispositivos y hacer tu propio sistema implementando IoT.
Estas y muchas otras razones son motivo suficiente para que hagas tu propia balanza digital, lo que le quieras agregar a futuro queda a tu imaginación.
MATERIALES:
Para comenzar a realizar este proyecto es importante tener claro cómo funciona el dispositivo principal, nos referimos al sensor de peso:
En el interior de este sensor de peso podemos encontrar una galga extensiométrica, se trata de un sensor que varía su resistencia al aplicar una fuerza sobre él, esto lo hace ser un sensor pasivo. Mediante las variaciones de resistencia podemos medir la variación de voltaje que produce con el siguiente circuito:
Este es un puente de Wheatstone utilizado para medir valores de resistencias mediante un equilibrio. Sin embargo, el análisis de un puente de Wheatstone queda fuera del alcance de este proyecto.
Lo siguiente sería conectar el sensor de peso a nuestro módulo HX711, un convertidor ADC que facilitará la comunicación y la medición de valores con nuestro microcontrolador.
Ahora debemos conectar nuestra LCD 16X02 con el módulo i2C al Arduino, (utilizaremos el módulo i2C para facilitar las conexiones, esto nos ahorrará mucho tiempo y espacio en nuestro Arduino). Estas son las conexiones:
Al terminar estas conexiones, podemos empezar a preparar el IDE de ARDUINO para cargar el programa. Para esto debemos instalar las siguientes librerías:
Para instalar la librería de Liquid_Crystal_I2C debemos seguir estos pasos:
Paso 1:
“Abrir la ubicación del archivo” donde está instalado el IDE ARDUINO
Paso 2:
Abrir la carpeta “libraries” y eliminar la carpeta que dice “LiquidCrystal”, (porque esta librería interfiere con la de “LiquidCrystal_I2C-Master”), así que es necesario eliminar o remover esta carpeta, para poder colocar aquí la nueva librería.
Al finalizar la instalación de las librerías “Liquid_Crystal_I2C” y “Queuetue_HX711_Library” ya tenemos todo listo para cargar el programa a nuestro Arduino.
CÓDIGO:
#include <Wire.h>
#include <Q2HX711.h> //Libreria para HX711, debe ser instalada
#include <LiquidCrystal_I2C.h> //Libreria para LCD con I2C, debe ser instalada
LiquidCrystal_I2C lcd(0x27,20,4); //Si tu LCD no funciona prueba con 0x3f en lugar de 0x27
const byte DT = 3; //Pin de datos HX711
const byte CLK = 2; // Reloj de HX711
int push_tara = 8; // Boton para el proceso tara
int escala = 11; //Boton para cambiar la escala
Q2HX711 hx711(DT, CLK); // instancia de la libreria de HX711
/***********VARIABLES DEL PROGRAMA******************/
/*La variable masa_calibracion debe ser cambiada por el valor en gramos de la masa de calibracion
*si tu masa de calibracion pesa 254 gramos deberias cambiar el valor de masa_calibracion=254;
*es importante que estes seguro de la masa real del objeto, para que la balanza sea mas precisa
*/
float masa_calibracion = 400.0; // Cambiar por el valor en gramos de la masa conocida de calibracion
//////////////////////////////////////////////////////////
long x1 = 0L;
long x0 = 0L;
float n_promedio = 10.0; // Aumentar este valor si se desea mas precision en la balanza
float tara = 0;
bool estado_tara = false;
bool estado_escala = false;
int modo = 0;
float oz_conversion = 0.035274; //Conversion para onzas, se pueden agregar mas conversiones
//////////////////////////////////////////////////////////
void setup() {
Serial.begin(9600); // Inicia el puerto serial a 9600 baudios
PCICR |= (1 << PCIE0); //Escaneo PCMSK0
PCMSK0 |= (1 << PCINT0); //pin D8 como trigger para la interrupcion
PCMSK0 |= (1 << PCINT3); //pin D10 como trigger para la interrupcion.
pinmodo(push_tara, INPUT_PULLUP);
pinmodo(escala, INPUT_PULLUP);
lcd.init(); //Inicializa el LCD 16X02
lcd.backlight(); //Activa la luz de fondo
delay(1000);
// Proceso TARA
for (int ii=0;ii<int(n_promedio);ii++){
delay(10);
x0+=hx711.read();
}
x0/=long(n_promedio);
Serial.println("Agregar masa");
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Agregar masa ");
lcd.setCursor(0,1);
lcd.print(" de calibracion ");
// Comienza el proceso de calibracion con la masa que se establecio en masa_calibracion
int ii = 1;
while(true){
if (hx711.read()<x0+10000)
{
//No hace nada si no detecta masa
}
else
{
ii++;
delay(2000);
for (int jj=0;jj<int(n_promedio);jj++){
x1+=hx711.read();
}
x1/=long(n_promedio);
break;
}
}
Serial.println("Calibration Completada");
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" Calibracion ");
lcd.setCursor(0,1);
lcd.print(" Completada ");
}
void loop() {
// promedio lectura
long lectura = 0;
for (int jj=0;jj<int(n_promedio);jj++)
{
lectura+=hx711.read();
}
lectura/=long(n_promedio);
// cálculo de masa basado en calibración y ajuste lineal
float ratio_1 = (float) (lectura-x0);
float ratio_2 = (float) (x1-x0);
float ratio = ratio_1/ratio_2;
float masa = masa_calibracion*ratio;
if(estado_tara)
{
tara = masa;
estado_tara = false;
Serial.print("ESPERE");
Serial.print(".");
lcd.setCursor(0,0);
lcd.print(" ESPERE ");
lcd.setCursor(0,1);
lcd.print(" . ");
delay(300);
Serial.print(".");
lcd.setCursor(0,0);
lcd.print(" ESPERE ");
lcd.setCursor(0,1);
lcd.print(" .. ");
delay(300);
Serial.println(".");
lcd.setCursor(0,0);
lcd.print(" ESPERE ");
lcd.setCursor(0,1);
lcd.print(" ... ");
delay(300);
}
if(estado_escala)
{
modo = modo + 1;
estado_escala = false;
if(modo > 2)
{
modo = 0;
}
}
if(modo == 0)
{
Serial.print(masa - tara);
Serial.println(" gramos");
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" MASA ");
lcd.setCursor(0,1);
lcd.print(masa - tara);
lcd.print(" gramos");
}
else if(modo == 1)
{
Serial.print(masa - tara);
Serial.println(" mililitros");
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" MASA ");
lcd.setCursor(0,1);
lcd.print(masa - tara);
lcd.print(" mililitros");
}
else
{
Serial.print((masa - tara)*oz_conversion);
Serial.println(" onzas");
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" MASA ");
lcd.setCursor(0,1);
lcd.print((masa - tara)*oz_conversion);
lcd.print(" onzas");
}
}//void loop
//INTERRUPCIONES
ISR(PCINT0_vect)
{
if (!(PINB & B00000001))
{
estado_tara = true; //BOTON TARA
}
if (!(PINB & B00001000))
{
estado_escala = true; //BOTON DE ESCALA
}
}
Una vez cargado el código a tu Arduino, puedes conectar los últimos componentes al proyecto, de esta forma:
Para finalizar solo tienes que poner a prueba la balanza, cuando la enciendas veras que en el LCD te aparecen unas letras que dicen “Agregar masa de calibración”
Cuando aparezca esto en pantalla, debes colocar sobre la balanza una masa de la cual conozca su peso en gramos. El valor de esta masa conocida lo debes anotar también en el código de programación, específicamente en esta parte:
/***********VARIABLES DEL PROGRAMA******************/
/*La variable masa_calibracion debe ser cambiada por el valor en gramos de la masa de calibracion
*si tu masa de calibracion pesa 254 gramos deberias cambiar el valor de masa_calibracion=254;
*es importante que estes seguro de la masa real del objeto, para que la balanza sea mas precisa
*/
float masa_calibracion = 400.0; // Cambiar por el valor en gramos de la masa conocida de calibracion
//////////////////////////////////////////////////////////
Al agregar la masa de calibración el programa realizará una calibración lineal.
Al finalizar la calibración, el programa mostrará en pantalla “Calibración completada” y a partir de este momento ya puedes pesar la cantidad de objetos que quieras, siempre y cuando no excedan el valor que establece tu sensor de peso. Nosotros utilizamos uno de 5kg, así que podremos medir masas como máximo de 5kg.
VÍDEOS RELACIONADOS:
