Balança com celula de carga, HX711 e uma MCU

Balança

Célula de carga

Existem diversos tipos de célula de carga, dentre as quais, esta que estou utilizando, bastante comum e com capacidade de carga de até 50Kg. Mas se precisar de mais carga, basta combinar mais células. Igualmente em uma balança de açougue ou supermercado, a carga deve ser colocada no centro da balança para distribuição correta do peso (por favor, não vamos entrar no assunto ‘peso’ e ‘massa’, então não façam comentários desse tipo para não pirar os não-nerds). Se você estiver utilizando 4 células combinadas, não haverá problemas na distribuição do peso, mas essas células interligadas distribuem o sinal de saída entre si. Desse modo, é mais segura a medição.

Apesar de seu formato esquisito, é bastante simples; ele sente a carga em seu núcleo ao centro, onde ele possui uma meia-ponte resistiva de boa qualidade e precisão. Ao exercer força sobre o sensor, uma tensão é gerada em sua saída e essa variação de tensão será proporcional ao peso, que deverá ser aferido.

Deve-se tomar cuidado com ruídos, que podem interferir na medição. Acredite, esses sensores são utilizados em balanças comerciais, se você tiver algum problema, certamente não será relacionado a estas células, por isso é bom precaver. Outra coisa que pode ser feita é a amplificação do sinal para facilitar a medição em uma MCU. Nesse ponto, você já deve ter percebido que a leitura da célula de carga é analógica.

A leitura analógica do Arduino é de 10 bits, de modo que você poderá dividir a precisão de carga por apenas 1024 valores (0 à 1023). Em 1Kg isso é bastante, mas em 50Kg a precisão cai e essa curva deverá ser considerada.  Outra opção é um MSP432 e daí por diante. Mas eu não faço essa conexão direta com a MCU, e você poderá ver mais adiante o modo de operação correto.

Falando sério, muito sério, eu prefiro utilizar  um ESP8266,  não só pela resolução, mas não se vê projetos com ESP8266 utilizando a porta analógica e tem algo muito importante a considerar; essa porta pode receber uma tensão máxima de 1V; porém o ESP8266 tem apenas 1 porta analógica e não poderemos fazer esse projeto com ela, exceto utilizando-se de um conversor AD.

Ponte resistiva

Uma ponte resistiva é uma maneira de medir uma resistência desconhecida; um método utilizado em medição de peso. Uma resistência equilibrada é quando a corrente medida é igual a zero. E bla,bla,bla teoria. O caso é que precisamos de simetria aqui, porque uma célula de carga faz meia ponte e para fazermos como na imagem de ponte resistiva, precisamos de duas células de carga e assim formamos uma ponte completa.

A célula de carga utilizada aqui é das mais baratas, contendo apenas 3 fios e para formar a ponte completa estou utilizando duas células.

Tive que fazer o desenho porque não ficou claro pra mim o funcionamento da célula e o wiring apenas olhando os esquemáticos. A consideração final para mim foi a seguinte:

  • Três fios, sendo Branco, Vermelho e Preto.
  • Para formar a ponte, interligo as respectivas bordas; branco com branco, preto com preto.
  • Os vermelhos vão ao A+ e A- do HX711.
  • Não importa isso, mas no meu caso coloquei os brancos em VCC e os pretos em GND.
  • Pode-se trabalhar de 2.6V à 5.5V com o HX711, portanto não há necessidade de preocupação com o nível logico.

Não considere os resistores, apenas fiz o desenho para figurar o wiring das células.

ponte resistiva - célula de carga de 3 fios
ponte resistiva – célula de carga de 3 fios

Amplificador de sinal HX711

E como falado, para que você consiga tirar um sinal de qualidade, a utilização do amplificador de sinal HX711 é fundamental  e faremos leituras utilizando-o.

A precisão desse amplificador de sinal pode variar em até 5% conforme condições de ambiente, principalmente afetado por temperatura. Dependendo do quão preciso a balança deva ser, será necessário aferir diversas cargas para verificar se há curva ou se a medição recebe uma variação constante.

Esse dispositivo pode ser alimentado de 2.7V à 5V, sendo ideal para utilização com qualquer MCU conhecida, sem precisar se preocupar com controle do nível lógico utilizando divisor de tensão, LLC, buffer não-inversor

Se quiser dar uma olhada no datasheet, você encontrará ao final 2 exemplos de drivers, um em assembly e um em C:

https://cdn.sparkfun.com/datasheets/Sensors/ForceFlex/hx711_english.pdf

Adquira os componentes

E para o projeto você precisará de:

Todos esses (e outros mais) você pode adquirir com a Fulltronic Componentes Eletrônicos, que anuncio com muito orgulho como um parceiro do site e proporcionará a vocês diversos outros artigos com brinquedos mais atípicos!

Biblioteca

Essa é uma das coisas que o Arduino proporciona de bom; uma comunidade inteira desenvolvendo código para agilizar tarefas. O lado negativo é que você deixará de por a mão em baixo nível, mas claro que eu não vou reinventar a roda aqui, e você tem duas possibilidades para obter a sua biblioteca.  Baixe-a clonando ese git:

git clone https://github.com/bogde/HX711.git

Ainda pela IDE do Arduino, você pode ir no Library Manager e digitar ‘HX711’ na caixa de busca. Esse tutorial estou fazendo com a biblioteca clonada do github. Apesar de gostar e preferir escrever meu próprio código, como tenho uma série de posts a correr, priorizei o funcionamento e o exclarecimento do wiring utilizando a biblioteca indicada com o seguinte código (do próprio exemplo, sem mexer em uma linha sequer):

#include "HX711.h"

// HX711.DOUT   - pin #A1
// HX711.PD_SCK - pin #A0

HX711 scale(A1, A0);        // parameter "gain" is ommited; the default value 128 is used by the library

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

  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.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();
}

Isso simplifica ao máximo o start do projeto.

Os fios vermelhos podem ser colocados em qualquer ordem, como citado mais acima, desde que um vá em A+ e o outro em A- para funcionar como nesse tutorial.

O Wiring é muito simples entre o Arduino e a célula de carga:

  • VCC em 5V do Arduino
  • GND no ground do Arduino
  • SCK en A0 do Arduino
  • DT ao A1 do Arduino

Os fios brancos estão conectados entre si, assim como os pretos, porém nenhum destes pares está conectado a GND ou VCC. Ao pressionar a célula com o dedo, a variação pode ser vista perfeitamente:

ponte resistiva - leitura

Siga-nos no Do bit Ao Byte no Facebook.

Prefere twitter? @DobitAoByte.

Inscreva-se no nosso canal Do bit Ao Byte Brasil no YouTube.

Nossos grupos:

Arduino BR – https://www.facebook.com/groups/microcontroladorarduinobr/
Raspberry Pi BR – https://www.facebook.com/groups/raspberrybr/
Orange Pi BR – https://www.facebook.com/groups/OrangePiBR/
Odroid BR – https://www.facebook.com/groups/odroidBR/
Sistemas Embarcados BR – https://www.facebook.com/groups/SistemasEmbarcadosBR/
MIPS BR – https://www.facebook.com/groups/MIPSBR/
Do Bit ao Byte – https://www.facebook.com/groups/dobitaobyte/

Próximo post a caminho!

 

Deixe uma resposta