Balança Inteligente com Sensor de Peso e Arduino Nano ESP32

A precisão na medição de peso é fundamental em uma variedade de aplicações, desde o controle de qualidade industrial até projetos de automação residencial. Neste tutorial, exploraremos a construção de uma balança inteligente utilizando um Sensor de Peso de 1kg, componentes acessíveis e a plataforma Arduino Nano ESP32, proporcionando uma solução prática e eficiente para medição de pesos inferiores a 1kg.

Ao combinar um sensor de peso de 1kg com o módulo conversor HX711, seremos capazes de criar uma balança altamente precisa e versátil. Além disso, vamos abordar a integração dessa balança com a Arduino Cloud, permitindo que os dados de peso sejam facilmente acessados e monitorados em tempo real através de uma interface web.

Este tutorial é ideal tanto para iniciantes que desejam aprender sobre eletrônica e programação quanto para makers que procuram por uma solução prática e customizável para suas necessidades de medição de peso.

Objetivos

O principal objetivo deste tutorial é fornecer um guia detalhado para a construção de uma balança inteligente utilizando um Arduino Nano ESP32, um sensor de peso de 1kg e um módulo conversor HX711. Exploraremos passo a passo a montagem física dos componentes, garantindo uma compreensão clara do processo de construção. Além disso, neste tutorial você aprenderá:

Configuração na Arduino Cloud: Além da montagem da balança, outro objetivo importante é abordar a configuração da balança na Arduino Cloud. Demonstraremos como criar uma “Thing” na plataforma Arduino Cloud, configurar variáveis de leitura de peso e criar um dashboard para visualização dos dados de peso em tempo real.
Aprendizado de Eletrônica e Programação: Este tutorial também tem como objetivo proporcionar um ambiente de aprendizado para eletrônica e programação. Os participantes poderão compreender os princípios por trás do funcionamento de sensores de peso, amplificadores de instrumentação e conversores analógico-digitais, além de ganhar experiência prática na escrita e implementação de código para Arduino.

Materiais Necessários

Para seguir com este tutorial, você irá precisar dos seguintes componentes:

Além dos itens mencionados acima, você também precisará ter uma conta cadastrada na Arduino Cloud.

Como funciona o Sensor de Peso de 1kg?

Um sensor de peso de 1 kg é um dispositivo projetado para medir a força exercida sobre ele, geralmente em unidades de quilogramas (kg) ou em força relacionada, como newtons (N). Um dos tipos mais comuns de sensor de peso é a célula de carga.

Célula de Carga: A célula de carga é o componente principal de um sensor de peso. Ela consiste em uma estrutura metálica flexível (normalmente feita de alumínio ou aço) com uma malha de fios de metal. Quando uma força é aplicada à célula de carga, ela se deforma ligeiramente, e essa deformação resulta em uma mudança na resistência elétrica dos fios de metal.
Medição de Resistência: Um circuito eletrônico conectado à célula de carga mede essa mudança na resistência elétrica. Essa mudança está diretamente relacionada à quantidade de força aplicada à célula de carga.
Conversão para Peso: Com base na mudança na resistência medida, o circuito eletrônico converte essa informação em um valor de peso. Isso é feito utilizando calibrações prévias que relacionam a deformação da célula de carga à força aplicada e, consequentemente, ao peso.
Saída de Dados: O valor de peso calculado é então enviado para um display ou sistema de controle, onde pode ser exibido para o usuário ou usado para automação de processos, como em balanças industriais, sistemas de dosagem, entre outros.

É importante notar que os sensores de peso devem ser calibrados periodicamente para garantir precisão nas medições, e fatores ambientais, como temperatura e umidade, podem influenciar o desempenho desses dispositivos.

Como funciona o Módulo Conversor HX711 para Sensor de Peso?

O módulo conversor HX711 é comumente usado em conjunto com células de carga para medir pesos com precisão. Aqui está um resumo de como funciona:

Princípio de Funcionamento: O módulo HX711 é um amplificador de instrumentação de alta precisão com um conversor analógico-digital (ADC) de 24 bits integrado. Ele é projetado especificamente para trabalhar com células de carga, permitindo que elas forneçam leituras precisas de peso.
Conexão com a Célula de Carga: A célula de carga é conectada ao módulo HX711. Geralmente, isso é feito através de quatro fios: dois para fornecer energia à célula de carga e dois para transmitir os sinais de mudança de resistência.
Amplificação do Sinal: O módulo HX711 amplifica o sinal proveniente da célula de carga. Isso é necessário porque os sinais gerados pela célula de carga são muito pequenos e precisam ser amplificados para serem digitalizados de forma precisa pelo ADC.
Conversão Analógico-Digital (ADC): O sinal amplificado é então convertido em um sinal digital pelo ADC de 24 bits embutido no módulo HX711. Esta conversão digitaliza o sinal analógico da célula de carga, permitindo que seja processado digitalmente.
Leitura dos Dados: Após a conversão analógico-digital, os dados são prontos para serem lidos por um microcontrolador ou outro dispositivo de processamento. O módulo HX711 geralmente se comunica com o microcontrolador através de uma interface digital, como SPI (Serial Peripheral Interface) ou I2C (Inter-Integrated Circuit).
Calibração: Antes de usar o módulo HX711, é importante calibrá-lo para garantir leituras precisas de peso. Isso envolve a aplicação de pesos conhecidos à célula de carga e ajustar os parâmetros de calibração do módulo para corresponder às leituras esperadas.

No geral, o módulo conversor HX711 simplifica o processo de medição de peso utilizando células de carga, ao amplificar, digitalizar e fornecer os dados prontos para processamento por um microcontrolador ou outro dispositivo eletrônico.

Circuito Eletrônico com Sensor de Peso

Segue o esquema de conexões entre a placa Arduino Nano ESP32, o Módulo Conversor HX711 para Sensor de Peso e o Sensor de Peso de 1kg:

As conexões realizadas são as seguintes:

Módulo Conversor HX711 para Sensor de Peso <-> Arduino Nano ESP32

GND <-> GND
DT <-> Pino A1
SCK <-> Pino A0
VCC <-> 3.3V

Módulo Conversor HX711 para Sensor de Peso <-> Sensor de Peso de 1kg

E+ <-> Cabo Vermelho
E- <-> Cabo Preto
A- <-> Cabo Branco
A+ <-> Cabo Verde

Montagem da Balança Inteligente com sensor de peso

O princípio de funcionamento do sensor de peso de 1 kg se baseia na deformação da parte metálica, tornando essencial que o sensor não seja diretamente apoiado em uma superfície plana.

No Thingiverse, é possível obter um arquivo STL contendo as peças necessárias para montar a balança. O arquivo pode ser obtido aqui.

Durante a montagem, é possível fixar as peças ao sensor utilizando parafusos ou simplesmente cola. O essencial é posicionar o sensor da seguinte maneira:

Configurando a Arduino Nano ESP32 na Arduino Cloud

1. O primeiro passo é logar na Arduino Cloud. Caso ainda não tenha uma conta cadastrada, você pode criar uma aqui.

2. Na sequência, é necessário conectar o Arduino ESP32 na Arduino Cloud. Para isso, vá em “Devices” e clique em “ADD DEVICE”.
3. Depois, em “Setup Device”, selecione “Arduino board”.
4. Caso você não tenha instalado o Arduino Create Agent em seu computador, uma mensagem sobre a instalação irá aparecer em sua tela. Clique em “INSTALL” para continuar.
5. Depois que o Arduino Create Agent for instalado, a tela de início da configuração irá aparecer. Clique em “CONFIGURE”.
6. Dê um nome para a sua placa.
7. Na sequência, salve/copie as informações sobre o “Device ID” e “Secret Key”. Clique em “CONTINUE”.
8. Aguarde as configurações do seu dispositivo serem concluídas.

Pronto! A placa Arduino Nano ESP32 já está pronta para ser utilizada na Arduino Cloud.

Criando uma Thing na Arduino Cloud

Agora precisamos criar a variável peso que estará disponível no Dashboard.

1. Para isso, na Arduino Cloud clique em “Things” e depois em “CREATE THING”.
2. Clique em “Select Device”.
3. Depois, clique em “ASSOCIATE”.
4. Na sequência, clique em “Configure”.
5. Insira o nome e a senha da rede WiFi onde a placa está conectada. Também insira a “Secret Key” fornecida na etapa anterior. Clique em “SAVE”.
6. Agora clique em “ADD” para adicionar uma variável.
7. Configure a variável da seguinte maneira:

Name: Peso
Type: Floating Point Number
Declaration: float peso;
Variable Permission: Read & Write

8. Clique em “ADD VARIABLE”.

Pronto! Sua variável peso já está configurada.

Criando um Dashboard na Arduino Cloud

Agora precisamos configurar o dashboard onde o peso medido pela balança inteligente é apresentado .

1. Para isso, na Arduino Cloud clique em “Dashboard” e depois em “CREATE DASHBOARD”.
2. Clique em “ADD” e depois no widget Value.
3. Em “Name” digite Peso.
4. Clique em “Link Variable”. Selecione a variável Peso e depois clique em “LINK VARIABLE”.
5. Por fim, clique em “DONE”.
6. Agora vamos repetir o processo acima para adicionar um gráfico que irá apresentar o histórico dos pesos medidos. Clique em “ADD” e depois selecione o widget Chart.
7. Em “Name” digite Histórico.
8. Clique em “Link Variable”. Selecione novamente a variável Peso e depois clique em “LINK VARIABLE”.
9. Por fim, clique em “DONE”.

Pronto! Seu dashboard já está configurado. Se desejar, você pode ajustar os widgets clicando no botão de ajuste.

Código para Calibração da Balança Inteligente

Para iniciar o processo de calibração, é fundamental contar com um peso conhecido como referência, o que significa ter conhecimento do peso real do objeto que será utilizado. Esse peso de referência pode variar, sendo possível utilizar tanto um objeto próximo ao peso máximo suportado, como 1 kg, quanto um peso menor. No nosso caso, utilizamos um objeto com massa de 0,034 kg.

Como resultado do processo de calibração, obtivemos um valor de escala de 1048004,56. Esse valor deverá ser empregado no código de pesagem. Importante ressaltar que cada balança e cada célula de carga possuem características únicas, e seus padrões de pesagem podem variar conforme os métodos de instalação e uso. Portanto, é crucial carregar o código a seguir na placa e obter seu próprio valor de escala.

// Programa: Balança Inteligente com Arduino Nano ESP32 - Calibração
// Autor: Rosana Guse

// Adiciona as bibliotecas utilizadas no código
#include "HX711.h"

// Define os pinos de ligação com o Arduino
#define DT A1
#define SCK A0

// Cria um objeto chamado balança
HX711 balanca;

void setup() {
  
  // Inicia o módulo HX711
  balanca.begin(DT, SCK);

  // Inicia a Comunicação Serial
  Serial.begin(9600);
  delay(5000);
  
  // Faz a verificação e registro da tara
  Serial.print("Leitura da tara:  ");
  Serial.println(balanca.read());
  Serial.println("Registrando a tara...");
  balanca.set_scale();
  balanca.tare(20);
  delay(2000);
  Serial.println("Insira um objeto com peso conhecido...");
}

void loop() {
  
  // Cria variáveis temporárias
  long soma = 0;
  int num_leituras = 32;
  float peso_objeto;

  // Aguarda a usuário digitar o peso do objeto conhecido
  Serial.println("Por favor, insira o peso do objeto em quilogramas:");
  while (!Serial.available()) {
  }
  peso_objeto = Serial.parseFloat();
  Serial.print("Peso do objeto inserido: ");
  Serial.print(peso_objeto, 3);
  Serial.println(" kg");

  // Realiza 32 leitura para calcular o valor da escala de calibração
  Serial.println("Realizando 32 leituras para calcular a média:");
  for (int i = 0; i < num_leituras; i++) {
    soma += balanca.get_value(10); 
    delay(100);
  }
  float media = soma / (float)num_leituras;
  float escala_calculada = media / peso_objeto;
  Serial.print("Média das 32 leituras: ");
  Serial.println(media, 2);
  Serial.print("Escala calculada: ");
  Serial.println(escala_calculada, 2); 

  // Limpa o buffer serial para ser feita uma nova leitura
  while (Serial.available()) {
    Serial.read();
  }

  // Aguarda 5 segundos antes de realizar a próxima leitura
  delay(5000);  
}

Código para Pesagem com Balança Inteligente com Sensor de Peso

O código a seguir desempenha a função de pesagem de objetos com peso inferior a 1 kg. Ao criar um dispositivo (“Thing”) na Arduino Cloud, um código correspondente é gerado automaticamente. Neste caso, você só precisará modificá-lo com o código abaixo.

Certifique-se de editar a linha 16, inserindo o valor de escala obtido no processo anterior.

// Programa: Balança Inteligente com Arduino Nano ESP32 - Pesagem
// Autor: Rosana Guse

// Adiciona as bibliotecas utilizadas no código
#include "thingProperties.h"
#include "HX711.h";

// Define os pinos de ligação com o Arduino
#define DT A1
#define SCK A0
 
// Cria um objeto chamado balança 
HX711 balanca;

// INSIRA AQUI O VALOR DA ESCALA OBTIDO NO PROCESSO DE CALIBRAÇÃO
float escala = 1048004.56;
 
void setup() {

  // Inicia o módulo HX711
  balanca.begin (DT, SCK);
  
  // Inicia a Comunicação Serial
  Serial.begin(9600);
  delay(5000); 
  
  // Inicia a comunicação com a Arduino Cloud
  initProperties();
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();

  // Faz a verificação e registro da tara
  Serial.print("Leitura da tara:  ");
  Serial.println(balanca.read());
  Serial.println("Registrando a tara...");
  balanca.set_scale(escala);
  balanca.tare(20);
  delay(2000);
}

void loop() {
  
  // Pesa o objeto
  Serial.println("Insira um objeto a ser pesado...");
  peso = balanca.get_units(20);
  Serial.println(peso,3);
  
  // Atualiza os valores na Arduino Cloud
  ArduinoCloud.update();
  
  // Aguarda 5 segundos antes de realizar a próxima leitura
  delay(5000);
}

void onPesoChange()  {
}

Funcionamento

A balança inteligente com sensor de peso opera com base em um princípio fundamental de física e eletrônica, aproveitando a relação entre a deformação de uma célula de carga e a resistência elétrica para medir o peso de um objeto. No centro do sistema está a célula de carga, uma estrutura flexível de metal que responde à aplicação de uma força exercida sobre ela. Quando um objeto é colocado sobre a balança, a célula de carga se deforma ligeiramente, resultando em uma mudança na resistência elétrica dos fios de metal que a compõem.

Para amplificar o sinal gerado pela célula de carga, a balança inteligente utiliza um amplificador de instrumentação, o módulo HX711. Esse componente é essencial para garantir que mesmo pequenas alterações na resistência da célula de carga sejam detectadas e processadas de forma adequada pelo sistema eletrônico da balança.

Após a amplificação, o sinal elétrico é convertido em um formato digital por meio de um conversor analógico-digital (ADC). Esse processo é necessário para que o Arduino Nano ESP32 conectado balança seja capaz de processar e interpretar os dados de peso de maneira eficiente. A conversão digital permite que o sistema realize cálculos adicionais, se necessário, e exiba o peso do objeto em uma interface de usuário, seja em um display integrado na própria balança ou em uma plataforma de monitoramento remoto, como a Arduino Cloud.

Se você tiver dúvidas, sugestões ou experiências para compartilhar, fique a vontade para deixar um comentário abaixo. E para não perder nenhum conteúdo como este, não deixe de nos seguir no Instagram.