El HX711 es un amplificador de célula de carga que te permite medir la fuerza (peso) con un Arduino, un ESP8266 o cualquier otra placa microcontroladora.
Recuerdo un alumno del curso de Arduino que desarrolló un sistema de pesado de bombonas de butano.
Sabiendo cuánto pesa una bombona vacía, fácilmente se puede controlar el estado de la bombona utilizando células de carga y el amplificador HX711 conectado a un Arduino.
Si además lo conectas a un ESP8266, puedes hacer un seguimiento a lo largo del tiempo enviando los datos a alguna plataforma en la nube para el IoT o utilizando Node-RED.
Es este tutorial paso a paso te voy a enseñar cómo hackear una báscula y poder medir el peso con un Arduino UNO para mostrarlo por el monitor serie.
Pero lo primero es entender qué es una célula de carga.
Indice de contenidos
¿Qué es una célula de carga?
Una célula de carga o celda de carga es un elemento físico (también llamado transductor) capaz de traducir la presión o fuerza en una señal eléctrica.
Es el elemento que nos va a permitir saber cuanto pesan las cosas.
Viene a ser como cualquier otro transductor. Por ejemplo, un micrófono es capaz de transformar ondas de presión en el aire en una señal eléctrica.
Luego, como ya vimos en otro artículo, el convertidor analógico digital se encarga de traducir esa señal analógica en una señal digital para que un microcontrolador u ordenador pueda entenderlo.
Vale, pero ¿cómo una célula de carga convierte una presión o fuerza en una señal electrónica?
Existen tres formas en las que una célula de carga es capaz de traducir una fuerza en una señal electrónica.
Célula de carga hidraúlica
Como su propio nombre indica, se trata de una célula de carga con un sistema hidráulico que consiste en un pistón y un cilindro.
Cuando una fuerza se ejerce en el pistón, se comprime un fluido dentro del cilindro y eso corresponde a una presión.
Célula de carga neumática
En este caso, la célula de carga utiliza la presión del aire a través de un diafragma.
Con un manómetro se mide la presión ejercida.
Célula de carga basada en galga extensométrica
Por último, la célula de carga basada en una galgas extensométricas que son las que vamos a utilizar en este tutorial.
Existen más células de carga pero son menos comunes.
Una galga extensométrica es un sensor que cambia su resistencia dependiendo de la presión que se ejerza sobre él debido al efecto piezorresistivo.
Existen otros sensores que cambian su resistencia debido a otros fenómenos físicos. Por ejemplo las fotorresistencias o LDR que cambian su resistencia dependiendo de la luz que incide en ellas.
En el caso de la galga extensométrica la resistencia cambia por la presión, carga o deformación del material.
Básicamente si coges una tira de metal conductor y la estiras, se volverá más delgada y más larga y la resistencia aumenta. Por el contrario, si la tira de metal se contrae bajo una fuerza, la resistencia disminuye.
Esta capacidad del sensor nos permite relacionar la fuerza con una señal eléctrica (un voltaje) y por lo tanto, podemos tratarlo con un circuito eléctrico.
Existen diferentes células de carga basadas en galgas extensométricas pero todas funcionan más o menos igual.
Varían en tamaño, material y configuración mecánica lo que hace que cada célula de carga tenga diferentes sensibilidades, máximos y mínimos.
Problemas con las células de carga con galga extensométrica
La galga extensométrica más común está formada por un alambre o lámina muy fina configurada de tal manera que hay un cambio lineal en la resistencia eléctrica cuando se aplica una deformación en una dirección específica.
Las resistencias más comunes son las de 120Ω, 350Ω y 1.000Ω.
Con un dispositivo capaz de medir la tensión podríamos saber cómo varía la resistencia y en consecuencia la fuerza que se está ejerciendo.
Esto nos daría la información del peso.
¿Qué es lo que sucede?
Pues que los cambios de resistencia son realmente pequeños. Si la resistencia es de 120Ω, los cambios que se pueden producir con un peso considerable es de 0.12Ω.
Esto es un verdadero problema ya que necesitaríamos un dispositivo capaz de medir estos pequeños cambios en la resistencia (son dispositivos muy caros) o coger ese pequeño cambio y amplificarlo.
Aquí es donde entra en juego el puente de Wheatstone, un circuito muy simple que te permitirá detectar esas pequeñas variaciones de resistencia.
Puente Wheatstone
Una forma muy buena de coger esos pequeños cambios en la resistencia de la galga extensométrica y convertirlos en algo que realmente podamos medir es utilizar un puente de Wheatstone.
El puente Wheatstone es un circuito eléctrico que se utiliza para medir resistencias desconocidas mediante la técnica conocida como el equilibrio de brazos.
Conociendo la tensión de la fuente y midiendo la tensión VG, se puede obtener el valor de la resistencia RX.
Si la resistencia RX es una galga extensométrica, será proporcional al peso que está deformando la galga.
Si quieres saber más cómo funciona te recomiendo que leas el artículo de All About Circuits.
Pero ¿qué pasa si queremos utilizar cuatro galgas extensométricas para una mayor precisión?
Por ejemplo, las típicas básculas que hay en casa.
En este caso, todas las resistencias del puente de Wheatstone son galgas extensométricas.
Por último, hay que conectar el puente Wheatstone a un amplificador para poder medir las señales con un Arduino.
Este amplificador de carga puede ser el HX711 y es el que vamos a utilizar.
Bueno, yo creo que con esto es más que suficiente para más o menos tener una idea de cómo funciona una báscula y qué elementos y componentes entran en acción.
Ahora, vamos a por la parte práctica.
Báscula digital con Arduino y el amplificador HX711
La idea de este tutorial es hacer una báscula con un Arduino UNO y que muestre la información por el monitor serie o en un display o LCD.
Lo primero que necesitas saber es el material que vamos a utilizar a lo largo de este tutorial:
La báscula puede valer cualquiera. La más barata que encuentres ya que la vamos a abrir y quitar el circuito que lleva dentro :)
Vamos a ir viendo por partes el material y la función que desempeña cada componente en este tutorial.
Empezamos por el amplificador HX711.
Amplificador de célula de carga HX711
El amplificador de célula de carga HX711 te permite obtener los datos de una célula de carga para tratarlos con un Arduino.
La finalidad de este componente es amplificar la señal que se obtiene de la célula de carga para luego dentro del microcontrolador poder hacer la operación de proporcionalidad y saber el peso que hay encima de la báscula.
La célula de carga que vamos a utilizar es la que viene dentro de la báscula. Suelen ser células de carga simple.
Como veremos más adelante, se utilizan cuatro situadas en forma de cuadrado y equidistantes unas de otras.
Vamos, como están situadas en la báscula de baño.
El amplificador HX711 tiene dos filas de pines. Una fila sirve para conectarse a la célula de carga y otra fila sirve para conectarse al microcontrolador.
Pines conexión HX711 y célula de carga
El amplificador de célula de carga HX711 admite cinco cables de la propia célula que se conectan en los pines RED, BLK, WHT, GRN y YLW.
Estos colores corresponden al código de color que suele ser una convención en las células de carga donde los cables rojo, negro, blanco y verde vienen de la tensión de la célula de carga y el amarillo es un cable de tierra opcional.
Por norma general, cada célula de carga tiene 4 puntos para medir las 2 tensiones que hemos visto en el puente de Wheatstone.
Por un lado tenemos la tensión de entrada o de excitación (en inglés Excitation) y por otro lado la tensión de salida (en inglés Output).
Entonces la correspondencia entre los cables y las conexiones con el amplificador HX711 son las siguientes:
| Conexión puente Wheatstone | Color |
| Excitation + | Rojo |
| Excitation – | Negro |
| Output + | Blanco |
| Output – | Verde |
Puede que en algunas células de carga los colores varíen y en vez de el negro se utilice el amarillo o en vez de el verde el azul. Para asegurarte lo mejor es acudir a la hoja de características técnicas de la célula de carga.
Algo muy común es que las lecturas del HX711 no sean lo que esperas como por ejemplo, que sean opuestas. Si disminuye el peso cuando tendría que aumentar cambia las conexiones de Output + y Output -.
Pines conexión con el microcontrolador
Por otro lado tenemos los pines de conexión con el microcontrolador: VDD, VCC, DAT, CLK y GND.
- VCC: tensión de alimentación. Admite un voltaje de entre 2,6V y 5,5V.
- VDD: tensión de nivel lógico que se utiliza. Si es un Arduino UNO es 5V y un ESP8266 es 3,3V.
- DAT: pin de datos.
- CLK: pin señal de reloj.
- GND: pin de conexión a tierra.
En algunos módulos como el que recomiendo en este tutorial, no hay acceso al pin VDD ya que internamente está puenteado con VCC. Es algo lógico ya que la tensión que obtienes de la placa está relacionada con el nivel lógico con el que trabajas.
Por lo tanto, por un lado tenemos los pines que van conectados a la célula de carga y por otro lado los pines que van conectados a un Arduino UNO.
Si quieres más información sobre el amplificador HX711 te recomiendo que eches un vistazo a la hoja de características técnicas.
A continuación vamos a ver el esquema completo de conexiones entre Arduino, la célula de carga y el amplificador HX711.
Esquema eléctrico Arduino, célula de carga y HX711
Estas serían las conexiones entre el HX711, Arduino y la célula de carga.
La conexión con Arduino es muy sencilla.
Del pin de 5V sacas un cable y lo conectas con VCC. Si tu módulo HX711 tiene un pin VDD conéctalo también a 5V.
El pin GND de Arduino lo conectas al pin GND del módulo HX711. Los pines DAT y CLK se conectan a los pines 3 y 2 de Arduino.
Puedes utilizar cualquier pin de Arduino para conectar con DAT y CLK. Es fácil cambiarlo en el código que veremos luego.
Respecto a la parte de conexión con la célula de carga, hemos visto que vamos a necesitar cuatro cables conectados a los pines RED, BLK, WHT y GRN.
En la siguiente sección verás de dónde sacamos estos cables.
Hackear la báscula de baño
Ha llegado el momento de sacar las herramientas y abrir la báscula de baño que has comprado o que tienes por casa. Abrelo sin miedo :)
También puedes comprar todos los componentes por separado: 4 células de carga simples y el HX711. Pero vamos, el precio más o menos viene a ser el mismo que si compras una báscula nueva.
Lo que hay dentro dependerá de cada báscula pero lo normal es que te encuentres 4 grupos de 3 cables que van conectados a un circuito y 2 cables de alimentación que van hacia una pila.
El siguiente paso es cortar todos los cables que van al circuito desde los sensores de carga. También corta los cables de alimentación y retira el circuito.
De nuevo sin miedo :)
Entonces tenemos 4 células de carga simple separadas equidistantes formando un cuadrado. De cada célula de carga salen 3 cables y por lo tanto tenemos 12 cables.
Por supuesto que así la báscula no funciona pero esto lo vamos a arreglar dentro de muy poco.
Pero una cosa, el HX711 sólo admite 4 cables. ¿Cómo combinar esos 12 cables para al final solo tener 4?
Pues es lo que vamos a ver a continuación.
Conexión báscula con HX711
Por ahora lo que tenemos es una báscula destripada con 4 conjuntos de 3 cables que salen de cada sensor o célula de carga. Todo esto hay que combinarlo en 4 cables para conectarlo con el amplificador HX711.
La combinación se puede hacer de dos formas: utilizando un componente o combinando los cables de forma manual.
Módulo combinador de carga
Lo más rápido sería utilizar un módulo combinador de SparkFun que combina todos los cables. Este módulo va entre los 4 sensores de carga y el amplificador HX711.
Lo único que hay que hacer es conectar los cables a las conexiones donde pone LR, LL, UR y UL.
Cómo se conecta cada sensor de carga lo veremos ahora.
Para los sensores de carga simple como los que utiliza esta báscula no hay un estándar de colores. En una báscula de baño puedes encontrar diferentes colores de cables.
Puedes encontrar un poco de todo, que el color negro se mantenga, que el color rojo y blanco se intercambien o que el color blanco se sustituya por un color verde.
La combinación más típica es encontrar rojo, negro y blanco.
Pero para asegurarte lo mejor es que midas la resistencia interna entre los pares de cables. El par que tenga más resistencia (aproximadamente al doble) es el que va al positivo y al negativo.
Por ejemplo, en mi caso al medir la resistencia entre el blanco y el negro la resistencia es de unos 2.000Ω
Sin embargo, cualquier otra combinación (negro-rojo o rojo-blanco) el resultado es alrededor de 1.000Ω
Por lo tanto, en mi caso particular los cables van conectados de la siguiente manera.
| Cable sensor de carga | Conexión módulo combinador |
| Rojo | C (Toma central) |
| Negro | – |
| Blanco | + |
Lo único que nos falta saber es donde conectar cada sensor de carga. Esto viene determinado por la posición.
Lo primero es definir qué es superior (upper) o inferior (lower). Si miras el módulo combinador verás las iniciales LR, LL, UR y UL.
Cada sensor de carga tiene que ir asignado a una de estas iniciales.
Estas iniciales significan:
- LR: Lower Right o inferior derecha
- LL: Lower Left o inferior izquierda
- UR: Upper Right o superior derecha
- UL: Upper Left o superior izquierda
Qué sea superior o inferior depende de nosotros. Por ejemplo para mi la combinación sería la siguiente.
Con esta información ya tenemos todo para conectar los cables de los 4 sensores de carga al módulo combinador y después al HX711.
Este sería el esquema de conexiones.
Con esto ya tendríamos todo conectado para empezar a trabajar en la programación.
Pero ¿qué sucede si no tenemos un módulo combinador?¿podríamos combinar nosotros mismos los cables?
A estas preguntas les daré respuesta en el siguiente apartado.
Combinación de cables manual
La otra opción sirve cuando no tenemos un módulo combinador. Se puede solucionar mirando el esquema eléctrico de SparkFun de este componente que lo puedes encontrar aquí.
Sólo tienes que seguir los cables y hacer las mismas conexiones que hace el módulo pero de forma manual. Quizás sea algo más complejo pero te ahorras un componente.
Esta es la ventaja que tiene el hardware libre, tienes a tu disposición todos los esquemas para que tu mismo te puedas fabricar los componentes o aprender.
Vamos a ver un ejemplo con los dos primeros sensores de carga que aparecen en el esquema: UL y UR.
Según el esquema el cable rojo (C) del sensor UL va directamente al pin BLK del HX711.
Si te fijas en el cable blanco, va directamente conectado al cable blanco del sensor UR y el cable negro al cable negro del sensor LL.
Y así con el resto de los sensores de carga. Al final te quedará un esquema como este.
En los dos casos, ya sea con el módulo combinador o la combinación manual, podremos medir el peso a través del amplificador HX711
Ahora solo queda una cosa y es programar el microcontrolador de Arduino para que todo el sistema funcione.
Programación del amplificador HX711 y Arduino
Ha llegado la hora de darle vida a todo el proyecto. Hasta ahora lo único que tenemos es un sistema de pesado conectado a un Arduino a través del amplificador HX711.
Pero esto no sirve de nada si no se programa.
Para poder pesar cosas o personas tenemos que hacer dos cosas:
- Calibrar la célula de carga con sus cuatro sensores
- Crear un programa para mostrar el peso en el monitor serie
Antes de meternos con los dos códigos, hay que instalar la librería para manejar el HX711.
Abre el Gestor de Librerías desde la opción del menú Programa>Incluir Librería>Administrar Librerías.
En el Gestor de Librerías busca HX711 e instala la primera opción que aparece, donde pone HX711 Arduino Library by Bogdan Necula, Andreas Moti.
Una vez la instales ya podemos empezar con la calibración de la báscula.
Calibración báscula digital y el amplificador HX711
El primer paso que tenemos que dar es la calibración. El código lo puedes encontrar en el repositorio de GitHub de Sparkfun.
La versión que voy a presentar aquí está traducida y adaptada para este ejemplo.
El código completo sería el siguiente
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
/* Este código fue creado por Nathan Seidle de SparkFun Electronics y lo puedes encontrar en https://github.com/sparkfun/HX711-Load-Cell-Amplifier/blob/master/firmware/SparkFun_HX711_Calibration/SparkFun_HX711_Calibration.ino Está sujeto a la licencia Beerware lo que viene a decir que el código es de dominio público. Si lo utilizas en algún proyecto te comprometes a invitar a una cerveza a Nathan Seidle si algún día te encuentras con el :) Este programa permite calibrar la báscula. Se utiliza para determinar el factor de calibración. También puede servir para generar el factor cero útil en básculas que tienen una masa permanente. Para empezar la configuración de la báscula tienes que iniciar este programa sin tener ningún peso encima de la báscula. Una vez empiecen a aparecer medidas de peso en el monitor serie, coloca algún objeto con un peso conocido sobre la báscula. Luego, en el monitor serie pon + o - (en símbolo) para ajustar el factor de calibración (factor_calibracion) hasta que la salida conincida con el peso conocido del objeto. Por ejemplo, puedes poner un kilo de arroz o un kilo de naranjas. Mi recomendación es que si tienes otro peso en casa primero lo peses en ese peso y así sabrás con exactitud cuanto pesa. Una vez el peso coincida apunta el valor del factor de calibración (factor_calibracion). Tu factor de calibración puede ser muy diferente al mío. Puede que sea muy positivo o muy negativo. Todo esto depende de la configuración de tu sistema de báscula, la célula de carga y los sensores de carga. */ #include "HX711.h" // Pin de datos y de reloj byte pinData = 3; byte pinClk = 2; HX711 bascula; // Parámetro para calibrar el peso y el sensor float factor_calibracion = 20780.0; //Este valor del factor de calibración funciona para mi. El tuyo probablemente será diferente. void setup() { Serial.begin(9600); Serial.println("HX711 programa de calibracion"); Serial.println("Quita cualquier peso de la bascula"); Serial.println("Una vez empiece a mostrar informacion de medidas, coloca un peso conocido encima de la bascula"); Serial.println("Presiona + para incrementar el factor de calibracion"); Serial.println("Presiona - para disminuir el factor de calibracion"); // Iniciar sensor bascula.begin(pinData, pinClk); // Aplicar la calibración bascula.set_scale(); // Iniciar la tara // No tiene que haber nada sobre el peso bascula.tare(); // Obtener una lectura de referencia long zero_factor = bascula.read_average(); // Mostrar la primera desviación Serial.print("Zero factor: "); Serial.println(zero_factor); } void loop() { // Aplicar calibración bascula.set_scale(factor_calibracion); // Mostrar la información para ajustar el factor de calibración Serial.print("Leyendo: "); Serial.print(bascula.get_units(), 1); Serial.print(" kgs"); Serial.print(" factor_calibracion: "); Serial.print(factor_calibracion); Serial.println(); // Obtener información desde el monitor serie if (Serial.available()) { char temp = Serial.read(); if (temp == '+') factor_calibracion += 10; else if (temp == '-') factor_calibracion -= 10; } } |
Sigue las instrucciones que hay en el código, cárgalo a la placa y ten en cuenta lo siguiente:
- Quita cualquier peso de la báscula antes de cargar el código.
- Una vez que empiecen a aparecer datos en el monitor serie pon algo con un peso conocido encima de la báscula (1 kg de arroz o 1 kg de lo que sea pero que sea conocido).
- Ajusta el factor de calibración escribiendo + o – en el monitor serie.
El factor de calibración dependerá de la configuración de cada báscula y no todos tenemos que tener el mismo.
Una vez que el peso que aparezca por el monitor serie coincida con el peso conocido, guarda el factor de calibración.
Ahora que está calibrada la báscula con el HX711, vamos a pasar a ver el ejemplo para obtener el peso de cualquier cosa o persona.
Ejemplo báscula digital con Arduino y el amplificador HX711
En esta última parte lo único que hacemos es utilizar el factor de calibración para mostrar la información correcta de cualquier cosa o persona a través del monitor serie.
El código completo sería el siguiente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
#include "HX711.h" #define DEBUG_HX711 // Parámetro para calibrar el peso y el sensor #define CALIBRACION 20780.0 // Pin de datos y de reloj byte pinData = 3; byte pinClk = 2; // Objeto HX711 HX711 bascula; void setup() { #ifdef DEBUG_HX711 // Iniciar comunicación serie Serial.begin(9600); Serial.println("[HX7] Inicio del sensor HX711"); #endif // Iniciar sensor bascula.begin(pinData, pinClk); // Aplicar la calibración bascula.set_scale(CALIBRACION); // Iniciar la tara // No tiene que haber nada sobre el peso bascula.tare(); } void loop() { #ifdef DEBUG_HX711 Serial.print("[HX7] Leyendo: "); Serial.print(bascula.get_units(), 1); Serial.print(" Kg"); Serial.println(); #endif } |
Cambia el factor de calibración (CALIBRACION) por el que has obtenido del código anterior. No todos tendemos el mismo factor.
Carga el código a la placa y abre el monitor serie. Ahora súbete a la báscula y comprueba el peso. Verás que más o menos indica lo que pesas con muy poca deriva arriba o abajo.
Conclusiones báscula digital con Arduino y el amplificador HX711
En este tutorial has podido comprobar cómo hackear una báscula de baño utilizando un Arduino y un amplificador HX711.
A parte, te he mostrado cómo leer e interpretar un simple esquema eléctrico, el módulo combinador.
Los siguientes pasos ya depende de ti.
Sería muy interesante poder conectar este sensor a un ESP8266 o a un Arduino MKR1000 para poder transmitir esta información a alguna plataforma en la nube.
Esto precisamente es lo que hago con la placa NodeMCU y Wemos en el curso de programación de Arduino + curso de ESP8266.
Es un bonus que incorporo para que aprendas a gestionar usuarios por su peso y enviar la información a ThingSpeak.
Cualquier duda estaré encantado de responder en los comentarios de aquí abajo.
Gracias a Shutterstock por ceder los derechos de la imagen.
