Este projeto visa projetar uma balança digital de peso que mede o peso de até 10 kg. Usamos uma célula de carga de 10kg, um módulo que amplifica a saída da célula de carga e um Arduino. A escala é projetada com precisão de + 0,01 kg e os switches são usados ​​para calibrar a balança digital de peso. Neste artigo, todos esses aspectos são brevemente explicados com o design e a programação. Este projeto nos torna capazes de aprender o mecanismo da escala de peso digital e como projetar um instrumento, mantendo as complexidades relacionadas em mente.

Ola, se tiver algum erro de tradução (AUTO), falta de link para download etc...
Veja na FONTE até ser revisado o post. -status ( revisado 30% 21/02/2019)-
 Mas se gostou compartilhe!!! Artigo do AUTOR FONTE é de 

Introdução à Escala de Peso Digital

Um instrumento é um dispositivo que é usado para fazer medições da quantidade física (distância, pressão, tensão, corrente, etc.). OU Também podemos dizer que um instrumento é um dispositivo que converte uma forma de parâmetro que não pode ser medida para outra forma que possa ser medida facilmente. Como todos os instrumentos elétricos convertem o sinal de entrada em sinal elétrico. Por exemplo: Um termômetro elétrico converte a temperatura em voltagem que é calibrada para fornecer leituras exatas. A parte mais importante do instrumento é a detecção da parte que detecta o sinal de entrada e fornece as tensões apropriadas de acordo. O instrumento que vamos discutir neste relatório é uma célula com 10kg de peso.

Os componentes necessários para fazer uma balança digital são:

  1. Célula de carga (10kg)
  2. Módulo HX711
  3. Arduino UNO
  4. LCD (16×2)
  5. Comuta
  6. Conectando Fios
  7. Resistores
  8. Placa Varrow
  9. Bateria e Regulador (5V)
  10. Base de madeira
  11. Parafusos, Porcas e Parafusos
  12. Folha acrílica (para o corpo)
  13. Solda

Detalhes dos principais componentes da escala de peso digital:

Agora vamos dar uma breve explicação dos principais componentes em fazer escala de peso abaixo:

  • Célula de Carga:

Uma célula de carga é um transdutor que é usado para criar um sinal elétrico cuja magnitude é diretamente proporcional à força. A célula de carga que usaremos neste projeto é uma célula de carga do tipo strain gauge de 10 kg que é mostrada abaixo.

Célula de Carga
engineerexperiences

Células de carga de strain strain são as mais comuns na indústria. Estas células de carga são particularmente rígidas, têm valores de ressonância muito bons e tendem a ter vida longa. As células de carga de strain string trabalham com base no princípio de que o strain gauge (um resistor planar) se deforma quando o material das células de carga se deforma apropriadamente. A deformação do strain gauge altera sua resistência elétrica, por uma quantidade proporcional à deformação. A mudança na resistência do strain gauge fornece uma mudança de valor elétrico que é calibrada para a carga colocada na célula de carga. Uma célula de carga geralmente consiste em quatro medidores de tensão em uma configuração de ponte de Wheatstone, mostrada abaixo:

Configuração da ponte de Wheatstone (base da célula de carga)

Os quatro fios que saem da ponte de Wheatstone na célula de carga são geralmente:

  • Excitação + (E +) ou VCC é vermelho
  • Excitação- (E-) ou terra é preto
  • Saída + (O +) é branco
  • Saída (O-) é verde ou azul

A tensão máxima de excitação aplicada à célula de carga é de 15V e o sinal de saída é em milivolts, então um amplificador ou módulo amplificador é necessário para ler as leituras. Ao usar a célula de carga, a montagem será mostrada abaixo:

Montagem da célula de carga para uso na balança digital de peso
Montagem da célula de carga para uso na balança digital de peso
  • Módulo HX711:

Como a célula de carga fornecerá a saída em micro volts e o Arduino não é capaz de ler esses valores, é necessária uma amplificação. A melhor solução é usar o amplificador HX711, que é um amplificador analógico para digital de 24 bits e fornece a melhor saída de uma célula de carga. O amplificador HX711 consiste de 10 pinos cuja imagem é mostrada abaixo:

Módulo HX711
Módulo HX711

Os pinos de Excitação fornecem entrada para a ponte de Wheatstone e existem dois canais neste módulo, o Canal A e o Canal B. O Canal A fornece o ganho de 128, enquanto o Canal B fornece o ganho de 32. Para excitar o módulo, aplicaremos 3- 5V a VCC pin do módulo. Os pinos de pinos DT (Serial Data Output) e SCK (Serial Clock) são os pinos de saída do módulo que fornecem valores na forma de 0s e 1s. O trabalho desses pinos precisa entender completamente o design da lógica digital, por isso não vamos discuti-lo aqui.

Arduino

Ele é programado através de seu próprio software, ou seja, ARDUINO IDE quando conectado ao PC por um cabo de dados. A maioria dos módulos que estão disponíveis nas lojas eletrônicas são fabricados de tal maneira que eles podem ser usados ​​facilmente com o Arduino. A célula de carga HX711 pode ser usada com o Arduino e programada facilmente, mas primeiro devemos adicionar a biblioteca do HX711 ao software Arduino.

Cálculo do fator de calibração da célula de carga:

Para usar qualquer instrumento de medição, precisamos calibrá-lo para leituras exatas. Tal como no nosso projeto de 10kg de peso, já que estamos utilizando uma célula de carga de 10kg e módulo HX711 com Arduino e quando observamos as leituras do HX711 serialmente no PC então essas leituras não dão nenhum sentido que indique a necessidade de calibração . Quando o fator de calibração é conhecido, é fácil para o Arduino fornecer as leituras exatas do peso colocado na escala de peso. O valor do fator de calibração é colocado dentro dos colchetes da função interna set_scale () dentro da biblioteca do HX711 para completar a calibração. As conexões dos componentes para o fator de calibração são mostradas abaixo:

Como calibrar sua balança digital com o Arduino?

  1. Chame set_scale () sem parâmetro.
  2. Chame tara () sem parâmetro.
  3. Coloque um peso conhecido na balança e chame get_units (10).
  4. Divida o resultado no passo 3 para o seu peso conhecido. Você deve obter o parâmetro que precisa passar para set_scale.
  5. Ajuste o parâmetro no passo 4 até obter uma leitura precisa.

Depois de conectar os componentes de acordo com a figura acima, vamos programar o Arduino UNO pelo programa abaixo que está de acordo com as 5 instruções acima:

#include "HX711.h" 
#define DOUT  3
#define CLK  2
HX711 scale(DOUT, CLK);
void setup()
{
   Serial.begin(9600);
   scale.set_scale();
   scale.tare();
}
void loop()
{
  Serial.println(scale.get_units());
}

Para completar a tarefa do fator de calibração, colocamos uma massa conhecida de 0,8 kg (800 gramas) na célula de carga. Depois de colocar o peso conhecido, a saída serial mudou, conforme mostrado abaixo:

Tomando a média dessas leituras, calculamos -163102 como o valor bruto para 0,8 kg de peso. Agora, para calcular o fator de calibração, dividiremos esse valor bruto pelo peso conhecido nas unidades para as quais estamos projetando nossa escala de peso. Portanto, o cálculo de -163102 / 0,8 dará a -203878 como nosso fator de calibração. Este fator de calibração fornecerá leituras próximas a 0,8 kg quando colocado na célula de carga, mas não com exatidão de 0,8 kg. Para encontrar o fator de calibração exato, faremos um programa que nos permitirá aumentar ou diminuir o fator de calibração e, ao mesmo tempo, observar o efeito da mudança do fator de calibração nas leituras de peso.

Projetando a Escala de Peso com Arduino:

A maioria dos instrumentos de medição contém interruptores em seus corpos que são para finalidades diferentes. Se olharmos para as balanças de peso digitais usadas na General Store, elas têm alguns botões e chaves numéricas. Para tornar nossa balança de peso mais simples, usaremos apenas botões e chaves ON / OFF. Então, decidimos que um interruptor LIGADO / DESLIGADO alimentará a balança de peso, um interruptor (CAL) será usado quando o usuário quiser calibrar a balança de peso. Um comutador (x100) será usado quando o usuário quiser aumentar ou diminuir o fator de calibração por múltiplos de 100, mas, por padrão, a escala de peso aumenta ou diminui o fator de calibração por múltiplos de 10.

Dois botões são usados; O botão INC é usado para aumentar o fator de calibração enquanto DEC é usado para diminuir o fator de calibração por múltiplos de 10 ou 100, conforme necessário. O diagrama de circuito completo da escala de peso é mostrado abaixo:

Diagrama de Circuito Completo da Escala de Peso Digital

Código:

Você pode fazer o download do esboço básico e código de trabalho (para fins de aprendizado) da escala de peso digital baseada em arduino no documento anexado. Você pode estender esse código de acordo com sua própria conveniência.

Baixe aqui

#include "HX711.h"  
#include 
LiquidCrystal lcd(12, 11, 10, 9, 8, 7);
#define DOUT  3
#define CLK  2
float weight=0;
const int cal=6;
const int up=5;
const int down=4;
const int x100=1;
int readingup,readingdown,readingcal,readingx100,cf=0,a[2]={100,1000},i=0;
float calibration_factor =-204100; //this value is calculated according to instructions in report
HX711 scale(DOUT, CLK); //using the Hx711 in 128 gain mode by default
void setup() 
{
  lcd.begin(16,2);
  pinMode(cal,INPUT);
  pinMode(up,INPUT);
  pinMode(down,INPUT);
  pinMode(x100,INPUT);
  scale.set_scale(); // initially calibrating the scale with zero value
  scale.tare(); //resets the scale to 0
  long zero_factor = scale.read_average(10); //stores the average of 10 readings from the ADC when there is no weight on pan
}
void loop() 
{
  readingcal=digitalRead(cal);
  if(readingcal==HIGH) //this section gets activated when CAL button is ON for calibration
  {
    if(cf==0)//in this section we will give some instructions for calibration once
    {
      lcd.clear();
      lcd.setCursor(2,0);
      lcd.print("Calibration   ");
      lcd.setCursor(4,1);
      lcd.print("Starts!        ");
      delay(3000);
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Place 1kg weight");
      lcd.setCursor(0,1);
      lcd.print("or known weight.");
      delay(4000);
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Press '+' when  ");
      lcd.setCursor(0,1);
      lcd.print("weight is small.");
      delay(2500);
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Press '-' when  ");
      lcd.setCursor(0,1);
      lcd.print("weight is big.  ");
      delay(2500);
      cf=1; // this variable helps us to read the instructions once and for the rest of time calibration() function is called 
    }
    calibration();
  }
  else //otherwise to measure the weights
  {
    display2();
    cf=0; //this variable helps us to read the instructions ONCE when the CAL button is switched ON
  }
}
void calibration()  //this is the general function of Calibration
{
  readingup=digitalRead(up); //reads the logic at pin 5 to increase the calibration factor
  readingdown=digitalRead(down); //reads the logic at pin 4 to decrease the calibration factor
  readingx100=digitalRead(x100); //reads the logic at pin 1 to inc/dec the calibration factor by 100 times
  if(readingx100==HIGH)
  {
    i=1; //i is the index of array used at top that contains only two values 10 and 100,
    //it provides the factor by which we are inc/dec the calibration factor
  }
  else {i=0;} //if x100 is off then by default we increase or decrease the calibration factor by 10 times
     if(readingup==HIGH)
  {
    calibration_factor+=a[i];//increasing the calibration factor by 10/100 times
    delay(80);
  }
  if(readingdown==HIGH)
  {
    calibration_factor-=a[i];//decreasing the calibration factor by 10/100 times
    delay(80);
  }
  display1();//as we used two different displays for two modes. NOrmal mode and Calibration mode.. 
  //this is for calibration mode
}
void display1()//calibration mode display
{
  scale.set_scale(calibration_factor); //the value in calibration factor is obtained by calibration it with known weights
  weight=scale.get_units(); //stores the average of weight readings from the ADC according to the calibration factor
  if(weight<0)
  {weight=0;}
  lcd.setCursor(0,0);
  lcd.print("Weight: ");
  lcd.setCursor(8,0);
  lcd.print(weight,4); //displays the weight in 4 decimal places only for calibration
  lcd.setCursor(14,0);
  lcd.print("kg");
  lcd.setCursor(0,1);
  lcd.print("Value: "); //display the calibration factor so that it is easy to inc/dec it and reading it at the same time
  lcd.setCursor(7,1);
  lcd.print(calibration_factor);
}
void display2()//display of normal mode
{
  scale.set_scale(calibration_factor);
  weight=scale.get_units(); 
  if(weight<0)
  {weight=0;}//if the weight is negative then show it zero
  lcd.setCursor(0,0);
  lcd.print("**Weight Scale:*");
  lcd.setCursor(0,1);
  lcd.print("Weight: ");
  lcd.setCursor(8,1);
  lcd.print(weight,2);//displaying the weight in two decimal places. As 0.01 accuracy is required
  lcd.setCursor(12,1);
  lcd.print("kg  ");
}

Para mais  artigos  e  projetos,  fique ligado conosco.
Em caso de consulta e dúvida, comente abaixo ou  entre em contato. 
Partilhe a sua experiência com o mundo com engineerexperiences.com ?

Veja mais


Ola, se tiver algum erro de tradução (AUTO), falta de link para download etc... Veja na FONTE até ser revisado o post. -status ( revisado 30% 21/02/2019)- Mas se gostou compartilhe!!!

Artigo do AUTOR FONTE é de


FONTE
Autor JOVENS ENGENHEIROS

DEIXE UMA RESPOSTA

Por favor digite seu comentário!
Por favor, digite seu nome aqui

dezessete + 20 =