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.
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.
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:
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.
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:
O módulo é mostrado na imagem abaixo:
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).
Células de carga são usadas em aplicações comerciais e industriais para medição de peso/carga em geral.
Nosso projeto de exemplo será o seguinte:
Usar duas células de carga para fazer a pesagem de objetos e mostrar na porta serial.
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. 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-.
Para facilitar a montagem em Protoboard, pinos podem ser soldados nas extremidades dos fios das células de carga. Veja que o ponto de apoio da superfície da balança deve ser na seta preta (parte superior da célula). A parte inferior da célula deve estar sobre uma base plana também.
Célula de Carga 50 Kg – Foto Gustavo Murta
A parte inferior da célula deve ser suspendida , pois senão os pinos que prendem o transdutor impedirão a flexão do sensor. Nesse caso, usei velcros adesivos recortados para prender na parte inferior.
Base com suspensão – Foto Gustavo Murta
Materiais necessários para o projeto Balança Digital com Arduino e Célula Strain Gauge
A ligação com o HX711 e o Arduino é mostrada abaixo:
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.
Para nossos Sketches vamos usar a biblioteca HX711.h, que pode ser baixada neste link.
Primeiro passo é a calibração das células de carga. Usando a montagem com as duas células de 50 Kg, rode o programa de calibração abaixo. Na minha montagem , o fator de calibração foi de 42130 (para pesagem em kilogramas). Por isso, esse valor foi inserido no programa. Após a calibração, anote o valor aferido do Fator de Calibração para ser inserido nos seus programas de Balança com o HX711.
Passos para Calibração :
Cada célula de carga poderá ter um valor diferente para o fator de calibração . Se algum peso medido estiver dando valor negativo, inverta os fios dos pinos A+ e A-.
Se a sua balança permite o uso das duas células ao mesmo tempo, faça o procedimento de calibração com as duas células montadas por baixo da base da balança.
Quando a balança estiver com uma precisão adequada, pare o procedimento e anote o valor do Fator de Calibração. Refaça o processo de calibração com outros pesos conhecidos, se achar necessário.
/* Programa para Calibração do HX711
Blog Eletrogate - https://blog.eletrogate.com/balanca-digital-com-arduino-aprenda-a-usar-a-celula-de-carga
Arduino UNO - IDE 1.8.5 - Modulo HX711 - celulas de Carga 50 Kg
Gustavo Murta 17/abril/2019
Biblioteca https://github.com/bogde/HX711
Baseado em https://www.hackster.io/MOHAN_CHANDALURU/hx711-load-cell-amplifier-interface-with-arduino-fa47f3
*/
#include "HX711.h" // Biblioteca HX711
#define DOUT A0 // HX711 DATA OUT = pino A0 do Arduino
#define CLK A1 // HX711 SCK IN = pino A1 do Arduino
HX711 balanca; // define instancia balança HX711
float calibration_factor = 42130; // fator de calibração para teste inicial
void setup()
{
Serial.begin(9600); // monitor serial 9600 Bps
balanca.begin(DOUT, CLK); // inicializa a balança
Serial.println(); // salta uma linha
Serial.println("HX711 - Calibracao da Balança"); // imprime no monitor serial
Serial.println("Remova o peso da balanca");
Serial.println("Depois que as leituras começarem, coloque um peso conhecido sobre a Balança");
Serial.println("Pressione a,s,d,f para aumentar Fator de Calibração por 10,100,1000,10000 respectivamente");
Serial.println("Pressione z,x,c,v para diminuir Fator de Calibração por 10,100,1000,10000 respectivamente");
Serial.println("Após leitura correta do peso, pressione t para TARA(zerar) ");
balanca.set_scale(); // configura a escala da Balança
zeraBalanca (); // zera a Balança
}
void zeraBalanca ()
{
Serial.println(); // salta uma linha
balanca.tare(); // zera a Balança
Serial.println("Balança Zerada ");
}
void loop()
{
balanca.set_scale(calibration_factor); // ajusta fator de calibração
Serial.print("Peso: "); // imprime no monitor serial
Serial.print(balanca.get_units(), 3); // imprime peso da balança com 3 casas decimais
Serial.print(" kg");
Serial.print(" Fator de Calibração: "); // imprime no monitor serial
Serial.println(calibration_factor); // imprime fator de calibração
delay(500) ; // atraso de 0,5 segundo
if (Serial.available()) // reconhece letra para ajuste do fator de calibração
{
char temp = Serial.read();
if (temp == '+' || temp == 'a') // a = aumenta 10
calibration_factor += 10;
else if (temp == '-' || temp == 'z') // z = diminui 10
calibration_factor -= 10;
else if (temp == 's') // s = aumenta 100
calibration_factor += 100;
else if (temp == 'x') // x = diminui 100
calibration_factor -= 100;
else if (temp == 'd') // d = aumenta 1000
calibration_factor += 1000;
else if (temp == 'c') // c = diminui 1000
calibration_factor -= 1000;
else if (temp == 'f') // f = aumenta 10000
calibration_factor += 10000;
else if (temp == 'v') // v = dimuni 10000
calibration_factor -= 10000;
else if (temp == 't') zeraBalanca (); // t = zera a Balança
}
}
Janela do monitor serial da Arduino IDE , com o procedimento de Calibração :
Após a Calibração das células de Carga, agora poderá rodar o programa da Balança.
Altere o valor do Fator de calibração no Programa Arduino HX711 Balança (insira o valor encontrado no procedimento de Calibração).
float calibration_factor = 42130; // fator de calibração aferido na Calibraçao
Remova qualquer peso sobre as células de carga, e pressione T para zerar a Balança.
Insira o peso na Balança e verifique o peso.
/* Programa para Balança com o HX711
Blog Eletrogate - https://blog.eletrogate.com/balanca-digital-com-arduino-aprenda-a-usar-a-celula-de-carga
Arduino UNO - IDE 1.8.5 - Modulo HX711 - celulas de Carga 50 Kg
Gustavo Murta 17/abril/2019
Biblioteca https://github.com/bogde/HX711
Baseado em https://www.hackster.io/MOHAN_CHANDALURU/hx711-load-cell-amplifier-interface-with-arduino-fa47f3
*/
#include "HX711.h" // Biblioteca HX711
#define DOUT A0 // HX711 DATA OUT = pino A0 do Arduino
#define CLK A1 // HX711 SCK IN = pino A1 do Arduino
HX711 balanca; // define instancia balança HX711
float calibration_factor = 42130; // fator de calibração aferido na Calibraçao
void setup()
{
Serial.begin(9600);
balanca.begin(DOUT, CLK); // inicializa a balança
Serial.println("Balança com HX711 - celula de carga 50 Kg");
Serial.println("Pressione t para Tara"); // imprime no monitor serial
balanca.set_scale(calibration_factor); // ajusta fator de calibração
balanca.tare(); // zera a Balança
}
void loop()
{
Serial.print("Peso: "); // imprime no monitor serial
Serial.print(balanca.get_units(), 3); // imprime peso na balança com 3 casas decimais
Serial.println(" kg"); // imprime no monitor serial
delay(500) ; // atraso de 0,5 segundos
if (Serial.available()) // se a serial estiver disponivel
{
char temp = Serial.read(); // le carcter da serial
if (temp == 't' || temp == 'T') // se pressionar t ou T
{
balanca.tare(); // zera a balança
Serial.println(" Balança zerada"); // imprime no monitor serial
}
}
}
Janela do monitor serial da Arduino IDE , com o programa da Balança HX711 ( peso = 1,250 Kg) :
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 importante para a qualidade das medições é a forma como as células de carga são montadas na balança.
O ideal é usar uma superfície plana sobre 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
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!
Tenha a Metodologia Eletrogate na sua Escola! Conheça nosso Programa de Robótica Educacional.
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
Eletrogate Componentes Eletrônicos
CNPJ: 18.917.521/0001-73
