Live Coding Musical com RP Pico e Sonic Pi
abril 24, 2026
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 é 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:
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.
A ligação com o HX711 e o Arduino é mostrada abaixo:
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 :/* 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.
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!
|
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.
Encontre tudo na Loja Eletrogate com frete grátis para compras acima de R$ 200
