HX711 com Arduino: ligação da célula de carga, calibração e balança digital

A combinação HX711 e Arduino é a forma mais popular e barata de ler o sinal de microvolts de uma célula de carga e transformá-lo em peso em gramas. Balanças de cozinha, balanças de banheiro, balanças de colmeia, monitores de pote de ração e bancadas de empuxo de motores seguem a mesma ideia: a célula de carga se deforma uma quantidade invisível sob o peso, o HX711 transforma essa variação minúscula em um número de 24 bits e o Arduino converte esse número em gramas com um fator de calibração.

Neste guia você vai aprender como funciona a ponte de Wheatstone dentro de uma célula de carga, o que significam as cores dos fios (E+, E-, A+, A-), como ligar quatro células de meia ponte de 50 kg tiradas de uma balança de banheiro e como fazer a tara e encontrar o fator de calibração passo a passo com a biblioteca HX711. Depois você vai montar uma balança digital com LCD e botão de tara, ver por que as leituras oscilam e como estabilizá-las e, por fim, fazer o mesmo com um ESP32 e display OLED e com um Raspberry Pi Pico (MicroPython).

O que é uma célula de carga e como ela funciona?

Uma célula de carga é uma peça de alumínio ou aço com extensômetros (strain gauges) colados nela. Um extensômetro é um resistor gravado em zigue-zague sobre uma lâmina fina: quando o metal é esticado, a trilha fica mais longa e mais fina e sua resistência sobe; quando é comprimido, a resistência cai. A variação é incrivelmente pequena. Um extensômetro com fator de sensibilidade de cerca de 2 muda sua resistência em apenas 0,2 por cento com uma deformação de uma parte por mil; em um extensômetro de 1000 Ω isso dá 2 Ω, algo que um analogRead() normal nunca conseguiria detectar.

Para tornar essa variação minúscula mensurável, quatro extensômetros são ligados como uma ponte de Wheatstone. Uma ponte é simplesmente dois divisores de tensão lado a lado: a alimentação vai entre E+ e E-, enquanto A+ e A- são os pontos médios dos dois divisores. Sem carga, os quatro resistores são iguais, então os dois pontos médios ficam na mesma tensão e a saída é zero. Quando uma carga é aplicada, dois extensômetros se esticam e dois se comprimem; um ponto médio sobe enquanto o outro desce. Se R1 e R2 são os resistores de cima e de baixo do divisor da esquerda e R3 e R4 os do divisor da direita, a saída é Vout = Vexc × (R4/(R3+R4) − R2/(R1+R2)) e cresce em proporção ao peso. Você pode brincar com a ideia do divisor na calculadora de divisor de tensão.

Um valor como 1 mV/V na etiqueta de uma célula de carga é a sua sensibilidade: na capacidade máxima, a célula fornece 1 mV para cada volt de excitação. Como o módulo HX711 alimenta a ponte com cerca de 4,3 V, uma célula de 5 kg produz só 4,3 mV a 5 kg e apenas 0,86 µV por grama. É por isso que você precisa de um ADC dedicado de 24 bits com ganho de 128.

Há um detalhe que vale notar na tabela: o valor bruto não depende da tensão de alimentação. O HX711 usa a tensão que alimenta a ponte (AVDD) também como referência de medição, então, se a alimentação cair um pouco, a saída da ponte cai na mesma proporção e o resultado continua igual. Isso se chama medição raciométrica. Como regra aproximada, a capacidade máxima de uma célula de 1 mV/V equivale a cerca de 2.147.000 contagens. Divida isso pela capacidade da célula em gramas e você tem um fator de calibração aproximado: ≈ 2150 para 1 kg, ≈ 430 para 5 kg e ≈ 107 para 20 kg.

O que é o módulo HX711? Especificações

O HX711 é um ADC sigma-delta de 24 bits fabricado pela Avia Semiconductor para aplicações de pesagem. Ele tem um amplificador de ganho programável (PGA), um regulador que alimenta a ponte e um oscilador interno, e se comunica com o mundo externo por apenas dois fios, com um protocolo serial simples e próprio. Esse protocolo não é I2C: quando a linha DT (DOUT) vai a LOW, o dado está pronto, e o Arduino lê os 24 bits um por um enviando 25–27 pulsos na linha SCK. O número de pulsos escolhe o canal e o ganho da próxima leitura: 25 pulsos significam canal A com ganho 128, 26 pulsos canal B com ganho 32 e 27 pulsos canal A com ganho 64.

Na maioria dos módulos verdes baratos, o pino RATE vem ligado ao GND na própria placa, então o módulo faz 10 leituras por segundo. A taxa de 10 SPS tem menos ruído e ainda rejeita a interferência da rede de 50/60 Hz, o que a torna a melhor escolha para pesagem na maioria dos casos. Se a linha SCK ficar em HIGH por mais de 60 µs, o HX711 entra no modo power-down e também corta a alimentação da ponte. Em projetos a bateria, isso é útil por meio das funções power_down() e power_up().

Tipos de célula de carga: qual capacidade escolher?

Escolha uma capacidade de cerca de 1,5 vez a carga mais pesada que você vai medir. Uma célula grande demais reduz a resolução: dá para pesar uma carta de 50 g em uma célula de 20 kg, mas a leitura será quatro vezes mais grosseira que em uma célula de 5 kg. Sobrecarregar uma célula pequena é pior, porém; células de barra normalmente aguentam com segurança cerca de 120 por cento da capacidade, mas acima de 150 por cento o metal pode se deformar de forma permanente e a célula nunca mais volta ao zero. A capacidade total também depende de quantas células dividem o peso: quatro células de 50 kg nos cantos suportam 200 kg juntas.

Cores dos fios e ligação do HX711

As cores podem variar entre fabricantes; algumas células usam amarelo no lugar do preto ou azul no lugar do verde, ou trocam os papéis do branco e do verde. Para ter certeza, coloque o multímetro em ohms: o par de excitação (E+, E-) e o par de sinal (A+, A-) normalmente leem cerca de 1000 Ω, enquanto os pares cruzados leem cerca de três quartos disso. Inverter os fios de sinal não danifica nada; o valor simplesmente diminui quando você adiciona peso. Você corrige isso trocando os fios ou deixando o fator de calibração negativo. B+ e B- pertencem ao segundo canal e ficam sem uso em projetos com uma célula só.

Como ligar quatro células de carga de meia ponte de 50 kg (balança corporal)

As células de 50 kg das balanças de banheiro, aquelas com o meio em forma de E, têm só dois extensômetros e 3 fios, então cada uma é meia ponte. Os fios costumam ser vermelho, branco e preto, mas sempre encontre o terminal central medindo: os dois fios externos leem cerca de 2 kΩ entre si, e o fio central lê cerca de 1 kΩ até cada fio externo. Na maioria das células, o terminal central é o vermelho. Quando você liga quatro células juntas, como um anel, obtém uma ponte de Wheatstone completa.

1. Coloque as células nos quatro cantos da plataforma e numere os cantos: 1 (frente esquerda), 2 (frente direita), 3 (fundo direito) e 4 (fundo esquerdo).
2. Una os fios externos da mesma cor das células vizinhas: os brancos de 1 e 2, os pretos de 2 e 3, os brancos de 3 e 4 e os pretos de 4 e 1.
3. Ligue os fios vermelhos das células diagonais 1 e 3 a E+ e E-.
4. Ligue os fios vermelhos da outra diagonal, células 2 e 4, a A+ e A-.
5. Meça antes de soldar: E+ a E- e A+ a A- devem ler cerca de 2 kΩ. Se o valor for muito diferente, uma das emendas está errada.
6. Se o valor diminuir quando você adicionar peso, troque os fios A+ e A- ou use um fator negativo.

Como instalar a biblioteca HX711

1. Na Arduino IDE, abra Ferramentas > Gerenciar Bibliotecas e digite HX711 na caixa de busca.
2. Instale a HX711 Arduino Library, de Bogdan Necula. Se for a primeira vez que você instala uma biblioteca, dê uma olhada no guia como adicionar bibliotecas no Arduino.
3. Depois de instalar, você encontra os sketches HX711_basic_example e HX711_full_example em Arquivo > Exemplos > HX711 Arduino Library; o código abaixo usa as mesmas funções.

Como fazer a tara e encontrar o fator de calibração?

O HX711 não entrega gramas, ele entrega um número bruto. Para transformar esse número em peso você precisa de dois valores: o offset (tara), que é a leitura da balança vazia, e o número de contagens por grama, o fator de calibração. A fórmula é simples: peso = (valor bruto − offset) / fator. A função tare() encontra o offset; o fator você descobre uma vez, usando um objeto de peso conhecido. Por exemplo, se a balança vazia lê 84.120 e o valor passa a 298.870 quando você coloca um peso de 500 g, a diferença é 214.750 e o fator é 214.750 / 500 = 429,5.

1. Fixe bem a célula na plataforma; a calibração deve ser feita com a balança na forma final.
2. Carregue o código abaixo, abra o Monitor Serial em 9600 baud e espere a tara com a balança vazia.
3. Coloque um objeto de peso conhecido no meio. Uma garrafa de água pesada em outra balança serve bem; um peso de cerca de metade da capacidade dá o melhor resultado.
4. Digite o peso do objeto em gramas no Monitor Serial (ex.: 500) e pressione Enter. O código calcula e mostra o fator e faz na hora uma leitura de verificação.
5. Anote o fator e coloque-o no código da sua balança. Repetir algumas vezes com pesos diferentes e tirar a média melhora a precisão.

1#include "HX711.h"
2
3const int DT_PIN = 2;                      // HX711 DT (DOUT)
4const int SCK_PIN = 3;                     // HX711 SCK (PD_SCK)
5
6HX711 scale;
7
8void setup() {
9  Serial.begin(9600);
10  scale.begin(DT_PIN, SCK_PIN);            // kanal A, kazanç 128 / channel A, gain 128
11  if (!scale.wait_ready_timeout(1000)) {   // modül cevap vermiyor / module not answering
12    Serial.println("HX711 bulunamadi / HX711 not found");
13    while (true) {}
14  }
15  scale.set_scale();                       // faktör 1: ham sayı / factor 1: raw counts
16  Serial.println("Tarti bos olsun, dara aliniyor... / Keep it empty, taring...");
17  delay(2000);
18  scale.tare(20);                          // 20 ölçümün ortalaması sıfır / average of 20 readings = zero
19  Serial.println("Bilinen agirligi koy, gramini yaz (or. 500) / Place a known weight, type its grams (e.g. 500)");
20}
21
22void loop() {
23  if (Serial.available()) {
24    float bilinen = Serial.parseFloat();   // Seri Monitör'den gram / grams from Serial Monitor
25    if (bilinen > 0) {
26      double fark = scale.get_value(20);   // dara düşülmüş ham fark / tared raw difference
27      float faktor = fark / bilinen;
28      Serial.print("Ham fark / raw difference: ");
29      Serial.println(fark, 0);
30      Serial.print("Kalibrasyon faktoru / calibration factor: ");
31      Serial.println(faktor, 2);
32      scale.set_scale(faktor);             // hemen kontrol et / check right away
33      Serial.print("Kontrol / check: ");
34      Serial.print(scale.get_units(10), 1);
35      Serial.println(" g");
36    }
37  }
38}

O código considera zero a média de 20 leituras com tare(20); a 10 SPS isso leva cerca de 2 segundos. Quando você adiciona o peso, get_value(20) retorna a diferença bruta já tarada, e dividi-la pelos gramas conhecidos dá o fator. Não se preocupe se o fator sair negativo: isso só significa que os fios de sinal estão invertidos, e a balança funciona corretamente com um fator negativo. Para não precisar digitar o fator a cada inicialização, você pode gravá-lo na memória permanente do Arduino com EEPROM.put() e lê-lo de volta com EEPROM.get(); os detalhes estão no artigo EEPROM do Arduino.

Balança digital com Arduino: gramas em um LCD com botão de tara

Agora vamos montar uma balança de verdade usando o seu fator. O peso aparece em um LCD I2C 16x2, e um botão no D4 faz a tara a qualquer momento, então você pode colocar um recipiente primeiro, tarar e depois pesar só o que está dentro. O LCD se liga em A4 (SDA) e A5 (SCL); veja o artigo display LCD I2C para os detalhes e o artigo como ligar um botão para usar o pull-up interno.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include "HX711.h"
4
5const int DT_PIN = 2;                      // HX711 DT
6const int SCK_PIN = 3;                     // HX711 SCK
7const int DARA_BUTON = 4;                  // dara butonu, diğer ucu GND / tare button, other leg to GND
8const float FAKTOR = 429.5;                // kendi faktörünü yaz / use your own factor
9
10HX711 scale;
11LiquidCrystal_I2C lcd(0x27, 16, 2);       // adres, sütun, satır / address, columns, rows
12float filtreli = 0;                        // filtrelenmiş ağırlık / filtered weight
13
14void setup() {
15  pinMode(DARA_BUTON, INPUT_PULLUP);
16  lcd.init();
17  lcd.backlight();
18  lcd.print("Dara aliniyor...");
19  scale.begin(DT_PIN, SCK_PIN);
20  scale.set_scale(FAKTOR);
21  scale.tare(20);                          // açılışta terazi boş olmalı / scale must be empty at start
22  lcd.clear();
23  lcd.print("Agirlik:");
24}
25
26void loop() {
27  if (digitalRead(DARA_BUTON) == LOW) {    // butona basıldı / button pressed
28    lcd.setCursor(0, 1);
29    lcd.print("Dara...         ");
30    scale.tare(20);
31    filtreli = 0;
32    while (digitalRead(DARA_BUTON) == LOW) {}   // bırakılmasını bekle / wait for release
33    delay(50);                             // kontak sıçramasını atla / skip contact bounce
34  }
35
36  if (scale.is_ready()) {
37    float w = scale.get_units(4);          // 4 ölçümün ortalaması / average of 4 readings
38    if (fabs(w - filtreli) > 5.0) {
39      filtreli = w;                        // büyük değişim: filtreyi atla / big change: skip the filter
40    } else {
41      filtreli = 0.7 * filtreli + 0.3 * w; // üstel ortalama (EMA) / exponential moving average
42    }
43    float goster = filtreli;
44    if (fabs(goster) < 0.5) goster = 0;    // sıfırdaki titremeyi gizle / hide jitter around zero
45
46    char yazi[12];
47    dtostrf(goster, 8, 1, yazi);           // 8 karakter, 1 ondalık / 8 chars, 1 decimal
48    lcd.setCursor(0, 1);
49    lcd.print(yazi);
50    lcd.print(" g");
51  }
52}

O código usa três pequenos truques. O primeiro é uma média móvel exponencial (EMA): cada leitura nova contribui com apenas 30 por cento para o resultado, o que suaviza a oscilação. Segundo, se o peso mudar de repente mais de 5 g, o filtro é ignorado e o display pula direto para o novo valor; o filtro só atua com carga estável. Terceiro, uma zona morta: valores abaixo de ±0,5 g aparecem como 0, então números dançando como 0,3, -0,2, 0,1 somem com a balança vazia. Como get_units(4) espera quatro leituras a cada chamada, a 10 SPS o display atualiza cerca de 2,5 vezes por segundo.

Leituras instáveis: oscilação, deriva e como corrigir

A maioria dos problemas em projetos com HX711 vem da parte mecânica, não do código. Uma célula de carga de barra funciona como uma viga em balanço: uma ponta é parafusada na base e a outra no prato de cima, com um espaçador de alguns milímetros (arruelas ou um bloco impresso em 3D) em cada ponta. Assim a célula fica em forma de Z e o meio pode se deformar livremente. Se o meio da célula encostar na base ou no prato, se os parafusos estiverem apertados demais ou se o prato flexionar, as leituras vão ficar derivando. Garanta que a seta na célula aponte no sentido da força (para baixo) e nunca deixe nada encostar na parte do meio, onde ficam os extensômetros.

• Base rígida: a base e o prato não podem flexionar; use compensado grosso, MDF ou chapa de alumínio. Vibrações da mesa também aparecem na leitura.
• Fios curtos e presos: mantenha os fios da célula curtos, torça-os juntos e prenda-os no lugar. Um cabo solto empurra a célula e muda o valor.
• Alimentação limpa: a porta USB de um notebook pode ter ruído. Ajuda colocar capacitores de 100 nF e 10 µF entre o VCC e o GND do módulo e manter distância de motores, relés e da antena Wi-Fi.
• Tempo de aquecimento: nos primeiros minutos depois de ligar, enquanto a célula e o módulo esquentam, o ponto zero pode derivar alguns gramas; espere antes de medições precisas e depois faça a tara.
• Média: get_units(10) reduz o ruído cerca de três vezes, mas leva 1 segundo a 10 SPS. Equilibre velocidade e estabilidade; para outros métodos de filtragem, veja o artigo como filtrar dados de sensores.
• Fluência (creep): sob uma carga que fica por muito tempo, o valor pode mudar alguns gramas ao longo de minutos. Isso é da natureza da célula e fica mais visível em células baratas.
• Expectativas realistas: 0,5–1 g de estabilidade com uma célula de 5 kg bem montada, e 50–100 g em uma balança corporal feita com quatro células de 50 kg, são bons resultados.

Balança com ESP32: display OLED e calibração permanente

A mesma biblioteca roda sem mudanças no ESP32. O exemplo abaixo mostra o peso em dígitos grandes em um OLED SSD1306 de 0,96 polegada, faz a tara com um botão no GPIO 27 e salva o fator de calibração na flash com a biblioteca Preferences. Basta digitar o peso conhecido em gramas no Monitor Serial, e o novo fator é calculado e guardado de forma permanente. Para a ligação do OLED (SDA GPIO 21, SCL GPIO 22) e as bibliotecas, veja o artigo display OLED.

1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Preferences.h>
5#include "HX711.h"
6
7const int DT_PIN = 25;                     // HX711 DT
8const int SCK_PIN = 26;                    // HX711 SCK
9const int DARA_BUTON = 27;                 // dara butonu, diğer ucu GND / tare button, other leg to GND
10
11HX711 scale;
12Adafruit_SSD1306 display(128, 64, &Wire, -1);
13Preferences ayar;
14float faktor;
15
16void agirlikGoster(float g) {
17  display.clearDisplay();
18  display.setTextSize(1);
19  display.setCursor(0, 0);
20  display.print(F("BlueGrays Terazi"));
21  display.setTextSize(2);                  // büyük rakamlar / big digits
22  display.setCursor(0, 28);
23  if (fabs(g) < 1000) {
24    display.print(g, 1);
25    display.print(F(" g"));
26  } else {
27    display.print(g / 1000.0, 3);          // 1 kg üstü kilogram / kilograms above 1 kg
28    display.print(F(" kg"));
29  }
30  display.display();
31}
32
33void setup() {
34  Serial.begin(115200);
35  pinMode(DARA_BUTON, INPUT_PULLUP);
36  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);   // SDA 21, SCL 22
37  display.setTextColor(SSD1306_WHITE);
38
39  ayar.begin("terazi", false);             // flash'ta ayar alanı / settings namespace in flash
40  faktor = ayar.getFloat("faktor", 429.5); // kayıt yoksa varsayılan / default if nothing saved
41
42  scale.begin(DT_PIN, SCK_PIN);
43  scale.set_scale(faktor);
44  scale.tare(20);
45  Serial.println("Kalibrasyon: agirligi koy, gramini yaz / Calibrate: place a weight, type its grams");
46}
47
48void loop() {
49  if (digitalRead(DARA_BUTON) == LOW) {
50    scale.tare(20);
51    while (digitalRead(DARA_BUTON) == LOW) delay(10);   // bırakılmasını bekle / wait for release
52    delay(50);                             // kontak sıçramasını atla / skip contact bounce
53  }
54
55  if (Serial.available()) {
56    float bilinen = Serial.parseFloat();
57    if (bilinen > 0) {
58      faktor = scale.get_value(20) / bilinen;  // yeni faktör / new factor
59      scale.set_scale(faktor);
60      ayar.putFloat("faktor", faktor);     // elektrik kesilse de kalır / survives power loss
61      Serial.printf("Yeni faktor / new factor: %.2f\n", faktor);
62    }
63  }
64
65  if (scale.wait_ready_timeout(200)) {
66    agirlikGoster(scale.get_units(5));
67  }
68}

Quando você alimenta o HX711 pelo pino 3V3 do ESP32, o regulador do módulo não consegue chegar a 4,3 V e a ponte funciona com um pouco menos de 3,3 V. Como a medição é raciométrica, o fator quase não muda; só o ruído aumenta um pouco. O ESP32 também já está pronto para Wi-Fi: mostrar o peso em uma página web ou mandar uma notificação para o seu celular quando o pote de ração estiver vazio exige só algumas linhas a mais. Para começar, leia O que é o ESP32?. Em uma balança de colmeia a bateria, você coloca o HX711 para dormir entre as leituras com scale.power_down() e o ESP32 com deep sleep. Para manter o SCK em HIGH enquanto o ESP32 dorme, trave o pino com gpio_hold_en(); caso contrário ele flutua e o HX711 pode acordar sozinho. Lembre-se também de descartar as leituras dos primeiros 400 ms depois de acordar.

HX711 com o Raspberry Pi Pico (MicroPython)

O MicroPython não vem com um módulo para o HX711, mas o protocolo é tão simples que você mesmo escreve o driver em poucas linhas. A classe abaixo espera a linha DT ir a LOW, lê os dados enviando 24 pulsos no SCK, envia 1–3 pulsos extras para escolher o ganho e converte o resultado de complemento de dois para um número com sinal. As interrupções ficam desativadas por um instante durante a leitura, assim a linha SCK nunca fica em HIGH por mais de 60 µs e o HX711 não dorme por acidente. Para configurar o MicroPython, veja O que é o Raspberry Pi Pico?.

1from machine import Pin
2import machine
3import time
4
5class HX711:
6    def __init__(self, dt, sck, gain=128):
7        self.dt = Pin(dt, Pin.IN)
8        self.sck = Pin(sck, Pin.OUT, value=0)
9        self.extra = {128: 1, 64: 3, 32: 2}[gain]   # toplam 25, 27, 26 darbe / 25, 27, 26 pulses in total
10        self.offset = 0
11        self.scale = 1.0
12        self.read()                                 # kazancı ayarla / set the gain
13
14    def read(self, timeout_ms=1000):
15        start = time.ticks_ms()
16        while self.dt.value() == 1:                 # DT LOW ise veri hazır / data ready when DT is LOW
17            if time.ticks_diff(time.ticks_ms(), start) > timeout_ms:
18                raise OSError("HX711 yanit vermiyor / not responding")
19        irq = machine.disable_irq()                 # SCK 60 µs'den uzun HIGH kalmasın / keep SCK HIGH under 60 µs
20        value = 0
21        for _ in range(24):
22            self.sck.value(1)
23            value = (value << 1) | self.dt.value()
24            self.sck.value(0)
25        for _ in range(self.extra):                 # sonraki ölçümün kanalı ve kazancı / next channel and gain
26            self.sck.value(1)
27            self.sck.value(0)
28        machine.enable_irq(irq)
29        if value & 0x800000:                        # ikiye tümleyen / two's complement
30            value -= 0x1000000
31        return value
32
33    def read_average(self, times=10):
34        return sum(self.read() for _ in range(times)) / times
35
36    def tare(self, times=15):
37        self.offset = self.read_average(times)
38
39    def get_units(self, times=5):
40        return (self.read_average(times) - self.offset) / self.scale
41
42
43hx = HX711(dt=15, sck=14)                           # DT -> GP15, SCK -> GP14
44print("Tarti bos, dara aliniyor... / Scale empty, taring...")
45hx.tare()
46hx.scale = 429.5                                    # kendi faktörün / your own factor
47
48while True:
49    print("{:.1f} g".format(hx.get_units()))
50    time.sleep_ms(200)

A lógica de calibração é a mesma do Arduino: com hx.scale = 1.0, coloque o peso conhecido e divida o resultado de get_units() pelo peso dele em gramas para obter o fator. No Pico, alimente o HX711 também pelo pino 3V3(OUT). Se quiser mostrar o peso em uma tela, adicione um OLED com o driver ssd1306.py e mostre o valor com oled.text().

Ideias de projetos com o HX711 e uma célula de carga

• Balança de cozinha: uma célula de 5 kg, um botão de tara e um display OLED para uma balança com resolução de 1 g.
• Balança corporal: as quatro células de uma balança de banheiro antiga, um HX711 e um LCD I2C mostrando quilogramas.
• Alimentador inteligente para pets: quando o peso do pote cair abaixo de um valor definido, o ESP32 manda uma notificação e um servo motor abre uma portinhola para soltar ração.
• Balança de vaso de planta: descubra quanta água uma planta precisa conforme o vaso fica mais leve e compare o resultado com um sensor de umidade do solo.
• Monitor de colmeia: coloque 4 células sob a colmeia, acompanhe a florada pelo ganho de peso diário e registre os dados pelo Wi-Fi.
• Contador de peças: ensine o peso de um único parafuso e descubra quantos parafusos há na caixa pelo peso total.
• Registro de dados: envie as leituras ao computador pela porta serial e faça gráficos com o método de enviar dados para o Excel.

Erros comuns e como corrigi-los

Depois que uma célula de carga com HX711 está bem montada e calibrada, você tem um aparelho que mede com precisão de grama usando peças baratas. Salve o seu fator de calibração, faça uma mecânica firme e ajuste o filtro à velocidade do seu projeto; o resto fica por conta da sua imaginação. Para uma visão mais ampla sobre medição, dê uma olhada no guia de sensores para Arduino. No app BlueGrays você encontra projetos para ler sensores, mostrar valores em displays LCD e OLED e registrar dados com o ESP32, com esquemas do circuito e código passo a passo, para combinar com a sua balança.