Objetivo

     Existem diversos tutoriais de balança de medição com o uso de duas ou quatro células de carga, a proposta dessa postagem é mostrar que é possível fazer uma balança com o uso de apenas uma célula de carga, não abrindo mão da demonstração da ligação para mais de uma célula, será ensinado:

O que é HX711

Ligação em ponte de Wheatstone

Como fazer a ligação de uma célula de carga

Como fazer a ligação de duas células de carga

Como fazer a ligação de quatro células de carga

Como baixar as bibliotecas necessárias

Montagem da balança

Como calibrar a balança

Projeto de medição de peso com os valores em todos os planetas do Sistema Solar, com esquemático e programação

       Apesar de simples, a proposta de projeto é Importante para aprendermos a utilizar o peso para outras funções, como: realização de uma operação de soma, multiplicação, subtração e divisão.


Introdução

      Dentre os componentes de uma balança, o principal é a célula de carga, também conhecida como strain gage ou load cell, a mesma é um transdutor responsável por variar a resistência de forma proporcional à deformação gerada pelo peso imposto sobre ela. A célula trabalha de acordo com a deformação elástica do material, caso essa seja ultrapassada, a célula deve ser recalibrada ou substituída caso se note que o peso não está sofrendo alterações mesmo com a retirada do objeto medido, sendo um forte indício de deformação permanente causada pela extrapolação.  Normalmente as células são feitas de algum metal como alumínio ou aço inox com fios extensômetros de resistência que devem ser interligados em Ponte de Wheatstone, como demonstrado mais adiante.

célula de carga

            Para o exemplo trabalhado aqui, será utilizada uma Célula de 50Kg, ou seja, seu limite de peso é 50Kg, mas caso seja necessário aumentar esse limite, mais células podem ser utilizadas na balança, o peso total será a soma delas, dessa forma:

tabela de células

 

            Para trabalhar com a Célula de Carga é necessário um conversor A/D (Analógico/Digital) amplificador, sendo normalmente utilizado o HX711

 

Lista de Materiais

 

            Para realizar a atividade proposta nesse tutorial, tenha em mãos os componentes abaixo:

01- Protoboard

01- Módulo Conversor Célula de Carga – HX711

01- Célula de Carga (sendo possível fazer com 1, 2 ou 4, conforme seu projeto)

02- Trimpots linear horizontal- 2kΩ

01- Placa Arduino Uno R3 + Cabo USB

Kit de jumpers Macho- Macho

 

            Caso queira realizar o exemplo das medições com o LCD, você também precisará de:

 

01- Módulo Serial I2C para Display LCD

01- Display LCD 16x2

Kit de jumpers Macho- Fêmea

 

            Você pode adquiri-los clicando em cada componente ou acessando o nosso site: 
           https://www.curtocircuito.com.br/

HX711

 

           O HX711 é um módulo amplificador operacional de 24 bits que será utilizado para converter o sinal analógico em digital, além de amplificar a saída para que seja reconhecida pelo Arduino. Ele foi criado com a intenção de atuar com sensores de peso ligados em ponte, sendo que o multiplexador (MUX) interno seleciona a entrada diferencial (A+ e A-) ou (B+ e B-) para o amplificador de ganho. Para os interessados em conhecer um pouco mais do HX711, é apresentado o componente e o seu circuito interno abaixo:

 

            Lembrando que E+ e E- correspondem ao VCC e ao GND, nessa ordem.


hx711


hx711 datasheet

 

Ligação em Ponte de Wheatstone

 

            Como mencionado na Introdução, para ligar células de carga é necessário realizar a Ponte de Wheatstone entre elas ou entre célula e componentes resistivos (para o caso de apenas uma unidade). A ponte de Wheatstone é uma rede de quatro pernas resistivas interligadas, formando dois divisores de tensão em paralelo, da seguinte forma:

 

ponte de wheatstone

            R1 e R2 em composição formam o primeiro divisor de tensão, R3 e R4 formam o segundo, a saída (Vout) é medida entre os nós C e D. Caso ocorra uma mudança de tensão, nesse caso gerada pelo peso, a resistência dos elementos da ponte é alterada. O número de pernas resistivas do componente utilizado vai definir a configuração da ponte.


Tabela resistência célula de carga

            Agora iremos ver os esquemas de ligação das células, atente-se aos nomes dos pinos, e não a posição, pois a probabilidade de erro é menor, em razão disso eu colocarei tabelas para que seja mais fácil acompanhar.

 


Para uma Célula de Carga

 

            Com o uso de uma Célula de Carga, teremos a configuração de Meia Ponte, pois na Célula existem duas pernas resistivas, que correspondem ao fio branco e ao fio preto, o fio vermelho será o nosso Vout. Para transformar esse circuito Meia Ponte em uma Ponte de Wheatstone completa, devemos inserir dois trimpots de 2KΩ ajustados para 1KΩ do pino da ponta ao pino do meio, esses dois trimpots vão simular as duas pernas resistivas que necessitamos para formar a ponte. A escolha do trimpot e da resistência ajustada se deve ao fato de: Se medirmos do fio preto ou branco da célula, ao fio vermelho, temos 1KΩ, e se medirmos do preto ao branco, temos 2KΩ.

            No modelo Ponte de Wheatstone, a ligação ficará assim:


ponte de wheatstone para uma célula

            Para a montagem com uma única célula, siga o esquemático abaixo:

Ligação de 1 célula

            Tabela com ligações do circuito acima
Tabela de ligação de uma célula
in= input (entrada)   out= output (saída)


Protótipo com uma célula de carga

 

 

Para duas Células de Carga

 

            No caso das duas Células, teremos uma Ponte Completa, dois fios na cor branca, dois na cor preta, e dois Vout (vermelho), então não será necessário o uso de outros componentes resistivos para completar a ponte.

            A ponte de Wheatstone para duas células ficará assim:

ponte de wheatstone para duas células

 

            Para a montagem do circuito com duas células, siga o esquemático abaixo:

Ligação de 2 células

            Tabela com esquema de ligações do circuito acima:

Tabela de ligação de duas célulasin= input (entrada)   out= output (saída)

Protótipo com 2 células de carga


Para quatro Células de Carga

 

            Para o uso de quatro células, em configuração de Ponte Completa, a ligação em Wheatstone é a seguinte:

ponte de wheatstone para quatro células

 

 

            Para montagem física, siga o esquemático:

 

ligação quatro células de carga

           Tabela com esquema de ligações:

Tabela de ligação de quatro célulasin= input (entrada)   out= output (saída)

Protótipo com quatro células de carga

Bibliotecas no Arduino

 

            Tendo em vista o objetivo de utilizar as Células de Carga em conjunto com o amplificador HX711, deve-se baixar a biblioteca do componente para a IDE do Arduino. Vale observar que se você já tiver a biblioteca HX711.h na IDE, você pode pular essa etapa, caso não tenha, acesse o link abaixo:

https://github.com/bogde/HX711

 

                Já no site, clique em Clone or download e em seguida em Download ZIP

 

biblioteca HX711_parte1

            Feito o download do arquivo em ZIP, entre na sua IDE do Arduino e realize o seguinte procedimento para inclusão de biblioteca:

 

                    Sketch> Incluir Biblioteca> Adicionar Bliblioteca .ZIP


Inclusão da biblioteca HX711_3

            Depois disso sua biblioteca já estará disponível para uso.

            Montagem do Protótipo da Balança

           As células de carga têm seu funcionamento baseado na deformação, como mencionado na Introdução, para tanto, é necessário que se dê um espaço para que essa deformação ocorra, vejamos:


Deformação da célula de carga

 

           
             Se uma força (P) referente à Peso é aplicada sobre a Célula, o centro da mesma sofrerá uma deformação referente a esse peso. No entanto, se esse centro estiver em contato direto com a superfície, uma força (S) de reação com o mesmo valor é aplicada abaixo dele, impedindo que ocorra a deformação central.

            Para que esse fenômeno seja evitado, faz-se necessária a criação de uma base para a célula, de forma que o centro não fique em contato com a superfície e consiga sofrer deformação.

            Eu fiz uma base com espumas de proteção de componentes, mas esse suporte pode ser feito com qualquer outro material, desde que cumpra sua função de permitir a deformação.

 

            Abaixo está uma foto do componente virado para demonstração.

Célula de carga uso

            Depois de fazer isso para a sua célula e para todas as outras se você estiver trabalhando com mais de uma, construa o seu protótipo de balança, eu utilizei mais algumas espumas e umas placas para isso.

            Ao terminar de montar a balança e com todos os componentes conectados de acordo com o exposto em Ligação do Circuito, vamos partir para a programação.

 

Processo para Calibrar a Célula de Carga

 

            Toda balança precisa ter suas células calibradas com o uso de um peso conhecido, para isso faça a seguinte programação:

            Iremos incluir a Biblioteca HX711.h  e em seguida definiremos os pinos correspondentes às ligações com o Arduino, no meu caso eu utilizei o pino 2 para o SCK  e o pino 3 para DT.


Calibração da balança_1

           
Em seguida iniciaremos a rotina de configurações, definindo o Baud rate da comunicação, os prints iniciais, atrasos e set de escala.

Calibração da balança_2

                Em void loop colocaremos todas as funções que desejamos deixar em loop, sendo elas as mensagens printadas na tela, as medições e funções de incremento e decremento do fator de calibração.

Calibração da balança_3

            Se preferir, copie e cole o código abaixo na IDE do Arduino:

/* 
Tutorial: Calibração de uma Célula de Carga
Autor: Curto Circuito
Descrição: Programa para calibrar célula com o uso de um peso conhecido. */
#include "HX711.h" /*Biblioteca do HX711.h */ HX711 balanca(3, 2); /* SCK= pino 2 e DT= pino 3 */ float calibration_factor = 48011.00; /* Fator de calibração para ajuste da célula */ float peso; /* variável peso */ void setup() { /* rotina de configurações */ Serial.begin(9600); /* Baud rate da comunicação */ Serial.println("Remova todos os pesos da balança"); /* Printa "Remova todos os pesos da balança" na COM */ delay(1000); /* atraso de 1000ms = 1s */ Serial.println("Após estabilização das leituras, coloque o peso conhecido na balança"); /* Printa "Após estabilização das leituras, coloque o peso conhecido na balança" na COM */ delay(1000); /* atraso de 1000ms = 1s */ Serial.println("Pressione + para incrementar o fator de calibração"); /* Printa "Pressione + para incrementar o fator de calibração" na COM */ Serial.println("Pressione - para decrementar o fator de calibração"); /* Printa "Pressione - para decrementar o fator de calibração" na COM */ delay(1000); /* atraso de 1000ms = 1s */ balanca.set_scale(); /* seta escala */ balanca.tare(); /* escala da tara */ long zero_factor = balanca.read_average(); /* Realizando a leitura */ } void loop() { /* chama função de loop */ balanca.set_scale(calibration_factor); /* a balanca está em função do fator de calibração */ Serial.print("Peso: "); /* Printa "Peso:" na COM */ peso = balanca.get_units(), 10; /* imprime peso */ if (peso < 0) /* se a unidade for menor que 0 será considerado 0 */ { peso = 0.00; /* Para o caso do peso ser negativo, o valor apresentado será 0 */ } Serial.print(peso); /* Printa o peso na serial */ Serial.print(" kg"); /* Printa "kg" na serial */ Serial.print(" Fator de calibração: "); /* Printa "Fator de calibração:" na serial */ Serial.print(calibration_factor); /* Printa o fator de calibração na serial */ Serial.println(); /* Pula linha no serial */ delay(500); /* atraso de 500ms = 0.5s*/ if(Serial.available()) /* caso sejam inseridos caracteres no serial */ { char temp = Serial.read(); if(temp == '+') /* Se o + for pressionado */ calibration_factor += 1; /* incrementa 1 no fator de calibração */ else if(temp == '-') /* Caso o - seja pressionado */ calibration_factor -= 1; /* Decrementa 1 do fator de calibração */ } }

            Conecte a USB da sua placa Arduino no computador e selecione a placa em: 

                                                                                        Ferramentas > Placa:... > Arduino/ Genuino Uno 
Seleção de placa

 


           Ainda em Ferramentas, selecione a porta de comunicação, sendo nessa ordem:

                                                                  Ferramentas > Porta... > COM(número da sua COM)

Seleção de porta

            Depois de fazer as configurações de acordo, compile o programa na seta do canto superior esquerdo da IDE compilar_icon

            Com o programa compilado, abra o Monitor Serial e aguarde até que os valores sejam mostrados. Quando os pesos já estiverem sendo dados, coloque o peso conhecido e ajuste o fator de calibração até que o valor medido em peso seja igual ao peso real do objeto.

 

            Esse ajuste é uma forma de descontar interferências de peso como o peso da chapa sobre a balança, entre outros.

            Abra o Monitor Serial monitor_serial_icon  e ajuste o fator de calibração com + e – do seu teclado, até que o valor medido seja igual ao do peso já conhecido, ao fazer isso, você achará o Fator de Calibração da sua balança, você usará esse mesmo fator para todos os projetos com essa balança, guarde esse número.

Projeto Balança com Peso em Todos os Planetas

 

           Cada planeta do Sistema Solar possui a sua força gravitacional em razão do seu tamanho, essa força gravitacional define o peso do objeto que pode ser dado em Newtons, ou a massa que é dada em Kg, erroneamente chamamos a massa de peso, mas como é a forma comum, continuaremos usando o termo peso para não haver confusão
             O peso em cada planeta vai ser dado pelo peso da medição terráquea x a constante do peso do planeta em questão, segue tabela abaixo com relação de peso da Terra e o peso que esse mesmo 1Kg teria em outros planetas, sem deixar de lado o planeta anão, Plutão.

 

Tabela constante planetas 

 

           Para esse projeto acrescentaremos o Display LCD em nossa ligação, abaixo estão os esquemáticos para todas as configurações de células, para o projeto eu usarei apenas uma célula, mas deixarei os esquemáticos para outras ligações.

 

            Para o uso de uma única célula, a ligação será a seguinte:

Ligação projeto balança planetas

            Tabela de ligações:


Tabela de ligação de uma célula e display

in= input (entrada)   out= output (saída)

            Com duas células será dessa forma:


Ligação de 2 células com display


            Tabela com esquema de ligações:

Tabela ligação projeto 2 células

           
E para 4 células será necessário fazer a seguinte ligação:

Ligação de 4 células e LCD

           
Tabela com esquema de ligações:

Tabela de ligação de quatro células projeto

in= input (entrada)   out= output (saída)


            Para realizar o projeto, é necessário baixar as bibliotecas condizentes com o Display LCD e o I2C.

            Elas são a Wire.h e a LiquidCrystal_I2C.h e estão disponíveis nesses links:

 

            Siga o exemplo da biblioteca do HX711 para inclusão de bibliotecas em ZIP em Bibliotecas no Arduino.

            Instaladas as bibliotecas, feita a ligação e calibração da célula como mostrado emProcesso para Calibração de Célula, vamos dar início a nossa programação na IDE o Arduino.

            Primeiramente incluímos as bibliotecas e declaramos as variáveis, sendo que em float calibration_factor colocaremos o valor encontrado durante a calibração.

Programa Peso nos planetas_1

           
            Em seguida entramos na rotina de configurações.
Programa Peso nos planetas_2

            Depois da rotina de configurações, precisamos iniciar o nosso loop de medição e apresentação dos resultados de todos os planetas.

            O valor medido será multiplicado pela constante de gravidade do planeta em questão, feito isso, será salvo na variável com o nome do planeta, dessa forma:
                 

 mercurio = (bal_get_units()*0.37);

            Sendo que mercurio é a variável usada para o planeta Mercúrio, bal_get_units( ) é a medição da balança e *0.37 é a multiplicação pela constante gravitacional do planeta em questão, que no caso é 0,37. Repetiremos esse processo para todos os planetas, multiplicando pela sua constante gravitacional presente na tabela acima.

Programa Peso nos planetas_3

            Depois de salvar o resultado das equações nas variáveis, iremos programar para que esse valor seja mostrado no display e no monitor serial.
            O display apresenta uma distribuição de posições da seguinte forma:


0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15         linha 0
0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15         linha 1

            Então, se desejarmos que seja escrito "Peso na Terra" na primeira linha (linha 0), começando da posição 0, devemos setar (0,0). Para o peso podemos usar a segunda linha (linha 1), também partindo da posição 0, ficando então (0,1). Ou seja, o primeiro número indica a posição, o segundo indica a linha.
            Eu darei set no LCD seguindo a lógica acima:

 

 lcd.setCursor(0,0);

            Depois vou fazer aparecer a mensagem desejada, que no caso é: "Peso na Terra"

lcd.print("Peso na Terra ");

 
           Em seguida darei set na segunda linha, fazendo aparecer o valor medido pela balança, com 4 casas depois da vírgula, e "Kg" no final.

lcd.setCursor(0,1); lcd.print(bal.get_units(), 4); lcd.print(" kg ");

           Feito isso, darei um atraso de 800ms que equivale a 0,8s, e limparei o LCD para que seja mostrado o próximo valor.

delay(800) ; lcd.clear();


           Agora será feito o mesmo para o monitor serial, a diferença será que não precisaremos indicar as posições, primeiro printaremos "Peso na Terra", em seguida o valor medido com 4 casas após a vírgula, e depois do número o "Kg".

Serial.print("Peso na Terra "); Serial.print(bal.get_units(), 4); Serial.println(" kg");

         Todo o processo será repetido para os outros planetas, com a diferença de que ao invés de mostrarmos o valor direto medido pela balança, printaremos o resultado das equações acima, então apenas colocaremos a variável representante, pois ela já carrega a operação que deve ser feita com o valor medido, como exemplo de Mercúrio: 

 lcd.print(mercurio, 4);

        O programa ficará assim:

Programa Peso nos planetas_4
Programa Peso nos planetas_5
Programa Peso nos planetas_6
Programa Peso nos planetas_7Programa Peso nos planetas_8

 

            Depois de incluir na programação o void loop, eu criei uma função para zerar a balança caso se faça necessário, para isso eu defini que se z ou Z forem inseridos no monitor serial, todos os dados na tela serão limpos.

           Para facilitar, deixarei disponível a programação para copiar:

 

#include "HX711.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16,2);                     
#define DOUT 3
#define CLK  2
HX711 bal;             /* instancia Balança HX711 */
float calibration_factor = 48060.00; /* fator de calibração aferido na Calibração */ float mercurio; float venus; float marte; float jupiter; float saturno; float urano; float netuno; float plutao; void setup() { Serial.begin(9600); bal.begin(DOUT, CLK); /* inicializa a balança */ bal.set_scale(calibration_factor); /* ajusta fator de calibração */ bal.tare(); /* zera a Balança */ lcd.init(); lcd.backlight(); } void loop() { lcd.setCursor(0,0); lcd.print("Peso na Terra "); lcd.setCursor(0,1); lcd.print(bal.get_units(), 4); /* imprime peso na balança com duas casas decimais */ mercurio = (bal.get_units()*0.37); venus = (bal.get_units()*0.88); marte = (bal.get_units()*0.38); jupiter = (bal.get_units()*2.64); saturno = (bal.get_units()*1.15); urano = (bal.get_units()*1.17); netuno = (bal.get_units()*1.18); plutao = (bal.get_units()*0.11); lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso na Terra "); Serial.print(bal.get_units(), 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Mercurio "); lcd.setCursor(0,1); lcd.print(mercurio, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Mercurio "); Serial.print(mercurio, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Venus "); lcd.setCursor(0,1); lcd.print(venus, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Venus "); Serial.print(venus, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Marte "); lcd.setCursor(0,1); lcd.print(marte, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Marte "); Serial.print(marte, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Jupiter "); lcd.setCursor(0,1); lcd.print(jupiter, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Jupiter "); Serial.print(jupiter, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Saturno "); lcd.setCursor(0,1); lcd.print(saturno, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Saturno "); Serial.print(saturno, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Urano "); lcd.setCursor(0,1); lcd.print(urano, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Urano "); Serial.print(urano, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Netuno "); lcd.setCursor(0,1); lcd.print(netuno, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Netuno "); Serial.print(netuno, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ delay(800) ; lcd.clear(); lcd.setCursor(0,0); lcd.print("Peso em Plutao "); lcd.setCursor(0,1); lcd.print(plutao, 4); /* imprime peso na balança com duas casas decimais */ lcd.print(" kg "); /* imprime no monitor serial */ Serial.print("Peso em Plutao "); Serial.print(plutao, 4); /* imprime peso na balança com duas casas decimais */ Serial.println(" kg"); /* imprime no monitor serial */ if (Serial.available()) /* se a serial estiver disponivel */ { char temp = Serial.read(); /* le caracter da serial */ if (temp == 't' || temp == 'T') /* se pressionar t ou T */ { bal.tare(); /* zera a balança */ Serial.println(" Balança zerada"); /* imprime no monitor serial */ } } }

 

                        Depois de selecionar a porta e a placa, como ensinado anteriormente, iremos compilar o programa e abrir o monitor serial.

Ao inserir um peso sobre a balança eu obtive o seguinte resultado:

Monitor serial

            Os valores estão bem próximos aos encontrados em cálculo usando o peso dado na Terra, como pode ser visto na tabela abaixo:

Tabela de resultados

           Os resultados calculados e medidos não deram exatamente o mesmo pois na programação eu faço a medição em tempo real e multiplico pela constante do planeta em questão, nas contas eu utilizei o valor já medido em Terra para fazer os cálculos.

 

            Mas por que o valor do peso não é mantido?

 

           Bem, eu usei apenas uma célula para esse projeto, o que deixa a balança menos precisa e menos equilibrada, pois todo o peso precisa se equilibrar em um objeto central. No entanto, como mencionado, o erro não foi tão grande.

             
             Conclusão

           Conforme exposto, é possível criar uma balança com uma única célula de carga, mas as medições oscilam com mais frequência do que com o uso de mais células, sendo a configuração de quatro células a mais precisa entre todas, pelo fator de apresentar um equilíbrio maior para a balança, e por ter o valor medido por 4 células diferentes, entregando assim um dado com maior precisão.