Balança de pesagem digital usando célula de carga e Arduino

Experimente Nosso Instrumento Para Eliminar Problemas





Neste post, vamos aprender sobre a célula de carga baseada em extensômetro. Exploraremos o que é Strain Gauge, o que é Load Cell, efeito da temperatura no strain gauge, compensação de temperatura com ponte de Wheatstone e amplificador Load Cell HX711 e, finalmente, aprenderemos como construir uma máquina de balança baseada em Arduino implementando célula de carga como o sensor de peso.

Este artigo trata da medição de peso e métodos de medição, e implementa os métodos em um circuito de balança baseado em Arduino.



Todos nós amamos ver nosso peso, independentemente da nossa idade, uma criança pequena pode adorar ver seu ganho de peso e adultos podem adorar ver sua perda de peso. O peso é um conceito vital desde a antiguidade que ajudou na comercialização de mercadorias, desenvolvimento de equipamentos científicos e produtos comerciais.

Nos tempos modernos, medimos pesos em quilogramas, miligramas e até microgramas para fins de laboratório. Um grama é igual em todo o mundo, todos os dispositivos de medição de peso devem medir o mesmo. A produção em massa de uma pílula com pequena diferença de alguns miligramas de dosagem é suficiente para transformar uma pílula salva-vidas em uma pílula suicida.



O que é peso?

Peso é a força exercida em um avião. A quantidade de força exercida é diretamente proporcional à massa de um objeto, o que significa que quanto maior a massa do objeto, maior a força exercida.

Massa é a quantidade de matéria física presente em um objeto.

O peso depende de mais um fator: Gravidade.

A gravidade é constante em todo o globo (existem pequenas variações na gravidade devido à forma esférica não uniforme da Terra, mas é muito pequena). O peso de 1 kg na terra pesará 160 gramas na lua com exatamente a mesma massa, porque a lua tem uma atração gravitacional muito mais fraca.

Agora você sabe o que é peso e quais são os fatores que tornam um objeto pesado.

O que é Strain gauge:

O medidor de tensão é um transdutor ou sensor que mede a tensão (deformação) em um objeto. Isso foi inventado pelo engenheiro elétrico Edward E. Simmons e o engenheiro mecânico Arthur Claude Ruge.

Ilustração do Strain Gauge:

Sensor medidor de tensão

O Strain Gauge é flexível, é um padrão de folha metálica fina imprensado entre duas folhas de plástico finas e deve ser fixado em uma superfície usando cola adequada ou qualquer material adesivo.

Quando aplicamos peso ou força na superfície, ela se deforma e o extensômetro também. A deformação do medidor de tensão faz com que a resistência elétrica da folha metálica mude.

Agora, a mudança do medidor de tensão na resistência é diretamente proporcional ao peso ou força aplicada na superfície.

Na vida real, a mudança na resistência do medidor de tensão é muito insignificante de detectar. Para detectar pequenas mudanças na resistência, estamos utilizando a ponte de Wheatstone.

Vamos explorar o que a ponte de Wheatstone é em poucas palavras.

Compreendendo uma ponte de Wheatstone:

Uma ponte de pedra de trigo é um circuito que pode ser usado para determinar a resistência desconhecida. A ponte de Wheatstone foi idealizada por Samuel Hunter Christie, mais tarde a ponte de Wheatstone foi ampliada e disseminada por Sir Charles

Wheatstone.

Ilustração do circuito da ponte de Wheatstone:

Circuito da ponte de Wheatstone

Nossos modernos multímetros digitais podem ler o valor da resistência variando de mega ohms, quilo ohms e faixa de ohms.

Usando a ponte de pedra de trigo, podemos medir a resistência na faixa de mili ohm.

A ponte de pedra do trigo consiste em 4 resistores, dos quatro, 3 são resistências conhecidas e um é resistência desconhecida.

A diferença de potencial (tensão) é aplicada nos pontos “A” e “C” e dos pontos “B” e “D” um voltímetro é conectado.

Se todos os resistores forem iguais, nenhuma corrente fluirá nos pontos “B” e “D” e o voltímetro indicará zero. Isso é chamado de ponte equilibrada.

Se a resistência de um resistor for diferente de outros três resistores, haverá fluxo de tensão entre os pontos 'B' e 'D' e o voltímetro lerá algum valor proporcional à resistência desconhecida. Isso é chamado de ponte não balanceada.

Aqui, a resistência desconhecida é o medidor de tensão, quando a resistência é alterada, ela reflete no voltímetro.

Agora, convertemos uma deformação ou peso ou força em sinal de tensão. Essa tensão precisa ser amplificada para obter algumas leituras úteis, que serão enviadas a um microcontrolador para obter as leituras em gramas.

Agora vamos discutir como a temperatura afeta o desempenho do medidor de tensão.

Efeitos da temperatura no Strain Gauge:

O medidor de tensão é sensível à temperatura e pode atrapalhar as leituras reais de peso / força. Quando há alteração da temperatura ambiente a folha metálica é submetida à expansão do metal, o que afeta diretamente a resistência.

Podemos anular o efeito da temperatura usando a ponte de Wheatstone. Vamos ver como podemos compensar a temperatura usando a ponte Wheatstone.

Compensação de temperatura:

Podemos facilmente neutralizar o efeito da temperatura substituindo todos os resistores por extensômetro. Agora, toda a resistência do medidor de tensão será afetada pela temperatura igualmente e o ruído indesejado será anulado pelo caráter da ponte de Wheatstone.

O que é uma célula de carga?

Uma célula de carga é um perfil de alumínio com medidor de tensão conectado a 4 lados na configuração de ponte de Wheatstone.

Ilustração da célula de carga:

Carregar dispositivo celular

Este tipo de célula de carga é rígido e comumente usado em indústrias. Existem 4 montagens de parafuso, um lado é aparafusado a uma superfície estacionária e a outra extremidade é aparafusada a um suporte (por exemplo, cesta) para segurar o objeto a ser medido.

Tem peso máximo especificado na folha de dados ou no corpo, exceder a especificação pode danificar a célula de carga.

Uma célula de ponte completa consiste em 4 terminais, nomeadamente E +, E-, que são fios de excitação através dos quais a tensão de alimentação é aplicada. Os outros dois fios são S + e S-, que são fios de sinal, a partir dos quais a tensão é medida.

Agora, essas tensões estão na faixa de milivolts, não são fortes o suficiente para um microcontrolador ler e processar. Precisamos de amplificação e pequenas mudanças devem ser visíveis para o microcontrolador. Para fazer isso, há um módulo dedicado chamado amplificadores de célula de carga, vamos dar uma visão geral sobre isso.

Amplificador de célula de carga HX711:

Ilustração do módulo amplificador de célula de carga HX711:

Amplificador de célula de carga HX711

O amplificador de célula de carga é baseado no IC HX711, que é um conversor analógico para digital de 24 bits projetado especificamente para medidas de peso. Possui diferentes ganhos selecionáveis ​​32, 64 e 128 e opera em 2,6 a 5,5 V.
Esta placa de breakout ajuda a detectar pequenas variações na célula de carga. Este módulo requer a biblioteca HX711.h para operar com

Arduino ou qualquer outro microcontrolador.

A célula de carga será conectada ao módulo HX711 e o módulo será conectado ao Arduino. O circuito de medição de peso deve ser desenvolvido dessa maneira.

Em conclusão, agora você sabe o que é o medidor de tensão, o que é a ponte de Wheatstone, os efeitos da temperatura no medidor de tensão, a compensação de temperatura e o que é o amplificador de célula de carga.

Entendemos de forma abrangente a parte teórica do projeto de uma balança a partir da discussão acima, agora vamos ver como uma célula loas pode ser usada para fazer uma máquina de balança prática usando Arduino

Projetando uma Máquina de Balança Digital com Arduino

Nas discussões a seguir, aprenderemos como construir uma máquina de pesagem digital usando Arduino, que pode medir pesos de alguns gramas a 40 kg (dependendo das especificações de sua célula de carga) com precisão razoável. Estaremos aprendendo sobre a classificação de células de carga de grau de precisão, calibraremos o circuito proposto e finalizaremos a máquina de pesagem.

Nota: Este circuito pode não ser compatível com os padrões exigidos para implementação comercial.

As máquinas de pesagem são usadas em diferentes tipos de negócios e pesquisas que variam de miligramas a várias toneladas. A escala máxima da máquina de pesagem proposta depende da especificação de sua célula de carga. Existem faixas de 500 gramas, 1 Kg, 5 Kg, 10 Kg, 20 Kg e 40 Kg etc.

Existem diferentes graus de célula de carga, eles oferecem diferentes faixas de precisão e você deve escolher aquele adequado para o seu projeto.

Classificação da classe de precisão da célula de carga:

As diferentes classes de precisão são definidas para diferentes tipos de aplicativos. A classificação abaixo é da menor precisão à maior faixa de precisão.

As células de carga com menor precisão (mas razoavelmente precisas) são classificadas como D1, C1 e C2. Isso é o suficiente para este projeto. Essas células de carga são usadas para medir o peso de areia, cimento ou água.

As células de carga de grau C3 são usadas na garantia de qualidade, como verificação de peso de rolamentos de esferas, peças de construção de máquinas, etc.

C4, C5, C6 são os melhores em precisão da classe, esses graus de células de carga são usados ​​para medir em gramas a microgramas. Essas classes de grau são usadas em escalas de balcão de loja, monitoramento de produção em grande escala, embalagem de alimentos e uso em laboratório, etc.

Agora vamos mergulhar nos detalhes técnicos do projeto.

Diagrama de circuito:

Carregar a conexão da célula HX711 ao Arduino e carregar a célula.

Carregar a conexão da célula HX711 ao Arduino e carregar a célula.

O projeto consiste em Arduino, placa amplificadora de célula de carga e célula de carga HX711 e um computador. A saída pode ser monitorada no monitor Serial do Arduino IDE.

O cérebro do projeto é como sempre o arduino, você pode usar qualquer modelo de placa Arduino. O HX711 é um ADC de 24 bits, que pode encontrar flexão mínima devido ao peso na célula de carga. Ele pode operar de 2,7 V a 5 V. A alimentação é fornecida pela placa Arduino.

A célula de carga geralmente tem quatro fios, que é a saída do extensômetro configurado para ponte de Wheatstone.

O fio vermelho é E +, o fio preto é E-, o fio verde é A- e o fio branco é A +. Alguns módulos HX711 especificam o nome dos terminais da célula de carga e alguns módulos HX711 especificam as cores dos fios, tal modelo é ilustrado no diagrama de circuito.

O pino DATA do HX711 está conectado ao pino nº 3 do Arduino e o pino do relógio do HX711 está conectado ao pino nº 2 do Arduino.

Como montar a célula de carga:

como instalar uma célula de carga com Arduino

A célula de carga possui quatro orifícios para parafusos, dois em ambos os lados. Qualquer um dos lados deve estar estacionário para melhor precisão; pode ser amontoado em uma madeira com peso razoável.

Uma madeira fina ou placa fina pode ser usada para segurar o peso de medição conforme ilustrado acima.

Então, quando você coloca um peso, a célula de carga dobra o mesmo com o medidor de tensão e muda sua resistência, que é medida pelo módulo HX711 e alimentada para o Arduino.

Assim que a configuração do hardware for concluída, vamos fazer o upload do código e calibrar.

Calibrando o circuito:

Existem dois programas, um é o programa de calibração (encontrar o fator de calibração). Outro código é o programa de medição de peso, o fator de calibração encontrado no código do programa de calibração precisa ser inserido no programa de medição de peso.

O fator de calibração determina a precisão da medição do peso.

Baixe a biblioteca HX711 aqui: github.com/bogde/HX711

Código do programa de calibração:

//-------------------- --------------------//
#include
const int out = 3
const int clck = 2
HX711 scale(out, clck)
float CalibrationFactor = -96550
char var
void setup()
{
Serial.begin(9600)
Serial.println('------------- Weight Scale Calibration --------------')
Serial.println('Press Q,W,E,R or q,w,e,r to increase calibration factor by 10,100,1000,10000 respectively')
Serial.println('Press A,S,D,F or a,s,d,f to decrease calibration factor by 10,100,1000,10000 respectively')
Serial.println('Press 'T' or 't' for tare')
scale.set_scale()
scale.tare()
long zero_factor = scale.read_average()
Serial.print('Zero factor: ')
Serial.println(zero_factor)
}
void loop()
{
scale.set_scale(CalibrationFactor)
Serial.print('Reading: ')
Serial.print(scale.get_units(), 3)
Serial.println(' Kilogram')
Serial.print('Calibration Factor is: ')
Serial.println(CalibrationFactor)
Serial.println('--------------------------------------------')
if (Serial.available())
{
var = Serial.read()
if (var == 'q')
{
CalibrationFactor = CalibrationFactor + 10
}
else if (var == 'a')
{
CalibrationFactor = CalibrationFactor - 10
}
else if (var == 'w')
{
CalibrationFactor = CalibrationFactor + 100
}
else if (var == 's')
{
CalibrationFactor = CalibrationFactor - 100
}
else if (var == 'e')
{
CalibrationFactor = CalibrationFactor + 1000
}
else if (var == 'd')
{
CalibrationFactor = CalibrationFactor - 1000
}
else if (var == 'r')
{
CalibrationFactor = CalibrationFactor + 10000
}
else if (var == 'f')
{
CalibrationFactor = CalibrationFactor - 10000
}
else if (var == 'Q')
{
CalibrationFactor = CalibrationFactor + 10
}
else if (var == 'A')
{
CalibrationFactor = CalibrationFactor - 10
}
else if (var == 'W')
{
CalibrationFactor = CalibrationFactor + 100
}
else if (var == 'S')
{
CalibrationFactor = CalibrationFactor - 100
}
else if (var == 'E')
{
CalibrationFactor = CalibrationFactor + 1000
}
else if (var == 'D')
{
CalibrationFactor = CalibrationFactor - 1000
}
else if (var == 'R')
{
CalibrationFactor = CalibrationFactor + 10000
}
else if (var == 'F')
{
CalibrationFactor = CalibrationFactor - 10000
}
else if (var == 't')
{
scale.tare()
}
else if (var == 'T')
{
scale.tare()
}
}
}
//-------------------- --------------------//

Como calibrar:

  • Com a configuração do hardware concluída, carregue o código acima.
  • Remova a placa fina ou madeira que é usada para segurar o peso, incluindo os dois parafusos (o outro lado da célula de carga deve ser fixado a uma base)
  • Abra o monitor serial.
  • Coloque um peso conhecido na célula de carga diretamente, 100 gramas (digamos).
  • Aperte Q, W, E, R para aumentar o fator de calibração em 10,100,1000,10000 respectivamente.
  • Aperte A, S, D, F para diminuir o fator de calibração em 10,100,1000,10000, respectivamente.
  • Pressione “Enter” após cada incremento ou decremento do fator de calibração.
  • Aumente ou diminua o fator de calibração até que o peso correto do material de peso conhecido apareça.
  • A função de tara é definir a escala de peso para zero, isso é útil quando você deseja medir o peso da água (digamos) sem o peso da tigela. Coloque a tigela primeiro, pressione tara e despeje a água.
  • Observe o fator de calibração e anote-o depois que o peso conhecido aparecer.

Agora ele pode medir pesos desconhecidos.

Código do programa de medição de peso:

//---------------- ----------------//
#include
const int out = 3
const int clck = 2
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
void setup()
{
Serial.begin(9600)
Serial.println('Press 'T' or 't' to tare')
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
Serial.print('Weight: ')
Serial.print(scale.get_units(), 3)
Serial.println(' Kilogram')
if (Serial.available())
{
char var = Serial.read()
if (var == 't')
{
scale.tare()
}
if (var == 'T')
{
scale.tare()
}
}
}
//---------------- ----------------//

float CalibrationFactor = -12000

Substitua -12000 pelo fator de calibração que você encontrou. Pode ser um número negativo ou positivo.

Carregue o código acima com sua configuração de hardware completa e sua balança de peso está pronta.

Máquina de balança de peso usando display LCD

O artigo acima explicou um sistema de balança baseado em Arduino usando seu PC. Na seção seguinte, tentaremos construir uma versão prática da máquina de balança adicionando um display LCD de 16 x 2, para que não dependamos de um PC durante as medições pesos. Neste post são propostas duas versões, uma com LCD “I2C” 16 x 2 e outra sem display LCD “I2C” 16 x 2.

Aqui, duas opções são fornecidas para que os leitores possam escolher o design de acordo com sua conveniência. A principal diferença entre os dois são as conexões de fio com módulo adaptador I2C, apenas 4 fios (Vcc, GND, SCL e SDA) são necessários para o funcionamento do display LCD, enquanto sem o adaptador I2C você precisa de vários fios para conectar o Arduino ao display LCD.

No entanto, as duas funções são exatamente iguais, alguns preferem I2C em vez de um convencional e alguns preferem o contrário, então aqui estão os dois designs.

Vamos dar uma olhada no design convencional do LCD:

Diagrama de circuito:

arduino, display LCD 16 x 2 e potenciômetro de 10K para ajustar o contraste do display LCD

No esquema acima, temos o arduino, display LCD 16 x 2 e potenciômetro de 10K para ajustar o contraste do display LCD.

3,3 V podem ser alimentados do Arduino para o display LCD para iluminação de fundo. Um botão de pressão é fornecido para zerar a leitura do peso, esta função será explicada em detalhes no final.

Esta é apenas a conexão entre o LCD e o Arduino, a conexão entre a célula de carga e o amplificador da célula de carga para o Arduino é mostrada na seção anterior.

Código para máquina de pesagem de LCD:

// -------- Program developed by R.GIRISH -------//
#include
#include
const int rs = 10
const int en = 9
const int d4 = 8
const int d5 = 7
const int d6 = 6
const int d7 = 5
LiquidCrystal lcd(rs, en, d4, d5, d6, d7)
const int out = 3
const int clck = 2
const int Tare = 4
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
void setup()
{
lcd.begin(16, 2)
pinMode(Tare, INPUT)
digitalWrite(Tare, HIGH)
lcd.setCursor(0, 0)
lcd.print(' Weight Scale')
lcd.setCursor(0, 1)
lcd.print(' Machine')
delay(2000)
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Weight:')
lcd.print(scale.get_units(), 3)
lcd.print(' Kg')
delay(200)
if (digitalRead(Tare) == LOW)
{
scale.tare()
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Tare ......')
lcd.setCursor(0, 1)
lcd.print('Setting to 0 Kg.')
delay(1000)
}
}
// -------- Program developed by R.GIRISH -------//

Agora vamos ver como usar esta máquina de pesagem com display LCD baseado em adaptador I2C.

Diagrama de circuito Arduino e display LCD com adaptador I2C:

Arduino e display LCD com adaptador I2C

Aqui temos apenas um Arduino e uma tela LCD com adaptador I2C na parte traseira. Agora, as conexões de fios são simplificadas e diretas.

Ilustração do módulo I2C:

Módulo I2C

Este módulo pode ser soldado diretamente na parte traseira de um display LCD normal de 16 x 2 ou mesmo 20 x 4 e seguir o diagrama esquemático.

E, novamente, consulte a seção anterior para conexão de célula de carga, amplificador de célula de carga e Arduino.

Baixe a seguinte biblioteca para I2C:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

Código para circuito de escala de peso baseado em I2C:

// -------- Program developed by R.GIRISH -------//
#include
#include
#include
const int out = 3
const int clck = 2
const int Tare = 4
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
LiquidCrystal_I2C lcd(0x27, 16, 2)
void setup()
{
lcd.init()
lcd.backlight()
pinMode(Tare, INPUT)
digitalWrite(Tare, HIGH)
lcd.setCursor(0,0)
lcd.print(' Weight Scale')
lcd.setCursor(0,1)
lcd.print(' Machine')
delay(2000)
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Weight:')
lcd.print(scale.get_units(), 3)
lcd.print(' Kg')
delay(200)
if (digitalRead(Tare) == LOW)
{
scale.tare()
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Tare ......')
lcd.setCursor(0,1)
lcd.print('Setting to 0 Kg.')
delay(1000)
}
}
// -------- Program developed by R.GIRISH -------//

NOTA:

Você deve inserir o fator de calibração no código antes de enviar qualquer um dos códigos para o Arduino.

float CalibrationFactor = -12000

A obtenção do fator de calibração é explicada na seção anterior acima.

Função de tara:

A função de tara em uma balança é levar as leituras a zero. Por exemplo, se tivermos uma cesta na qual as mercadorias são carregadas, o peso líquido será o peso da cesta + o peso das mercadorias.

Se premirmos o botão de tara com cesto na célula de carga antes de carregar a mercadoria, o peso do cesto será desprezado e podemos medir o peso da mercadoria sozinhos.

Se você tiver alguma dúvida sobre este circuito de máquina de balança de pesagem de LCD prático baseado em Arduino, expresse na seção de comentários que você pode obter uma resposta rápida.




Anterior: Circuito contator de estado sólido para bombas motorizadas Próximo: Como fazer transformadores redutores