Objetivo

     Existem diversos tutoriais de balança de medição com o uso de duas ou quatro células de carga, a proposta desse protótipo é 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:

       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.

Load_Cell

            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:

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

            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_interno

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 pernas resistivas

            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 de 4 células

           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 preparada

            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.

            A minha balança improvisada ficou dessa forma:

            Perceba que com as espumas eu consigo ter a deformação almejada da balança.

            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 em Processo 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:

/*///////////////////////////////////////////////////////////////////////////////////////////////////// 
Tutorial: Balança dos Planetas 
Autoria: Curto Circuito

Descrição do funcionamento: Balança que mostra em um display LCD o peso do objeto em todos
os planetas do Sistema Solar
////////////////////////////////////////////////////////////////////////////////////////////////////*/

 /*///////////////////////Inclusão de bibliotecas e declaração de variáveis///////////////////////////*/

#include "HX711.h" // inclui a biblioteca HX711 
#include <Wire.h> // inclui a biblioteca necessária para comunicação com I2C
#include <LiquidCrystal_I2C.h> // inclui biblioteca do LCD com I2C 
LiquidCrystal_I2C lcd(0x27, 16,2);              // define o endereço do LCD e o modelo, sendo para o caso 16x2
#define DOUT 3 // define DOUT como pino 3
#define CLK 2 // define CLK como pino 2
HX711 bal;                                      // instancia Balança HX711
float calibration_factor = 48060.00;            // Fator de calibração descoberto em Calibração da Balança
float mercurio;                                 // declaração de constante para Mercúrio
float venus;                                    // declaração de constante para Vênus
float marte;                                    // declaração de constante para Marte
float jupiter;                                  // declaração de constante para Júpiter
float saturno;                                  // declaração de constante para Saturno
float urano;                                    // declaração de constante para Urano
float netuno;                                   // declaração de constante para Netuno
float plutao;                                   // declaração de constante para Plutão


 /*/////////////////////////////Rotina de configurações/////////////////////////////////////////////////*/

void setup()                                    // início da rotina de configuração
{  
  Serial.begin(9600);                           // define Baud rate
  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();                                   // inicia LCD
  lcd.backlight();                              // liga blacklight do LCD
}

 /*//////////////////////////////////Rotina de repetição////////////////////////////////////////////////*/

void loop()                                     // início da rotina de loop
{ 
  mercurio = (bal.get_units()*0.37);            // define que a variável de Mercúrio será o valor medido x a constante de 0,37 
  venus = (bal.get_units()*0.88);               // define que a variável de Vênus será o valor medido x a constante de 0,88 
  marte = (bal.get_units()*0.38);               // define que a variável de Marte será o valor medido x a constante de 0,38 
  jupiter = (bal.get_units()*2.64);             // define que a variável de Júpiter será o valor medido x a constante de 2,64 
  saturno = (bal.get_units()*1.15);             // define que a variável de Saturno será o valor medido x a constante de 1,15 
  urano = (bal.get_units()*1.17);               // define que a variável de Urano será o valor medido x a constante de 1,17 
  netuno = (bal.get_units()*1.18);              // define que a variável de Netuno será o valor medido x a constante de 1,18 
  plutao = (bal.get_units()*0.11);              // define que a variável de Plutão será o valor medido x a constante de 0,11 
  
/*////////////////////////////////////////Peso na Terra///////////////////////////////////////////////////*/  
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso na Terra ");                 // printa no LCD "Peso na Terra"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(bal.get_units(), 4);                // imprime peso na balança com 4 casas depois da vírgula
  lcd.print(" kg ");                            // imprime " Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD
           
  Serial.print("Peso na Terra ");               // printa " Peso na Terra" no monitor serial 
  Serial.print(bal.get_units(), 4);             // imprime peso na balança com 4 casas depois da vírgula
  Serial.println(" kg");                        // imprime "Kg" no monitor serial 
  
  /*//////////////////////////////////Peso em Mercúrio///////////////////////////////////////////////////*/  
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Mercurio ");               // printa no LCD "Peso em Mercurio"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(mercurio, 4);                       // imprime peso em Mercúrio com 4 casas depois da vírgula
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s 
  lcd.clear();                                  // limpa LCD
  
  Serial.print("Peso em Mercurio ");            // printa " Peso em Mercurio" no monitor serial 
  Serial.print(mercurio, 4);                    // imprime peso na balança com 4 casas depois da vírgula
  Serial.println(" kg");                        // imprime "Kg" no monitor serial 

 /*/////////////////////////////////////Peso em Vênus///////////////////////////////////////////////////*/ 
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Venus ");                  // printa no LCD "Peso em Vênus"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(venus, 4);                          // imprime peso em Vênus com 4 casas depois da vírgula
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD

  Serial.print("Peso em Venus ");               // printa " Peso em Venus" no monitor serial 
  Serial.print(venus, 4);                       // imprime peso na balança com 4 casas depois da vírgula 
  Serial.println(" kg");                        // imprime "Kg" no monitor serial 
  
 /*//////////////////////////////////Peso em Marte/////////////////////////////////////////////////////*/ 
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Marte ");                  // printa no LCD "Peso em Marte"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(marte, 4);                          // imprime peso em Marte com 4 casas depois da vírgula
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD
  
  Serial.print("Peso em Marte ");               // printa " Peso em Marte" no monitor serial 
  Serial.print(marte, 4);                       // imprime peso na balança com 4 casas depois da vírgula 
  Serial.println(" kg");                        // imprime "Kg" no monitor serial 
    
  /*//////////////////////////////////Peso em Júpiter/////////////////////////////////////////////////*/ 
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Jupiter ");                // printa no LCD "Peso em Júpiter"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(jupiter, 4);                        // imprime peso em Júpiter com 4 casas depois da vírgula
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD
  
  Serial.print("Peso em Jupiter ");             // printa " Peso em Júpiter" no monitor serial 
  Serial.print(jupiter, 4);                     // imprime peso na balança com 4 casas depois da vírgula 
  Serial.println(" kg");                        // imprime "Kg" no LCD 

 /*////////////////////////////////////Peso em Saturno///////////////////////////////////////////////*/ 
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Saturno ");                // printa no LCD "Peso em Saturno"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(saturno, 4);                        // imprime peso em Saturno com 4 casas depois da vírgula
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD
  
  Serial.print("Peso em Saturno ");             // printa " Peso em Saturno" no monitor serial 
  Serial.print(saturno, 4);                     // imprime peso na balança com 4 casas depois da vírgula
  Serial.println(" kg");                        // imprime "Kg" no LCD 
  
 /*//////////////////////////////////////////Peso em Urano///////////////////////////////////////////*/ 
 
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Urano ");                  // printa no LCD "Peso em Urano"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(urano, 4);                          // imprime peso em Urano com 4 casas depois da vírgula 
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD
  
  Serial.print("Peso em Urano ");               // printa " Peso em Urano" no monitor serial 
  Serial.print(urano, 4);                       // imprime peso na balança com 4 casas depois da vírgula 
  Serial.println(" kg");                        // imprime "Kg" no LCD

  /*////////////////////////////////////Peso em Netuno//////////////////////////////////////////////*/  
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Netuno ");                 // printa no LCD "Peso em Netuno"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(netuno, 4);                         // imprime peso em Netuno com 4 casas depois da vírgula 
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  delay(800) ;                                  // atraso de 0,8s
  lcd.clear();                                  // limpa LCD
  
  Serial.print("Peso em Netuno ");              // printa " Peso em Netuno" no monitor serial 
  Serial.print(netuno, 4);                      // imprime peso na balança com 4 casas depois da vírgula
  Serial.println(" kg");                        // imprime "Kg" no LCD 
  
  /*/////////////////////////////////////Peso em Plutão/////////////////////////////////////////////*/  
  
  lcd.setCursor(0,0);                           // incializa LCD na coluna 0 e linha 0
  lcd.print("Peso em Plutao ");                 // printa no LCD "Peso em Plutão"
  lcd.setCursor(0,1);                           // inicializa LCD na coluna 0 e linha 1
  lcd.print(plutao, 4);                         // imprime peso em Urano com 4 casas depois da vírgula 
  lcd.print(" kg ");                            // imprime "Kg" no LCD 
  
  Serial.print("Peso em Plutao ");              // printa " Peso em Plutão" no monitor serial 
  Serial.print(plutao, 4);                      // imprime peso na balança com 4 casas depois da vírgula
  Serial.println(" kg");                        // imprime "Kg" no LCD 
  
/*////////////////////////////////////Zerar Balança///////////////////////////////////////////////*/ 
 
if (Serial.available())                         // se a serial estiver disponivel
  {
    char temp = Serial.read();                  // lê carctere da serial 
    if (temp == 'z' || temp == 'Z')             // se pressionar z ou Z
    {
      bal.tare();                               // zera a balança
      Serial.println(" Balança zerada");        // imprime " Balança Zerada" 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.


              Demonstração do Funcionamento
           
         
 Eu coloquei um motor como peso e o resultado que eu obtive foi esse:
           

Demonstração do funcionamento da balança com uma célula 

             
             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.