Saltar al contenido
Control Automático Educación

Balanza Digital con PIC – HX711

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.

Celdas de Carga con PIC
Instalación de una galga extensiométrica sobre una celda de carga (fuente: WikiPedia)

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.

Puente de Wheatstone en Celdas de Carga

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.

HX711 y Celdas de Carga
HX711 y Celdas de Carga

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.

Balanza HX711
Balanza HX711

El circuito a implementar es el siguiente:

Báscula con hx711+pic

La conexión entre la celda de carga y el HX711 es:

HX711Celda de Carga
E+Cable Rojo
E-Cable Negro
A-Cable Blanco
A+Cable Verde

La conexión entre el HX711 y el PIC es:

HX711Microcontrolador PIC
GNDGND
DTRB2 (pin 35)
SDKRB3 (pin 36)
VCCVCC
Balanza con hx711+pic

Para llevar a cabo este proyecto, vamos a emplear varios conceptos vistos en nuestras clases pasadas:

  1. Para la visualización de datos emplearemos un LCD16x2 con comunicación I2C.
  2. 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:

  1. Botón de RESET: Sirve para reiniciar el programa (simula apagado y encendido de la balanza)
  2. Botón MODO: Sirve para cambiar las unidades de medida de la balanza y para entrar al menú de calibración.
  3. 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.

Entradas relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Comentarios (4)

Hola me parece lo bueno que haces al desarrollar programas que aporten mucho al conocimiento. La verdad tengo muy poco conocimiento pero me gustaría aprender más pero lo que me gustaría es realizar mi propia balanza y que más es lo que me interesa es que como una balanza podría trabajar con el incremento como de 50 gramos en 50 hasta los 300 kilos

Responder

Un saludo.
Que cambios llevará el codigo para leer 4 sensores hx711 con este mismo pic?.

Por favor, podrías poner algo hacerca de esto?.

Responder

Buenas tardes, tengo estos problemas al compilar el código ya que me dice lo siguiente:

WRITE_FLOAT_EEPROM (Function not void and does not return a value)

y en la librería de i2c :

static char data; (variable never used)

Le agradecería su respuesta a que podrían deberse esos problemas, muchas gracias

Responder

Son solo advertencias pero no son errores. En la función no hay nngun retorno de algún dato, en este caso no lo necesitamos. Y en la libreria no se esta usando la variable data, entonces pudes borrarla.

Responder