Sensor de Peso no Arduino - Célula de Carga com conversor HX711

Sensor de Peso com Arduino – Célula de Carga com conversor HX711

As balanças, equipamentos capazes de medir o peso de um objeto, são importantes em diversas atividades, onde é necessário saber a massa de uma substância ou produto. Nesse tutorial vamos aprender como montar um sensor de peso com Arduino, usando uma célula de carga em conjunto com um conversor de sinal AD. 

Sensores de Peso

O primeiro passo para entender como um sensor funciona é investigar qual a propriedade física que ele mede. No caso de uma balança, é a força exercida sobre uma superfície, que nada mais é do que o peso.

Quando um objeto está sobre uma superfície, ele exerce uma força sobre ela que é igual a sua massa multiplicada pelo aceleração da gravidade. 

Célula de Carga

Quando submetido a uma força ou carga, um corpo se deforma momentaneamente. Essa deformação altera as propriedades físicas do material, e se esse material for um condutor, pode alterar sua resistência elétrica. A imagem abaixo mostra um strain gauge, ou extensômetro, que é a resistência elétrica utilizada como sensor. Essa resistência é colada na superfície do corpo que vai ser submetido a carga para que sofra a mesma deformação do corpo. A direção vertical é a mais sensível às forças, então o sensor é posicionado na direção da carga.

 

A resistência de um material é proporcional ao seu comprimento e inversamente proporcional a sua área. Por isso, se houver uma força esticando pelas bordas o strain gauge da figura, seu comprimento aumenta, aumentando sua resistência. Se ao invés de esticado, estiver sendo comprimido, então sua resistência diminui.

A célula de carga é montada em uma ponte de Wheatstone, como a figura, onde uma ou mais resistências são substituídas por um extensômetro. Quando a ponte está balanceada, as relações entre as resistências é tal que R1/R2 = R4/R3, e Vo é igual a zero.

Se uma das resistências for uma célula de carga, digamos R3, quando houver desbalanceamento da ponte, ou seja, se a resistência for alterada por efeito de uma carga, valores de tensão diferentes de zero passam a ser medidos em Vo.

A célula de carga pode ser construída em ponte completa, meia ponte ou um quarto de ponte. Você pode ver exemplos de montagem aqui. Um sensor de 3 terminais consiste de meia ponte, com um divisor de tensão entre uma resistência fixa e um extensômetro.

 

 

Os terminais desse sensor são:

• Vcc – Fio branco, de alimentação da ponte
• Vss – Fio preto, o GND de alimentação da ponte
• Sinal – Fio vermelho, o Vo de saída

A natureza dos sinais mecânicos transformados em elétricos através dos transdutores é analógica e contínua no tempo. Entretanto, para permitir que o sinal possa ser tratado e processado por um microcontrolador é necessário fazer uma conversão do sinal analógico para um sinal digital. 

Essa transformação ocorre através de um conversor A/D (Analógico/Digital). Ele transforma um sinal analógico e contínuo no tempo em um sinal amostrado e discreto no tempo, com precisão determinada pela resolução em bits do conversor utilizado. Quanto mais bits, menor é o erro entre o valor analógico e o valor convertido para digital.

Conversor HX711

O módulo AD HX711 é um conversor analógico/digital de 24 bits, associado a um estágio de amplificação, específico para trabalhar com sensor de carga.

O diferencial de tensão na célula de carga é muito pequeno, assim como são pequenas as variações na medida. Por isso, o sinal precisa ser amplificado.

A saída do módulo usa comunicação serial para enviar a leitura de tensão para o Arduino, que será interpretada como força / peso. 

Mãos à Obra – Montando um Sensor de Peso com Arduino

Componentes Necessários

• 1 x Célula de Carga
• 1 x Módulo AD 24bits HX711
• 2 x Resistores 1 kΩ
• 1 x Arduino Uno R3 ou similar
• 1 x Protoboard
• Jumpers

Montando o Sensor de Peso

As ligações entre a célula de carga, o conversor e o Arduino para montagem do sensor de peso devem ficar como na imagem.

 

 

Atenção na ordem dos terminais que ligam o conversor HX711 na ponte de Wheatstone (E+/E-/A+/A-) e a ligação dos terminais DT e SCK no Arduino.

Programando o Arduino

Biblioteca HX711.h

A biblioteca HX711.h foi criada por Bogdan Necule, e está disponível na IDE Arduino. Ela permite a interface e leitura de dados do módulo. Para baixar você pode ir em “Ferramentas/Gerenciar Bibliotecas” e procurar por HX711. Na lista de bibliotecas, procure o nome do autor. Também está disponível para download na página do autor no GitHub.

Código de calibração

O código abaixo é uma etapa intermediária para o uso do sensor. Copie e cole na IDE Arduino.

// Código de calibração da célula de carga.
//
// Arduino - HX711
// Pin 10 - SCK
// Pin 11 - DT

#include "HX711.h"

#define CELULA_DT  11
#define CELULA_SCK  10

HX711 escala;

float fator_calib = -10000; // Se esse valor estiver muito distante ao iniciar, ajustar e fazer o upload novamente

void setup() {
  
  Serial.begin(9600);
  Serial.println("Rotina para calibrar a célula.");
  Serial.println("Inicie sem carga.");
  Serial.println("Após iniciarem as leituras, coloque um peso de massa conhecida");
  Serial.println("Para calibrar o fator de ajuste digite + ou -");   

  escala.begin(CELULA_DT, CELULA_SCK);
  escala.set_scale();
  escala.tare(); // Ajusta o zero da escala no valor de leitura

}

void loop() {

  escala.set_scale(fator_calib); // Ajusta a escala para esse fator de calibração

  Serial.print("Leitura: ");
  Serial.print(escala.get_units(10), 2); // Retorna a média de 10 medidas
  Serial.print(" kg");
  Serial.print(" Fator: ");
  Serial.print(fator_calib);
  Serial.println();

  if(Serial.available())
  {
    char tecla = Serial.read();
    if(tecla == '+')
      fator_calib += 10;
    else if(tecla == '-')
      fator_calib -= 10;
  }
}

Após escrever o código, clique em Carregar (Upload) para transferir o programa para o Arduino. Com esse código você vai conseguir encontrar o valor de calibração do sensor, ou offset. Esse offset vai ser utilizado no código principal, para medida de cargas.

Código principal

Abaixo está o código para realizar medidas com a sua célula de carga. Crie um novo sketch e cole na IDE.

// Código de medida com a célula de carga.
//

#include "HX711.h"

#define CELULA_DT  11
#define CELULA_SCK  10

HX711 escala;

float fator_calib = -10000; // Coloque aqui o valor encontrado na calibração

void setup() {
  
  Serial.begin(9600);
  Serial.println("Rotina de medida com a célula de carga.");

  escala.begin(CELULA_DT, CELULA_SCK);
  escala.set_scale(fator_calib); // Ajusta a escala
  escala.tare(); // Ajusta o zero da escala
}

void loop() {

  Serial.print("Leitura: ");
  Serial.print(escala.get_units(10), 2); // Retorna a média de 10 medidas
  Serial.print(" kg");
  Serial.println();

  delay(1000);
  
}

Colocando o Sensor de Pesos para Funcionar

Ao executar o código de calibração, deixe a célula sem carga. Após a mensagem de inicialização, coloque um peso conhecido sobre a célula e faça o ajuste do fator de calibração para que o valor lido coincida com o valor real. Depois de calibrado, anote o valor.

Substitua esse valor no código principal e carregue o código. Agora sua balança funciona devidamente ajustada.

Entendendo a Fundo

Entendendo o Software

O programa imprime os dados obtidos com a biblioteca HX711.h no monitor serial. O primeiro código e o segundo são semelhantes, com o primeiro código realizando medida e calibração. O segundo programa utiliza o fator de calibração encontrado no primeiro.

– Incluindo a biblioteca

A biblioteca do conversor AD é incluída:

#include "HX711.h";

– Definimos algumas constantes e variáveis

Essas constantes são traduzidas pelo compilador. Onde no código aparecer, por exemplo, CELULA_DT, o compilador entenderá como o inteiro 11. Essas constantes são usadas para armazenar os pinos DT e SCK do conversor.

#define CELULA_DT 11
#define CELULA_SCK 10 

– Criação do objeto

Em seguida é realizada a criação do objeto escala. Também criamos uma variável com o valor inicial do fator de calibração, que vai ser alterado na execução.

HX711 escala;

float fator_calib = -10000; // Se esse valor estiver muito distante ao iniciar, ajustar e fazer o upload novamente

– Inicialização da Comunicação e Configuração do HX711

Iniciamos a comunicação serial com Serial.begin(). Em seguida inicializamos o objeto escala com a função begin, informando os pinos de dados e clock. Depois setamos a constante de escala e ajustamos o zero da balança. Note que no código principal, a escala é setada com o fator encontrado no código de calibração e não é mais ajustada na execução.

void setup() {

  Serial.begin(9600);
  Serial.println("Rotina de medida com a célula de carga.");
  
  escala.begin(CELULA_DT, CELULA_SCK);
  escala.set_scale(); // Ajusta a escala
  escala.tare(); // Ajusta o zero da escala
}

– Calibração do Sensor de Peso

Em cada loop da rotina principal, a escala é reajustada. Então é realizada a medida e apresentada no monitor serial. A função get_units(10) retorna 10 leituras da célula. Também é apresentado o fator de calibração atual, que será utilizado no código principal.

void loop() {

  escala.set_scale(fator_calib); // Ajusta a escala para esse fator de calibração
  Serial.print("Leitura: ");
  Serial.print(escala.get_units(10), 2); // Retorna a média de 10 medidas
  Serial.print(" kg");
  Serial.print(" Fator: ");
  Serial.print(fator_calib);
  Serial.println();  

}

– Ajuste do Fator de Calibração

Se a tecla + for digitada, o fator de calibração é acrescido de 10. Se for digitado -, o fator sofre decréscimo de 10. Esses valores de incremento e decremento podem ser ajustados no código se for necessário.

if(Serial.available()) {
  char tecla = Serial.read();
  if(tecla == '+')
    fator_calib += 10;
  else if(tecla == '-')
    fator_calib -= 10;
}

Considerações Finais

Nesse tutorial aprendemos o que é uma célula de carga e como montar um sensor de peso com Arduino. Esperamos que tenham gostado, deixe seu comentário com duvidas, sugestões ou com a foto ou vídeo de seu projeto!! Compartilhe à vontade.