Célula de Carga 50 Kg com Amplificador HX711

Célula de Carga é um sensor ativo que é alimentado com um sinal de excitação externo onde se é medida a variação da tensão de saída. Esse sensor de peso é baseado em Strain Gauge onde a mudança na resistência elétrica do sensor é proporcional a uma determinada pressão ou força aplicada.
Como a variação de tensão é muito baixa, é necessário um Amplificador de Sinais e que neste caso recomenda-se um Conversor Amplificador HX711.

Especificações Célula de carga 50 Kg:

    • Material de Fabricado: liga de alumínio
    • Capacidade de peso de cada célula: até 50kg
    • Potência nominal: 1,0 ± 0,1 mV / V
    • Não-linearidade: 0,08% FSHisterese: 0,1% FS
    • Repetibilidade: 0,05% FS
    • Deformação (5min): 0.05% FS
    • Temperatura sobre o produto: 0,02% FS / °C
    • Temperatura sobre Zero: 0,02% FS / °C
    • Equilíbrio Zero: ± 0,1000 mV / V
    • Impedância de entrada: 1000 ± 20%
    • Impedância de saída: 1000 ± 10%
    • Resistência de isolamento: 2000 Mohms
    • Seguro de Sobrecarga: 120% FS
    • Final de Sobrecarga: 150% FS
    • Temperatura: -20 ~ 65 °C
    • Tensão de Excitação: 5VDC;
    • Tensão máxima de trabalho: 8VCC
    • Nível de proteção: IP65
    • Modo de conexão dos fios: Vermelho: entrada (+), Branco: saída (-), Preto: entrada (-)
    • Dimensões (CxLxA): 34x34x8,7mm
    • Peso: 20g

Especificações HX711:

    • Tensão de funcionamento: 5V DC
    • Corrente de funcionamento: <10 mA
    • Diferencial de tensão de entrada: ± 40mV (tensão de entrada diferencial em larga escala é ± 40mV)
    • Precisão dos dados: 24 bits
    • Freqüência de atualização: 80 Hz
    • Dimensões: 24x15x2,7mm
    • Peso: 1,1g

Aplicação simples de Célula de carga

Neste exemplo será mostrado o funcionamento do dispositivo, lembrando que a precisão das leituras dependerá muito do nivelamento da plataforma de teste construída com as células de carga.

Primeiramente, devemos fazer a junção das Células de Carga no Módulo HX711 e em seguida conectar ao Arduino.

Quatro Células

ESQUEMA CÉLULA DE CARGA 50 KG 4 Células

Duas Células

 

 

Feito isso, podemos seguir agora para a calibração.

Calibração

Primeiramente, devemos incluir a biblioteca HX711.h  para em seguida carregar o código no Arduino.

#include "HX711.h"
#define DOUT  2
#define CLK   3
HX711 peso;                // instancia Balança HX711
float calibration_factor = 34730;     // fator de calibração para teste inicial
void setup()
{
  Serial.begin(9600);
  peso.begin(DOUT, CLK);      // inicializa a balança
  Serial.println();
  Serial.println("Calibracao da Balança");
  peso.set_scale();                                // configura a escala da Balança
  zerapeso ();                                    // zera a Balança
}
void zerapeso ()
{
  Serial.println();
  peso.tare();                                                 // zera a Balança
  Serial.println("Zerando a Balança ");
}
void loop()
{
  peso.set_scale(calibration_factor);            // ajusta fator de calibração
  Serial.print("Peso: ");                       // imprime no monitor serial
  Serial.print(peso.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) ;
  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') zerapeso ();          // t = zera a Balança
  }
}

Feito isso siga o procedimento:

    • Após a balança for zerada pelo programa, coloque um peso conhecido sobre a célula de carga.
    • Digite no Monitor Serial a, s, d, f para aumentar o Fator de Calibração por 10,100,1000,10000 ou Digite z, x, c, v para diminuir o Fator de Calibração por 10,100,1000,10000, respectivamente até obter o fator de calibração correspondente ao peso conhecido.

Foi utilizado um peso teste de calibração com um valor conhecido de aproximadamente 2,3Kg.

Acrescentando agora um peso no valor de 5Kg, podemos observar, dentro do esperado, a seguinte variação:

Então, para verificar se o fator de calibração corresponde realmente ao valor correto, vamos inserir esse valor obtido no código exemplo da própria biblioteca HX711.h (HX711_full_example) e observar os valores com os mesmos pesos:

#include "HX711.h"

// HX711 circuit wiring
# define LOADCELL_DOUT_PIN   2
# define LOADCELL_SCK_PIN    3

HX711 scale;

void setup() {
  Serial.begin(38400);
  Serial.println("HX711 Demo");

  Serial.println("Initializing the scale");

  // Initialize library with data output pin, clock input pin and gain factor.
  // Channel selection is made by passing the appropriate gain:
  // - With a gain factor of 64 or 128, channel A is selected
  // - With a gain factor of 32, channel B is selected
  // By omitting the gain factor parameter, the library
  // default "128" (Channel A) is used here.
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);

  Serial.println("Before setting up the scale:");
  Serial.print("read: \t\t");
  Serial.println(scale.read());			// print a raw reading from the ADC

  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));  	// print the average of 20 readings from the ADC

  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));		// print the average of 5 readings from the ADC minus the tare weight (not set yet)

  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);	// print the average of 5 readings from the ADC minus tare weight (not set) divided
  // by the SCALE parameter (not set yet)

  //scale.set_scale(2280.f);                      // this value is obtained by calibrating the scale with known weights; see the README for details
  scale.set_scale(20350.f);                      // this value is obtained by calibrating the scale with known weights; see the README for details
  scale.tare();				        // reset the scale to 0

  Serial.println("After setting up the scale:");

  Serial.print("read: \t\t");
  Serial.println(scale.read());                 // print a raw reading from the ADC

  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));       // print the average of 20 readings from the ADC

  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));		// print the average of 5 readings from the ADC minus the tare weight, set with tare()

  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);        // print the average of 5 readings from the ADC minus tare weight, divided
  // by the SCALE parameter set with set_scale

  Serial.println("Readings:");
}

void loop() {
  Serial.print("one reading:\t");
  Serial.print(scale.get_units(), 1);
  Serial.print("\t| average:\t");
  Serial.println(scale.get_units(10), 1);

  scale.power_down();			        // put the ADC in sleep mode
  delay(5000);
  scale.power_up();
}

 

Então, carregando o código, abrindo o Monitor Serial e fazendo o teste com os mesmos pesos, podemos observar os valores bem próximos obtidos na calibração.

Lembrando-se que a variação de alguns gramas é devido às células de carga não estarem perfeitamente niveladas à superfície de contato utilizada nesse experimento. As células de carga foram coladas em uma prancha de madeira e colocada sobre um piso que não era perfeitamente nivelado e com isso a pressão sobre as células não foi igualmente distribuída, porém o teste foi suficientemente satisfatório para o estudo do funcionamento das células de carga.

Onde comprar?

#VLADCONTROL SHOP