Objetivos
Material requerido.
Una célula de carga | |
Una plataforma de balanza | |
Arduino uno o similar | |
Cables macho-hembra |
Si has llegado a esta pagina directamente tal vez te convenga revisar este otro tutorial que escribimos como introduccion al tema
Usando una célula de carga para pesar
Casi todo el mundo se cachondea con lo de las células de carga y las galgas, porque parece un tema extraño cuando lo desconocen y más extravagante aun, cuando les dices que se puede utilizar las mínimas deformaciones de una probeta de aluminio o acero para determinar el peso de algo que pongas encima. ¿De cuantos metros de probeta estamos hablando? Es una de las preguntas típicas, porque parece contraintuitivo, que un mísero cuarto de kilo de jamón york pueda curvar significativamente una barra metálica por mucho que se empeñen.
Pero lo cierto es que nuestro ojos y sentido común nos engañan, y el metal se curva con el peso que le pongamos encima, aunque sea imperceptiblemente, y podemos usar una célula de carga para detectar ese pandeo fácilmente. De hecho, este es el fundamento de poco menos que todas las balanzas con las que convives cotidianamente.
Como no espero que me creáis, os propongo hacer una pequeña balanza, con una simple célula de carga que podéis conseguir en nuestra tienda por unos pocos euros, y un convertidor analógico digital incluido en el paquete.
Montando la célula de carga
Para poder medir la deformación de una barra metálica, necesitamos disponer el peso en un extremo de la misma y la fijación al suelo en el otro extremo a una pequeña altura, que permita la flexión de la barra.
Cuando pongamos un peso en el plato (Al que apunta la flecha roja) la probeta se pandeará hacia abajo, por lo que necesita un apoyo fijo al suelo, que la alce unos pocos milímetros en el otro extremo. La probeta viene de serie con un par de agujeros pasantes en los laterales, de modo que la flexión sea máxima en esa zona y resulte más fácil de medir con las galgas.
Se puede hacer con unas planchas de madera que tengas por ahí, o como yo, que soy muy vago, comprando un kit de metacrilato que ya viene cortado y listo para montar, pero la idea es la misma. Sujetas la célula de carga, que ya trae los taladros con rosca, atornillándola al suelo, por un extremo, asegurándote de que la flecha del otro extremo apunta hacia abajo (Que es la forma en que está pensada, y no al revés )
Yo voy a usar una plataforma de metacrilato que ya viene cortada a medida para montar la balanza. Fíjate que la célula de carga está sujeta a la plataforma inferior y el plato de pesaje se sujeta a la probeta de aluminio mediante un tornillo:
Esquema de conexión a Arduino
Habitualmente las células de carga simples como las que vamos a usar en esta sesión, vienen con un convertidor analógico a digital de 24 bits del tipo HX711, es un ADC de 24 bits de resolución y bajo coste, de uso generalizado, con algunas características que lo hacen muy interesante y del que habláramos específicamente en otra sesión. Pero aquí, lo primero tenemos que conectar el ADC HX711 a nuestro Arduino.
Arduino | Vcc | GND | 2 | 3 |
---|---|---|---|---|
HX711 | Vcc | GND | SCK | DT |
Por el otro extremo, las conexiones son así:
HX711 | E+ | E- | A- | A+ |
---|---|---|---|---|
Load Cell | Rojo | Negro | Verde | Blanco |
Los terminales B+ y B- , son un segundo canal para el convertidor analógico a digital, que no usaremos en esta sesión. Si todo va bien, espero entrar con el segundo canal en la futura entrega sobre el HX711.
La conexión es muy sencilla y únicamente tienes que tener cuidado con las soldaduras y asegúrate de que conectas bien todo (Yo metí la pata la primera vez, hay que jo…, y me estuvo mareando un buen rato)
Programando la báscula con HX711
Vamos a usar la célula de carga sobre su soporte y colocaremos peso en la bandeja superior. Al hacerlo, la probeta de aluminio se inclinará ligeramente hacia abajo(Por el peso) y la célula de carga detectará el desequilibro en el puente de Wheatstone que configuran las galgas internamente (Ya vienen de fabrica conectadas en puente, no tienes que hacer nada)
Antes de empezar es importante entender que vamos a usar un HX711, que es un convertidor de 24 bits, en contraposición de los de Arduino que son de 10 bits. ¿Por qué?
Mientras que Arduino es capaz de dividir los 5 voltios a la entrada en 210 partes es decir 1.024, lo que corresponde a 5 / 1.024 = 4,88 mV por escalón, el HX711 es capaz de dividir los 5V en 224 partes, lo que supone 5 / 16.777.216 = 29,8 µV, es decir 16.834 veces mayor resolución. Casi nada. El Hx711 es capaz de detectar (En teoría) variaciones de tensión de casi 30 µV.
¿Porque necesitamos tanta resolución? Pues porque la deformación que se genera es minúscula, y lo mismo ocurre con la tensión del puente de Wheatstone, tal y como te dicta tu sentido común, pero suficiente para ser medido con precisión con un ADC de 24 bits.
Una vez hechas las advertencias previas, comprenderás que hagas lo que hagas, la célula de carga siempre devuelve un número, que es la tensión en el puente, pero que de por sí tiene poco sentido, sino afinamos un poco más. ¿Por qué?
En primer lugar, el propio soporte que has colocado para apoyar el peso a medir, pesa por sí mismo. Tenemos que eliminar ese peso, restándole del peso final antes de nada, y a eso se le llama tarar la báscula. Será la primera operación a realizar.
Lo segundo es, que todo instrumento de medida dará siempre una medida pase lo que pase, pero que sea creíble o te sirva de algo es un problema diferente. Suponte que pones algo de peso desconocido en la balanza y tu Arduino te informa, todo cachondo, que los resultados son 132.456,1. ¿Ciento y pico mil qué? Kilos, gramos, miliostios?. La medida solo es una información de la tensión en el puente, no un valor de peso.
Por ese motivo, tenemos que calibrar la balanza con un peso conocido para conseguir un factor de conversión de tensión en el puente con unos ciertos gramos o kilos. Será nuestra segunda operación. En general se acepta que este tipo de galgas están diseñadas para que la respuesta sea lineal (Que la tensión en el puente es directamente proporcional al peso) Pero sobre esto también se podría hablar largo y tendido.
En esta sesión, supondremos, elegantemente, que la respuesta de la célula de carga es perfectamente lineal y lo que haremos será pesar algo cuyo peso conozcamos con exactitud y calcular un coeficiente de conversión entre la tensión del puente y el peso, y a esto se le llama calibrar la balanza.
Solamente, después de tarar la báscula y calibrarla, podremos aventurar el peso de lo que pongamos en el plato. ¿Vale? Una vez con esto claro vamos a empezar con el programa de nuestra bascula. Empieza por instalar la librería necesaria para el HX711 desde el gestor de librerías:
Ahora en el cuadro que aparece escribe HX711 y elige la primera opción: HX711 Arduino Library, y dale a instalar.
Programa para calibrar la balanza
Empezaremos, preparando un programa para calibrar nuestra balanza. Podemos empezar por incluir la librería:
#include "HX711.h"
Ahora un par de líneas para indicar a que pines de Arduino hemos conectado los cables de datos del HX711:
const int LOADCELL_DOUT_PIN = 3; const int LOADCELL_SCK_PIN = 2;
Si tuvieras interés en conectar más de una célula de carga para tener varias basculas, bastaría con elegir otro par de pines digitales e indicarlo aquí. Ahora hay que instanciar cada balanza que definimos (Nosotros solo una)
HX711 balanza;
Vamos con el setup():
void setup() { Serial.begin(115200); balanza.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN); delay(250); balanza.set_scale(); //La escala por defecto es 1 balanza.tare(); }
Después de inicializar la puerta Serie, para los mensaje y lecturas, lo siguiente es arrancar la instancia balanza, pasándole como parámetros los pines a los que hemos conectado el HX711. Y hacemos un pequeño delay para dar tiempo a que todo se estabilice.
balanza.set_scale(); //La escala por defecto es 1 balanza.tare();
La primera línea fija la escala de medida en 1, el valor por defecto. La segunda hace una medida de la tara. Mas adelante nos preocuparemos de afinar todo esto un poco. Vamos con el loop:
void loop() { if (balanza.is_ready()) { long reading = balanza.get_units(10); Serial.println(reading ); } else Serial.println("HX711 not found."); delay(500); }
Programa: Calibracion
Cuando hacemos una lectura con balanza.read(), obtenemos la tensión del puente de Wheatstone. Es un valor sin mucho sentido físico, más allá de ser una medida de tensión actual, Si no ponemos peso en la balanza, obtendrás pequeños valores alrededor alrededor de 0 en la consola:
Ahora tenemos que calibrarla, y para eso necesitas un peso conocido. Normalmente, el peso conocido, conviene que sea lo más próximo al fondo de escala de tu célula de carga. La que yo estoy usando es de 5Kg, pero las hay de 10, de 20Kg…etc. Si no tienes un peso tan alto, podemos apañarnos con una botella de litro de agua, por ejemplo.
En mi caso y a falta de un peso calibrado próximo a 5Kg, voy a usar un peso que tengo por aquí de exactamente 455 gramos (Es largo de explicar). Si colocas tu peso patrón en la balanza, veras como las lecturas cambia a números mucho mayores:
Te recomiendo, dejarle hacer unas cuantas lecturas, (Entre 32 y 64, por ejemplo) porque puedes ver que hay pequeñas variaciones en la medida en bruto y después hacer el promedio de todas esas medidas. Lo que yo he hecho es copiar esas medidas desde la consola (Si. Puedes copiar directamente los valores) y pegarlos en Excel sin más. Después usa la función promedio(Rango) y te dará un número que será la media: En mi caso 177.250.
Como sé que mi peso es de 455 gramos, mi factor de escala es la división ambos valores:
Una vez conocido el valor de conversión de nuestra balanza, con el peso real colocado en el plato, podemos ya, empezar con el programa de pesaje, pero como esto ya se ha alargado bastante, vamos a dejarlo aquí, por ahora. En la próxima sesión desarrollaremos el programa de pesaje final de nuestra báscula. Hasta entonces un saludo.