Balança digital com Arduino e célula Strain Gauge

Célucas de carga com arduino

Célucas de carga com arduino

Hoje vamos falar de um sensor muito útil e prático de ser integrado com aplicações com Arduino. As células de carga baseadas em Strain Gauges, são os elementos sensores utilizados em balanças digitais de vários tipos. A célula do modelo que vamos usar é capaz de medir até 50Kg. Para balanças com maior capacidade pode-se utilizar um número maior de sensores. Neste artigo vamos explicar o que são os sensores Strain Gauges e vamos usar uma célula de carga para medir peso de objetos de até 50Kg e apresentar o resultado em um display LCD.

Introdução

O sensor de carga que vamos usar é um strain Gauge, um dos vários tipos de sensores que podem ser usados para medir peso. É possível utilizar vários sensores de carga simultaneamente para aumentar a capacidade. A nossa célula de carga é um sensor de meia ponte, ou seja, utiliza uma meia-ponte de Wheatstone com uma resistência de referência e um elemento sensor cuja resistência varia conforme a pressão aplicada. Veja a imagem abaixo.

Em geral, são usadas pelo menos duas células de carga, uma para medir compressão e outra para medir tensão (forças aplicadas em direções diferentes). Com duas células de carga, tem-se uma ponte de Wheatstone completa. Para usar apenas uma célula de carga, é necessário completar a ponte com outros dois resistores.

Como funciona um sensor Strain Gauge

O princípio de funcionamento de um Strain Gauge é a mudança na resistência elétrica do sensor proporcional a uma determinada pressão ou força aplicada a ele(daí o nome “Strain”). O sensor Strain Gauge mais comum é feito com fios muito pequenos organizados em um determinado padrão(geralmente em forma de uma ponte de resistência) de forma que quando é aplicado uma força em uma determinada direção, causando uma deformação na disposição dos fios, a resistência varia proporcionalmente.

A sensibilidade de cada sensor e modelo é bem diferente, e geralmente é expressa pelo chamado Gauge Factor(GF). Este é definido como a razão entre uma mudança na resistência elétrica em relação a uma mudança no comprimento(dimensões físicas) provocada por uma força externa.

A grande dificuldade desses sensores é que as deformações provocadas pela aplicação de uma força ou pressão externa são muito pequenas, provocando variações na escala de décimos de ohms. Devido à essas variações de ordem muito pequena, é necessário usar um segundo componente, que é um amplificador de sinais. Existem modelos comerciais específicos para trabalhar com Strain Gauges. Neste artigo vamos usar o amplificador HX711 (mais informações na próxima sessão).

Além dos sensores baseados em strain Gauges, existem também sensores de carga pneumáticos e hidráulicos. Para trabalhar com Arduino e pequenos projetos eletrônicos, o sensor Strain Gauge, que é baseado na variação da resistência elétrica é o mais indicado. Para conhecer um pouco sobre os demais tipos de sensores, veja esse excelente artigo. Para uma rápida introdução em vídeo(em inglês), acesse este link.

A célula de carga que vamos usar possui as seguintes especificações:

  • Dimensões (mm): 28 * 28 * 8;
  • Capacidade (Kg): 50;
  • Margem de erro: 0.2%;
  • Tensão de excitação (V): 5 ~ 10;

Trata-se de um sensor ativo, ou seja, ele é alimentado com um sinal de excitação externo. A saída do sensor é em Volts. Como você deve imaginar, devido á pequena variação na resistência do elemento sensor, a variação na tensão de saída também é muito pequena. Esse sinal de tensão de saída é o que vamos conectar ao amplificador HX711.

Conversor HX711

O Módulo conversor e amplificador HX711 de 24 bits é utilizado para amplificar o sinal de dispositivos como as células de carga, fazendo a interligação entre essas células e o microcontrolador. Recomendamos a leitura do datasheet.

Especificações:

  • Tensão de operação: 4,8 à 5,5V DC;
  • Corrente de operação: 1,6mA;
  • Temperatura de operação: -20 à 85°C;
  • Interface SPI;
  • Dimensões: 29 x 17 x 4mm (sem os pinos)

O módulo é mostrado na imagem abaixo:

Amplificador para célula de carga

Amplificador para célula de carga

O módulo é fabricado pela Avia Semiconductors e seu conversor AD tem precisão de 24 bits. O módulo foi desenhado para interfacear diretamente com sensores em ponte para aplicações de medição de carga. O multiplexador de entrada seleciona entre dois canais diferenciais A e B. Cada canal diferencial pode ser ligado em até duas células de carga(A+ e A- e B+ e B-, cada qual ligado na saída de uma célula de carga em meia ponte).

Aplicações

Células de carga são usadas em aplicações comerciais e industriais para medição de peso/carga em geral.

  • Balanças digitais;
  • Identificação de limites de carga;
  • Pesagem de objetos;
  • Qualquer aplicação para a qual seja necessário fazer medição de carga;

Descrição do projeto

Nosso projeto de exemplo será o seguinte:

Usar duas células de carga para fazer a pesagem de objetos e mostrar na porta serial.

Aspectos de Hardware

Importante ressaltar o padrão de cores usados nessa célula. Como indicado na imagem, o fio vermelho, que usualmente é usado para VCC, é na verdade o sinal de saída(ligado ao pino A- do HX711). E o fio no qual o VCC deve ser ligado é o fio branco. Recomendamos que você faça a medição das resistências entre os fios da célula para saber qual é qual. Os fios que derem uma leitura de 2K são os que devem ser conectados à E+ e E- (geralmente, o fio branco(E+) e preto(E-) ). O fio no qual você obter leituras de 1K é o que deve ser conectado ao A+(geralmente é o fio vermelho). Assim, o pino A+ d HX711 será ligado ao ponto comum entre os dois resistores de 1K.

As células de carga geralmente são usadas em grupos de quatro, em que cada célula é colocada em uma parte da balança. Podem ser usadas em grupos de dois também, em que cada célula é um dos “braços” da ponte de Wheatstone(é o caso em questão). Há também exemplos em que uma das células é substituída por dois resistores de 1k(nesse caso tem que ser resistores de precisão). Outra opção para fazer medições com apenas uma célula de carga é completar a ponte de Wheatstone com um resistor de 1K mais um trimpot. É importante que as resistências sejam o mais próximo possível, de forma que resistores tradicionais com 5% de tolerância não são uma boa ideia. Usar um trimpot multivoltas ou resistores de matafilm de 1% de tolerância é mais adequado.

Nas referências ao final do artigo deixamos algumas dessas montagens como indicação.

A montagem fica mais clara na montagem abaixo:

 

Circuito com células de carga

Circuito com células de carga. Fonte: Connect HX711 to a three wire load cell

Na imagem acima vemos uma ponte de resistência completa. De cada lado usaremos uma célula de carga. Cada célula possui resistência ativa(elemento sensor). Vale notar que, para fins práticos, basta conectar o fio preto de uma célula no fio branco da outra, e cada fio vermelho fica sendo os sinais A+ e A-.

A ligação com o HX711 e o Arduino é mostrada abaixo:

Celula de carga com Arduino

Célula de carga com Arduino

Recomendamos que utilizem principalmente o diagrama de circuito como referência, por ele explicitar as resistências internas das células e ser um desenho mais limpo.

Aspectos de Software

Para nosso código vamos usar a biblioteca HX711.h, que pode ser baixada neste link. O código é praticamente uma versão adaptada do exemplo Serialbegin, que vem junto do arquivo da biblioteca. Como o exemplo foi feito pelo autor da própria biblioteca, convém usá-lo como base para os seus projetos. Algumas variações de códigos que tentamos usar de outros projetos na internet não funcionaram tão bem quanto esse exemplo adaptado.

Basicamente, para fazer a balança funcionar temos de implementar duas etapas. Primeiro, calibramos a balança e, depois, entramos no void loop() para realizar as leituras e apresentá-las na porta serial.

No procedimento de calibração, primeiro são apresentadas algumas leituras iniciais, a calibração é feita por meio da função scale.set_scale(2280.f), e depois novas leituras são feitas a título de comparação. Um ponto importante é que  valor passado na função para setar a escala é para peso medido em libras. Para obter as medidas em Kgs é necessário dividir as leituras por 2.2 (1 libra é igual 0.45Kg).

Após essa primeira parte de calibração, na função void loop() basta fazermos as leituras com a função scale.get_units(). É possível fazer apenas uma leitura e também fazer x leituras e obter o valor médio, passando o número de leituras como argumento, por exeplo: scale.get_units(10).

#include "HX711.h"

#define DOUT A0
#define CLK A1

HX711 scale;

void setup() 
{
  Serial.begin(9600);
  scale.begin(DOUT, CLK);

  Serial.println("Leituras antes de ajustar a escala");
  Serial.println(scale.read());      
  Serial.print("Le a media de 20 leituras do ADX: \t\t");
  Serial.println(scale.read_average(20)); 
  Serial.print("Le valor do ADC menos a tara(aleatorio nessa primeira leitura): \t\t");
  Serial.println(scale.get_value(5));   
  Serial.print("Le valor medio do ADC menos a tara(aleatorio nessa primeira leitura): \t\t");
  Serial.println(scale.get_units(5), 1);  
  
  //Valor usado pelo exemplo para calibrar a balanca. Como foi feito para libras, vamos dividir as leituras
  //por 2.2 para obter o valor em kg. Leia o Readme.txt da biblioteca para mais detalhes
  scale.set_scale(2280.f);   
  scale.tare();     
            
  Serial.println("Leituras depois de ajustar a escala");
  Serial.print("read: \t\t");
  Serial.println(scale.read());                 

  Serial.println("Le valor do ADC menos a tara(aleatorio nessa primeira leitura): \t\t");
  Serial.println(scale.read_average(20));       

  Serial.print("Le valor do ADC menos a tara: \t\t");
  Serial.println(scale.get_value(5));   
  Serial.print("Le valor do ADC menos a tara e ajustado pelo fator de correcao");
  Serial.println(scale.get_units(5), 1);        
            
}

void loop() 
{
  Serial.print("Leitura:\t");
  Serial.print(scale.get_units(), 1);
  Serial.print("\t| Media de 10 leituras\t"); 
  Serial.println(scale.get_units(10), 1);

  scale.power_down();             
  delay(1000);
  scale.power_up();
}


Um acréscimo interessante de ser feito é substituir a porta serial por um display LCD. Assim, as leituras da balança serão apresentadas diretamente no LCD, dispensando o uso do computador para usar o monitor serial. Para incluir a interface com o display LCD, leia esse artigo aqui no Blog e aprenda a integrar displays LCD em seus projetos com Arduino.

Devido a ruídos nas ligações com protoboard e da célula de carga, algumas leituras podem apresentar variações fora da curva. No entanto, as medições tendem a se manter em torno de um valor de referência. Um ponto que influencia bastante a qualidade das medições é a forma com que o peso é inserido na balança.

O ideal é usar uma superfície plana sob as células de carga de forma aplicar o peso todo nas células. A estrutura mecânica que você utilizar para acomodar os pesos pode fazer as leituras variarem um pouco. Fique atento a esse ponto.

Com o circuito montado, basta rodar no PC. Não faça fios muito grandes para conectar as células de carga para diminuir as interferências.

Células de carga montadas com Arduino

Células de carga montadas com Arduino

 

Considerações finais

Nossa recomendação final é que você utilize pelo menos duas células de carga e faça a ponte de wheatstone completa. Muitos exemplos encontrados que utilizam apenas uma célula de carga tiveram muitas dificuldades até conseguir leituras que façam sentido. Reforçamos a sugestão para visitar o post sobre display LCD e incorporar esse elemento ao seu projeto de balança.

Qualquer dúvida, correção ou sugestão, deixe um comentário!

Referências:

Avaliações: 5.0. de 2 votos.
Por favor, aguarde...
Vitor Vidal
Vitor Vidal
Engenheiro eletricista, mestrando em eng. elétrica e apaixonado por eletrônica, literatura, tecnologia e ciência. Divide o tempo entre pesquisas na área de sistemas de controle, desenvolvimento de projetos eletrônicos e sua estante de livros.