Vamos a montar una bascula con una célula de carga.

Obtendremos un display con y sin decimales.

Haremos algunas pruebas[/three-fourth] [clear/]

 

 

	Una célula de carga
	Una plataforma de balanza
	Arduino uno o similar
	Cables macho-hembra
	Display 8 digitos 7 segmentos

 

Este tutorial e sparte de una serie sobre galgas y células de carga para hacer una balanza. Tal vez te interese revisarlas:

• Galgas y celulas de carga
• Balanza con célula de carga

 

 

En la última sesión montamos nuestra plataforma de pesaje y escribimos el programa que nos permitía obtener lecturas de la báscula. Pero la lectura que obtenemos con nuestro Arduino es simplemente un valor de tensión que nos devuelve el HX711 sin demasiado sentido en el mundo real. Por eso, comentamos que antes de poder pesar cosas, necesitábamos, en primer lugar, tarar la báscula sin carga, para poder eliminar el peso del plato de la propia balanza, algo que hace la librería con una llamada a la función correspondiente, y después necesitábamos calibrarla.

Vimos que calibrar la bascula significaba hallar un factor de conversión entre la lectura de la tensión en el puente y un peso conocido. Dicho de otro modo, para poder establecer el peso de algo con nuestra balanza, necesitábamos encontrar un factor de proporcionalidad entre un peso conocido y la lectura en bruto de la tensión en el puente.

Una vez que hemos determinado dicha relación, podemos usarlo como factor de conversión entre voltios en la célula y peso. Como este fue el objetivo de la última sesión, ya estamos en condiciones de escribir un programa que nos devuelva el peso real de cualquier cosa que coloquemos en la balanza. Vamos con ello.

 

Ahora que sabemos el factor de escala podemos ya escribir el programa competo que nos calcule el peso de lo que pongamos en la balanza. Lo primero sin novedad, es lo mismo que en el programa anterior:

#include "HX711.h"
const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 2;
HX711 balanza;

El setup() es casi igual:

void setup()
{    Serial.begin(115200);
     balanza.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);  
     delay(250);
     balanza.tare(10);  // Hacer 20 lecturas, el promedio es la tara
     balanza.set_scale(390);
}

He elegido esta vez, calcular la tara con 10 lecturas en lugar de una. La librería las promedia para obtener la tara. Y después fijamos la escala en el valor de calibración que determinamos en apartado anterior. (Para mí 390)

La librería dispone de tres funciones para leer la báscula:

Funcion	Descripción
balanza.read()	Lectura directa, sin tarar ni calibrar
get_value( )	Lectura descontando la tara
get_units()	Peso sin tara y corregido con la escala

Podemos escribir el loop más o menos así:

void loop()
   {   if (balanza.is_ready())
         { long reading = balanza.get_units(10);   // Peso sin tara y corregido
           Serial.println(reading  );
         }
       else
           Serial.println("No encuentro el HX711.");
       delay(200);
   }

Podríamos hacer una lectura unica y guardarla como la tara o peso en vacío (Nuestro cero gramos), pero como ya hemos comentado más arriba, hay mil cosas que pueden producir señales espurias en la célula de carga, por lo que es recomendable,  hacer unas cuantas medidas de la tara, sin carga, y calcular su promedio. De ese modo los errores aleatorios, tienden a compensarse.

Si no le dices nada, el hace solo una medida y listo, pero aquí le hemos pedido que haga el promedio de 10 lecturas. Puedes hacer más o menos dependiendo de tus gustos, pero 10 parece un número más que razonable.  Esto significa que cuando enciendas la báscula, no debes tener nada en el plato, porque lo considerará parte de la tara.  Si pongo ahora mi peso de control en el plato, podemos obtener las primeras lecturas de peso:

Vemos que la lectura es ligeramente superior a mi peso conocido de 455 gramos, (Los decimales despreciados). Podemos ajustar a mano el valor de la escala hasta que coincida con el peso correcto. Para mí ese valor de escala ha sido de 397:

Parece que ya estamos en condiciones de pesar con nuestra balanza Programa: Pesaje.rar, hagamos algunas pruebas, Aquí va un video con las primeras pesadas

 

 

 

 

Una vez que tenemos calibrada la balanza podemos añadirle un display de verdad para poder visualizar con comodidad el resultado (Sin necesitar un PC conectado, que encarecería mucho nuestra balanza). Vamos a usar un display de 8 dígitos y 7 segmentos, que presentamos hace no mucho tiempo:

En la última sesión publicamos las conexiones a la balanza con esta imagen esquemática:

Basta con añadir estas nuevas conexiones a las anteriores de la balanza, para conectar el display:

Una vez hecho, podemos ya comenzar a modificar programa para incluir tanto la balanza como el display que vamos a usar

 

 

Vamos a mezclar los programas Arduino de la última sesión para la balanza y los ejemplos que usamos para mostrar dígitos en el display. Como siempre, empezamos con las librerías necesarias:

#include "HX711.h"
#include "LedControl.h"

Algunas definiciones de pines:

const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 2;

Y empezamos por instanciar la balanza y el display:

HX711 balanza;
LedControl lc=LedControl(12,11,10,1);

Pasamos al setup(), donde simplemente inicializamos el puerto serie (Por si acaso) , después programamos el display al 50% de brillo y lo borramos. A continuación, ponemos la escala de la balanza y le pedimos calcular la tara tal y como vimos en la sesión anterior

void setup()
   { Serial.begin(115200);
     balanza.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
     delay(250);

     lc.shutdown(0,false);     // turn off power saving, enables display
     lc.setIntensity(0,5);     // sets brightness (0~15 possible values)
     lc.clearDisplay(0);       // clear screen

     balanza.set_scale(397);
     balanza.tare(20);  // Hacer 20 lecturas, el promedio es la tara
   }

Hasta aquí, poca novedad. Para mostrar el peso en el display utilizaremos las funciones que programamos en la sesión del display de 8 digitos 7 segmentos, que usamos allí para representar números enteros y números en coma flotante (float)

xxx

void loop()
   { if (balanza.is_ready())
      {  long reading = balanza.get_units(10);     // Peso sin tara y corregido
         displayInt(reading);
      }
    else
         Serial.println("No encuentro el HX711.");
    delay(250);
}

Programa completo: Balanza_con_display

¡Accede al contenido!

 

Por si alguien aún no se ha sorprendido, de que un peso minúsculo sea capaz de combar una barra de aluminio lo suficiente como para que nuestra célula de carga lo pese, vamos a dar una ultima vuelta de tuerca al tema. Haciendo pruebas he visto que nuestra balanza es capaz de dar una aproximación bastante razonable hasta el decimo de gramo y para ello basta con modificar el programa anterior para que represente decimales.

Basta para ellos sustituir las líneas:

long reading = balanza.get_units(10);           // Peso sin tara y corregido
displayInt(reading);

Por estas otras:

float reading = balanza.get_units(10);
displayFloat(reading,2);

 

Programa completo: Balanza arduino con 2 decimales

¡Accede al contenido!

Donde recibimos la medida de tensión del ADC en el puente como float (Que es lo que de verdad nos devuelve la función) y usamos la función displayFloat en lugar de displayInt para jugar con los decimales.

• La primera línea hace el promedio de 10 pesadas antes de devolvernos un valor y a pesar de todo hay fluctuaciones en los decimales (Ya comentamos que las galgas son muy sensibles a interferencias de todo tipo)
• Además, cuando colocamos un peso en el plato, la probeta de la célula de carga comienza a vibrar antes de alcanzar el equilibrio. (Si. No solo se comba con unos pocos gramos, sino que además oscila alrededor del punto de equilibrio durante un cierto tiempo, por lo que conviene que dejes un par de segundos para que se estabilice el pesaje.
• Al principio bailaran los dos decimales, pero si le dejas descansar unos segundo veras que la medida se va estabilizando mucho. Y si quieres una buena medida del peso, asegúrate de no tocar la balanza ni la mesa que la sustenta.
• El interés de esto, es mas un ejercicio teórico que practico, porque salvo que hayas usado un peso de control calibrado a la centésima de gramo, la medida no puede ser real. Pero se debe a la falta de precisión del peso de control mas que a la falta de sensibilidad de la propia báscula.[/fancy-ul] [/three-fourth]

 

Podemos entonces usar nuestra balanza con bastante confianza y aquí va un mini video para que apreciéis la finura de la pesada: