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

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?

---

Se você tiver dúvidas, sugestões ou experiências para compartilhar, fique a vontade para deixar um comentário abaixo. E para não perder nenhum conteúdo como este, não deixe de nos seguir no Instagram.