Aprenda a construir uma balança com Arduino e módulo HX711 6

As balanças eletrônicas para cozinha e banheiro que encontramos nas lojas são baseadas em um sensor chamado de célula de carga. Neste post, vamos conhecer estes sensores e ver como usar o módulo HX711 para obter a medição efetuada por eles. Esses conhecimentos serão usados para construir uma balança controlada por um Arduino.

Como funciona uma célula de carga?

Uma célula de carga é um sensor capaz de fornecer um sinal elétrico para indicar uma força. Vamos nos concentrar neste post em um tipo de célula de carga, o strain gauge, na qual a força que desejamos medir irá deformar o sensor. Esta deformação causará uma variação na resistência do sensor.

A dificuldade em usar as células de carga é que esta variação é muito pequena. Para conseguirmos medi-la, usamos uma configuração chamada Ponte de Wheatstone:

Nesta configuração uma tensão é aplicada entre os pontos marcados com Vin e é lida a tensão obtida nos pontos Vout. Quando R1*R4 = R2*R3 a tensão Vout é zero (dizemos que a ponte está balanceada). Uma variação nas resistências pode ser calculada a partir da tensão Vout.

Algumas células de carga possuem internamente quatro sensores já ligados em ponte, neste caso a célula possui quatro fios. A que vamos usar neste post é um modelo de três fios, que contém apenas um sensor. Neste caso, a melhor opção é montar uma ponte com quatro sensores, tomando cuidado com as polaridades de cada um (para que as diferenças não sejam canceladas):

Mesmo usando uma Ponte de Wheatstone, as variações a serem medidas são ainda pequenas demais para serem lidas diretamente por uma entrada analógica do Arduino. É aqui que entra o módulo HX711, que é um conversor analógico digital (ADC) de 24 bits específico para uso com células de carga.

Como calibrar uma célula de carga?

A calibração de célula de carga consiste em determinar a relação entre a tensão lida na ponte (no caso retornada pelo HX711) e a força nela aplicada (no caso, o peso do objeto colocado na balança). Vamos chamar esta relação de escala.

O procedimento básico para realizar a calibração é colocar um peso conhecido e verificar qual a leitura obtida. Uma complicação adicional é que a nossa montagem aplica uma força na célula de carga mesmo quando não temos peso. Este peso inicial (a tara) precisa ser descontado. O procedimento completo de calibração fica assim:

1. Medimos o valor retornado pelo HX711 com a balança vazia. Este valor correspondente à tara é o offset;
2. Medimos o valor leitura retornado pelo HX711 com um peso conhecido na balança;
3. Calculamos escala = (leitura – offset) / peso

Feita a calibração, o peso corresponde a uma leitura informada pelo HX711 será = (leitura – offset) / escala. Como os valores lidos oscilam ligeiramente a cada leitura, vamos usar a média de várias leituras (nos meus testes a variação correspondeu a algumas gramas).

Projeto balança com arduino

Materiais Necessários

Os materiais necessários para a confecção deste projeto são:

• Arduino Uno
• Display LCD Shield com teclado
• 4 x Sensor de Peso 50Kg (Célula de Carga)
• Módulo Conversor HX711

Montagem

O shield de display e teclado deve ser encaixado sobre o Arduino, ele será a nossa “interface com o operador”. A figura abaixo mostra como interligar os quatro sensores de peso ao módulo conversor e como ligar o módulo ao Arduino.

As células de carga que vamos usar possuem um “anel” em torno de uma placa. A movimentação desta placa é que gera o sinal que vamos utilizar. Para que esta placa possa se movimentar, é preciso colocar um espaçador na hora da montagem. Se você tiver acesso a uma impressora 3D, você pode imprimir esta peça. No meu protótipo, fiz os espaçadores com papel cartão grosso e os fixei às células usando fita dupla face:

Coloque uma superfície plana sobre os quatro sensores, de forma que o peso colocado nela seja distribuído igualmente entre eles.

Código

Vamos usar a biblioteca HX711 de Bogdan Necula e Andreas Moti, que você deve instalar através do Gerenciador de Biblioteca da IDE do Arduino:

Além dela, vamos usar as bibliotecas LiquidCrystal e EEProm que vem pré-instaladas na IDE.

O código para a nossa balança é o seguinte:

#include <LiquidCrystal.h>
#include <EEPROM.h>
#include <HX711.h>
 
// Define as conexões da balança e cria o objeto para acesso
const int CELULA_DADO = 2;
const int CELULA_CLOCK = 3;
HX711 celulaCarga;
 
// Define as conexões do display e cria o objeto para acesso
const int rs = 8, en = 9, d4 = 4, d5 = 5, d6 = 6, d7 = 7;
const int backLight = 10;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
 
// Limites para detecção das teclas, em ordem crescente
int limiteTecla[] = { 50, 150, 300, 500, 750, 1024 };
 
// Indices para as teclas
const int TEC_DIREITA = 0;
const int TEC_CIMA = 1;
const int TEC_BAIXO = 2;
const int TEC_ESQUERDA = 3;
const int TEC_SELECT = 4;
const int TEC_NENHUMA = 5;
  
// Endereços na EEProm
const int ENDER_FLAG = 0;
const int ENDER_ESCALA = 1;
 
// Indicação de balança calibrada
const byte FLAG_CALIBRADA = 0x55;
 
// Iniciação
void setup() {
  // Iniciação do Display
  pinMode(backLight, OUTPUT);
  lcd.begin(16, 2);
  mostraVersao();
  digitalWrite(backLight, HIGH);  // acende
  
  // Iniciação do HX711
  celulaCarga.begin(CELULA_DADO, CELULA_CLOCK);
  ajustaTara();
  if (EEPROM.read(ENDER_FLAG) != FLAG_CALIBRADA) {
    calibra();
  } else {
    // Usa escala salva na EEPROM
    float escala;
    EEPROM.get (ENDER_ESCALA, escala);
    celulaCarga.set_scale(escala);
  }
  mostraVersao();
}
 
// Laço principal
void loop() {
  // Lê e mostra o peso
  float peso = celulaCarga.get_units();
  char medida[17];
  dtostrf (peso, 7, 3, medida);
  strcat (medida, "Kg");
  lcd.setCursor(0,1);
  lcd.print(medida);
 
  // Dá um tempo entre as leituras
  delay (500);
  
  // Trata as teclas
  int tecla = leTecla();
  if (tecla != TEC_NENHUMA) {
    lcd.setCursor(0,1);
    lcd.print("Solte a tecla");
    while (leTecla() != TEC_NENHUMA) {
      delay(100);
    }
    if (tecla == TEC_DIREITA) {
      ajustaTara();
    } else if (tecla == TEC_ESQUERDA) {
      ajustaTara();
      calibra();
    }
    mostraVersao(); // recompõe a tela
  }
}
 
// Apresenta a identificação e versão do programa
void mostraVersao() {
  lcd.clear();
  lcd.print("BALANCA v1.00");
}
 
// Ajusta o offset para o valor da balança vazia
void ajustaTara() {
  lcd.setCursor(0,1);
  lcd.print("Registrando TARA");
  delay(500);
  celulaCarga.tare(50);
}
 
// Efetua a calibração da balança
void calibra() {
  // Mostra as instruções
  lcd.clear();
  lcd.print ("CALIBRACAO");
  delay (2000);
  lcd.clear();
  lcd.print("Coloque 1Kg");
  lcd.setCursor(0,1);
  lcd.print ("Aperte SELECT");
  while (leTecla() != TEC_SELECT) {
    delay(100);
  }
  lcd.setCursor(0,1);
  lcd.print("Solte  SELECT");
  while (leTecla() != TEC_NENHUMA) {
    delay(100);
  }
  lcd.print("Aguarde......");
  delay(1000);
 
  // Faz a leitura e calcula a escala
  long leitura = celulaCarga.read_average(50);
  float escala = (leitura - celulaCarga.get_offset())/1.00f;
 
  // Salva na EEProm
  EEPROM.put(ENDER_ESCALA, escala);
  EEPROM.write(ENDER_FLAG, FLAG_CALIBRADA);
 
  // Usa a escala calculada
  celulaCarga.set_scale(escala);
}
 
// Le uma tecla
// Cada tecla do shield resulta em uma tensão diferente em A0
int leTecla() {
  int leitura = analogRead(A0);
  int tecla;
  for (tecla = 0; ; tecla++) {
    if (leitura < limiteTecla[tecla]) {
      return tecla;
    }
  }
  return TEC_NENHUMA; // Não deve acontecer!
}

Operação e Funcionamento

Quando você ligar (ou reiniciar) o Arduino, o programa considera que a balança está vazia, coloca um aviso no display e chama o método tare() da biblioteca. Esta rotina lê 50 vezes o valor retornado pelo HX711 e considera que a média é o offset a ser descontado de todas as leituras.

Em seguidam o programa verifica na EEProm se já foi feita a calibração. Se não, será feito o procedimento de calibração:

• Coloca uma mensagem no display pedindo para colocar um peso de 1Kg;
• Aguarda o pressionar e soltar a tecla Select;
• Chama o método read_average() da biblioteca para obter a média de 50 leituras do HX711;
• Calcula a escala e salva na EEProm.

Como parte final da iniciação, o valor da escala é passado para a biblioteca através do método set_scale().

Concluída a iniciação, o programa passa a chamar periodicamente o método get_units() e a apresentar o valor retornado. Este método obtém uma leitura do HX711 (usamos uma média de 4 leituras), subtrai o offset e divide pela escala, resultando no valor em quilos.

O programa testa também se foi apertada e solta uma das seguintes teclas:

• Right: faz novamente o processo de tara;
• Left: refaz a calibração.

Estas teclas devem ser apertadas com a balança vazia.

Veja mais detalhes sobre o uso do LCD shield com teclado.

Obs.: Esta balança tem fins apenas didáticos. Dependendo do uso, balanças tem que passar por processos verificatórios do Inmetro.

Conclusão

Neste artigo vimos como funcionam as células de carga e como usar o módulo HX711 para fazer uma medição de peso. Colocamos esses conhecimento em prática fazendo uma balança.

Abaixo um teste rápido da balança. Mesmo com uma montagem simples, a precisão obtida foi da ordem de algumas gramas.

Agora que você já conhece as células de carga e o módulo HX711, que tal fazer algum projeto com eles? E, se quiser, você pode postar seu projeto na nossa Comunidade Maker no Facebook.

Gostou do artigo? Deixe seu comentário logo abaixo dizendo o que achou. Para mais artigos e tutorias de projetos acesse nosso blog.