Saludos controlera o controlero, en esta entrada veremos como construir y programar una balanza electronica con un microcontrolador PIC, una celda de carga y un integrado HX711 empleando el CCS C (PIC C).
Antes de comenzar te hago la invitación para que veas todas las entradas de nuestro CURSO GRATUITO DE MICROCONTROLADORES PIC EN CCS C.
Y que te suscríbas al canal de YouTube si te gusta la programación de sistemas embebidos:
Celdas de Carga
Las celdas de carga son sensores que detectan fuerza (masa, torque, etc.) provocada sobre un objeto metálico.
Al momento de aplicar una fuerza sobre una celda de carga, esta convierte dicha fuerza en una señal eléctrica. Las celdas de carga también se conocen como «transductores de carga», dado que convierten una carga (fuerza) en una señale eléctrica.
A pesar de que existen várias configuraciones de las celdas de carga, las más populares son las que emplean sensores piezo resistivos conocidos como las galgas extensométricas capaces de variar una resistencia en función a la presión aplicada sobre ellas.
Dado que la celda de carga mide la fuerza mecánica, principalmente el peso de los objetos, hoy en día, casi todas las balanzas o básculas electrónicas utilizan celdas de carga para medir el peso.
Son muy utilizados debido a la precisión con la que pueden medir el peso y en el mercado pueden encontrarse diferentes clases de celdas de carga, clase A, clase B, clase C y clase D, que difieren según su precisión y capacidad.
Sin embargo como las celdas de carga entregan variación de resistencia a través de las galgas extensiométricas, lo mas común es que se empleen cuatro de estas galgas extensiométricas conectadas en una configuración de puente Wheatstone para leer de forma precisa las variación de resistencia.
Módulo HX711
Para poder leer la información de la celda de carga en nuestra báscula o balanza digital con el microcontrolador PIC empleando PIC C, vamos a necesitar emplear el módulo HX711.
El módulo HX711 es un transmisor que ubicamos entre la celdas de carga y nuestro microcontrolador PIC, para poder determinar el peso del objeto de una forma rápida. Este módulo es compatible con diferentes celdas de carga del mercado tales como: 1kg, 5kg, 20kg y 50kg.
Para poder leer toda la información en nuestro microcontrolador es necesario valernos del Datasheet del HX711.
Si lo deseas puedes adquirir los componentes de este proyecto directamente del portal Chino Aliexpress donde encontrarás los componentes mucho más baratos y con envios a todas partes del mundo:
HX711 con Microcotrolador PIC
Para este proyecto de balanza electrónica con microcontrolador PIC y HX711 se van a emplear los siguientes materiales:
- Microcontrolador PIC 18F4550
- Cristal de Cuarzo 20MHz
- 3 Resistencias 10K
- 3 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
- Fuente de alimentación
- Programador de PIC
Incialmente será necesário crear la balanza empleando la celda de carga, la lámina, la madera y los soportes. Note que la celda de carga tiene una dirección. El lado marcado con 5kg y una flecha hacia abajo debe quedar suspendida para permitir que la celda de carga se deforme al momento de colocar un peso sobre ella.
Sobre ese mismo lado, es recomendable colocar unos soportes que separen la lámina de la celda de carga para evitar que la propia lámina se apoye sobre el pegante blanco de la celda de carga, donde se encuentra ubicado una de las galgas extensiométricas.
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 PIC es:
| HX711 | Microcontrolador PIC |
| GND | GND |
| DT | RB2 (pin 35) |
| SDK | RB3 (pin 36) |
| VCC | VCC |
Para llevar a cabo este proyecto, vamos a emplear varios conceptos vistos en nuestras clases pasadas:
- Para la visualización de datos emplearemos un LCD16x2 con comunicación I2C.
- Para almacenar los factores de escalización se emplea la lectura y escritura en la memoria EEPROM interna del PIC.
Funcionamiento
El proyecto consta de 3 botones:
- Botón de RESET: Sirve para reiniciar el programa (simula apagado y encendido de la balanza)
- Botón MODO: Sirve para cambiar las unidades de medida de la balanza y para entrar al menú de calibración.
- 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, kilogramos y onzas a través del botón MODO y puede tararse algún peso por medio del botón TARA.
Código en PIC C Compiler (CCS C)
Para el siguiente código funcionar, debes bajar la librería HX711.c hecha por mi la cual puedes descargarla en el siguiente botón, junto con la librería del LCD I2C.
Puedes descargar mi librería librería HX711.c también desde mi GitHub dando CLICK AQUI.
/**************************************************************************************
* Balanza Digital con PIC + HX711 + Celda de Carga de 5kg *
* *
* by Sergio Andres Castaño Giraldo *
* website: https://controlautomaticoeducacion.com/ *
* YouTube Chanel: https://www.youtube.com/channel/UCdzSnI03LpBI_8gXJseIDuw *
**************************************************************************************/
#INCLUDE <18f4550.h>
#USE DELAY(CLOCK=20000000,crystal)
#FUSES HS,NOPROTECT,NOWDT,NOBROWNOUT,NOPUT,NOLVP
#use i2c(Master,Fast=100000, sda=PIN_B0, scl=PIN_B1)
#include "i2c_Flex_LCD.c"
#include "hx711.c"
#define MODO PIN_B4
#define TARA PIN_B5
float escala= 0;
float peso_conocido[4] = {550,1000,3000,5000};
//Escribir en la EEPROM
WRITE_FLOAT_EEPROM(long int n, float data) {
int i;
for (i = 0; i < 4; i++)
write_eeprom(i + n, *((int8*)&data + i) ) ;
}
//Leer en la EEPROM
float READ_FLOAT_EEPROM(long int n) {
int i;
float data;
for (i = 0; i < 4; i++)
*((int8*)&data + i) = read_eeprom(i + n);
return(data);
}
//Funcion de calibracion y ajuste
void calibration(){
int i = 0,cal=1;
int32 adc_lecture;
// Escribimos el Mensaje en el LCD
lcd_gotoxy(2, 1);
printf(lcd_putc, "Calibracion de");
lcd_gotoxy(4, 2);
printf(lcd_putc, "Balanza");
delay_ms(1500);
tare(10); //El peso actual es considerado Tara.
lcd_clear();
//Inicia el proceso de ajuste y calibración
while(cal == 1){
lcd_gotoxy(1, 1);
printf(lcd_putc, "Peso Conocido:");
lcd_gotoxy(1, 2);
printf(lcd_putc, "%4.0f g ",peso_conocido[i]);
//Busca el peso conocido con el boton tara
if(input(TARA) == 1){
delay_ms(200); // Anti-debounde
i =(i>2) ? 0:i+1; //if-else en una linea
}
//Selecciona el peso conocido con el boton modo
if(input(MODO)){
delay_ms(200);
lcd_clear();
lcd_gotoxy(1, 1);
printf(lcd_putc, "Ponga el Peso");
lcd_gotoxy(1, 2);
printf(lcd_putc, "y espere ...");
delay_ms(3000);
//Lee el valor del HX711
adc_lecture = get_value(10);
//Calcula la escala con el valor leido dividido el peso conocido
escala = adc_lecture / peso_conocido[i];
//Guarda la escala en la EEPROM
WRITE_FLOAT_EEPROM(0, escala);
delay_ms(100);
cal = 0; //Cambia la bandera para salir del while
lcd_clear();
}
}
}
void main() {
float peso=0,factor = 1;
int unidad = 1;
lcd_init(0x4E,16,2);
lcd_backlight_led(ON); //Enciende la luz de Fondo
init_hx(128);
lcd_clear();
//Lee el valor de la escala en la EEPROM
escala = READ_FLOAT_EEPROM(0);
//Pregunta si se entra al modo de ajuste y calibración
if( input(MODO) == 1 && input(TARA) == 1)
calibration();
lcd_gotoxy(1, 1);
printf(lcd_putc, "Retire el Peso");
lcd_gotoxy(1, 2);
printf(lcd_putc, "y espere ...");
set_scale(escala);
tare(10);
delay_ms(2000);
lcd_clear();
lcd_gotoxy(1, 1);
printf(lcd_putc, "Listo....");
delay_ms(3000);
lcd_clear();
tare(10);
while(1){
peso = get_units(10); //Lee el peso y hace un promedio de 10 muestras
lcd_gotoxy(3, 1);
printf(lcd_putc, "Balanza CAE");
switch (unidad) {
case 1:
factor = 1.0;
lcd_gotoxy(1, 2);
printf(lcd_putc, "Peso: %4.1f g ",peso/factor);
break;
case 2:
factor = 1000.0;
lcd_gotoxy(1, 2);
printf(lcd_putc, "Peso: %4.2f Kg ",peso/factor);
break;
case 3:
factor = 28.35;
lcd_gotoxy(1, 2);
printf(lcd_putc, "Peso: %4.2f oz ",peso/factor);
break;
}
if(input(TARA)==1){
delay_ms(200);
tare(10);
}
if(input(MODO)==1){
delay_ms(200);
unidad = (unidad>2)? 1:unidad+1;
}
delay_ms(100);
}
}
Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:
👉 Invitar a Sergio a un Café ☕️
Que esten muy bien, nos vemos en la siguiente entrada.
Mi nombre es Sergio Andres Castaño Giraldo, y en este sitio web voy a compartir una de las cosas que mas me gusta en la vida y es sobre la Ingeniería de Control y Automatización. El sitio web estará en constante crecimiento, voy a ir publicando material sobre el asunto desde temas básicos hasta temas un poco más complejos. Suscríbete al sitio web, dale me gusta a la página en Facebook y únete al canal de youtube. Espero de corazón que la información que comparto en este sitio, te pueda ser de utilidad. Y nuevamente te doy las gracias y la bienvenida a control automático educación.