HX711 Arduino: Pengkabelan Load Cell, Kalibrasi, dan Timbangan Digital

Kombinasi HX711 dan Arduino adalah cara paling populer dan paling murah untuk membaca sinyal tingkat mikrovolt dari load cell dan mengubahnya menjadi berat dalam gram. Timbangan dapur, timbangan badan, timbangan sarang lebah, pemantau mangkuk makanan hewan, dan alat uji daya dorong motor semuanya memakai ide yang sama: load cell melengkung sedikit sekali di bawah beban, HX711 mengubah perubahan kecil itu menjadi angka 24-bit, dan Arduino mengubah angka itu menjadi gram dengan faktor kalibrasi.

Di panduan ini kamu akan mempelajari cara kerja jembatan Wheatstone di dalam load cell, arti warna kabelnya (E+, E-, A+, A-), cara menyambungkan empat sel half-bridge 50 kg yang diambil dari timbangan badan, dan cara melakukan tare serta mencari faktor kalibrasi langkah demi langkah dengan library HX711. Setelah itu kamu akan membuat timbangan digital dengan LCD dan tombol tare, melihat kenapa pembacaannya bergetar dan cara menstabilkannya, lalu melakukan hal yang sama dengan ESP32 dan layar OLED serta dengan Raspberry Pi Pico (MicroPython).

Apa itu load cell dan bagaimana cara kerjanya?

Load cell adalah potongan aluminium atau baja yang ditempeli strain gauge. Strain gauge adalah resistor yang digores berpola zig-zag pada foil tipis: ketika logamnya meregang, jalurnya jadi lebih panjang dan lebih tipis sehingga hambatannya naik; ketika tertekan, hambatannya turun. Perubahannya sangat kecil. Gauge dengan gauge factor sekitar 2 hanya mengubah hambatannya sebesar 0,2 persen pada regangan satu per seribu; untuk gauge 1000 Ω itu hanya 2 Ω, yang tidak akan pernah terdeteksi oleh analogRead() biasa.

Agar perubahan sekecil ini bisa diukur, empat strain gauge disambungkan menjadi jembatan Wheatstone. Jembatan ini sebenarnya dua pembagi tegangan yang berdampingan: catu daya dipasang antara E+ dan E-, sedangkan A+ dan A- adalah titik tengah kedua pembagi. Tanpa beban, keempat resistor sama besar, jadi kedua titik tengah berada di tegangan yang sama dan output-nya nol. Ketika diberi beban, dua gauge meregang dan dua tertekan; satu titik tengah naik sementara yang lain turun. Jika R1 dan R2 adalah resistor atas dan bawah pembagi kiri dan R3 serta R4 milik pembagi kanan, output-nya adalah Vout = Vexc × (R4/(R3+R4) − R2/(R1+R2)), dan nilainya naik sebanding dengan berat. Kamu bisa bermain dengan ide pembagi ini di kalkulator pembagi tegangan.

Angka seperti 1 mV/V di label load cell adalah sensitivitasnya: pada kapasitas penuh, sel mengeluarkan 1 mV untuk setiap volt tegangan eksitasi. Karena modul HX711 memberi jembatan sekitar 4,3 V, sel 5 kg hanya menghasilkan 4,3 mV pada 5 kg dan cuma 0,86 µV per gram. Karena itulah kamu butuh ADC 24-bit khusus dengan penguatan 128.

Ada detail yang patut diperhatikan di tabel ini: nilai mentahnya tidak bergantung pada tegangan catu. HX711 juga memakai tegangan yang memberi daya ke jembatan (AVDD) sebagai referensi pengukurannya, jadi jika catu daya turun sedikit, output jembatan turun dengan rasio yang sama dan hasilnya tetap. Ini disebut pengukuran ratiometrik. Sebagai aturan kasar, kapasitas penuh pada sel 1 mV/V setara dengan sekitar 2.147.000 hitungan. Bagi angka itu dengan kapasitas sel dalam gram dan kamu mendapat perkiraan faktor kalibrasi: ≈ 2150 untuk 1 kg, ≈ 430 untuk 5 kg, dan ≈ 107 untuk 20 kg.

Apa itu modul HX711? Spesifikasi

HX711 adalah ADC sigma-delta 24-bit buatan Avia Semiconductor untuk aplikasi penimbangan. Di dalamnya ada penguat dengan penguatan yang bisa diprogram (PGA), regulator yang memberi daya ke jembatan, dan osilator internal, dan chip ini berkomunikasi dengan dunia luar hanya lewat dua kabel dengan protokol serial sederhana miliknya sendiri. Protokol itu bukan I2C: ketika jalur DT (DOUT) menjadi LOW, data sudah siap, dan Arduino membaca 24 bit satu per satu dengan mengirim 25–27 pulsa di jalur SCK. Jumlah pulsa menentukan kanal dan penguatan untuk pembacaan berikutnya: 25 pulsa berarti kanal A dengan penguatan 128, 26 pulsa kanal B dengan penguatan 32, dan 27 pulsa kanal A dengan penguatan 64.

Pada kebanyakan modul hijau murah, pin RATE sudah disambungkan ke GND di board, jadi modul mengambil 10 pembacaan per detik. 10 SPS lebih sedikit noise-nya dan juga meredam interferensi listrik 50/60 Hz, sehingga dalam banyak kasus ini pilihan terbaik untuk menimbang. Jika jalur SCK tetap HIGH lebih dari 60 µs, HX711 masuk ke mode power-down dan juga memutus daya ke jembatan. Di proyek bertenaga baterai, ini berguna lewat fungsi power_down() dan power_up().

Jenis load cell: kapasitas mana yang sebaiknya dipilih?

Pilih kapasitas sekitar 1,5 kali beban terberat yang akan kamu ukur. Sel yang terlalu besar menurunkan resolusi: kamu bisa menimbang surat 50 g dengan sel 20 kg, tapi pembacaannya empat kali lebih kasar daripada dengan sel 5 kg. Namun membebani sel kecil secara berlebihan lebih buruk; sel batang biasanya aman sampai sekitar 120 persen kapasitasnya, tapi di atas 150 persen logamnya bisa melengkung permanen dan sel tidak akan pernah kembali ke nol. Kapasitas total juga bergantung pada berapa sel yang berbagi beban: empat sel 50 kg di sudut-sudut bersama-sama menahan 200 kg.

Warna kabel dan pengkabelan HX711

Warna bisa berbeda antar produsen; beberapa sel memakai kuning sebagai ganti hitam atau biru sebagai ganti hijau, atau menukar peran putih dan hijau. Supaya yakin, atur multimetermu ke ohm: pasangan eksitasi (E+, E-) dan pasangan sinyal (A+, A-) biasanya terbaca sekitar 1000 Ω, sedangkan pasangan silang terbaca sekitar tiga perempatnya. Menukar kabel sinyal tidak merusak apa pun; nilainya hanya turun ketika kamu menambah beban. Kamu memperbaikinya dengan menukar kabel atau membuat faktor kalibrasi negatif. B+ dan B- milik kanal kedua dan tidak dipakai di proyek satu sel.

Menyambungkan empat load cell half-bridge 50 kg (timbangan badan)

Sel 50 kg dari timbangan badan, yang bagian tengahnya berbentuk E, hanya berisi dua strain gauge dan 3 kabel, jadi masing-masing adalah setengah jembatan. Kabelnya biasanya merah, putih, dan hitam, tapi selalu cari center tap dengan mengukur: dua kabel luar terbaca sekitar 2 kΩ di antara keduanya, dan kabel tengah terbaca sekitar 1 kΩ ke masing-masing kabel luar. Pada kebanyakan sel, center tap-nya merah. Ketika kamu menyambungkan empat sel seperti cincin, kamu mendapat jembatan Wheatstone penuh.

1. Letakkan sel di empat sudut platform dan beri nomor sudutnya 1 (depan kiri), 2 (depan kanan), 3 (belakang kanan), dan 4 (belakang kiri).
2. Sambungkan kabel luar berwarna sama dari sel yang bersebelahan: putih 1 dan 2, hitam 2 dan 3, putih 3 dan 4, serta hitam 4 dan 1.
3. Sambungkan kabel merah sel diagonal 1 dan 3 ke E+ dan E-.
4. Sambungkan kabel merah diagonal lainnya, sel 2 dan 4, ke A+ dan A-.
5. Ukur sebelum menyolder: E+ ke E- dan A+ ke A- keduanya harus terbaca sekitar 2 kΩ. Jika nilainya jauh berbeda, salah satu sambungan keliru.
6. Jika nilainya turun ketika kamu menambah beban, tukar kabel A+ dan A- atau pakai faktor negatif.

Menginstal library HX711

1. Di Arduino IDE, buka Tools > Manage Libraries dan ketik HX711 di kotak pencarian.
2. Instal HX711 Arduino Library buatan Bogdan Necula. Jika ini pertama kalinya kamu menginstal library, lihat panduan Cara Menambahkan Library di Arduino.
3. Setelah terinstal, kamu akan menemukan sketch HX711_basic_example dan HX711_full_example di File > Examples > HX711 Arduino Library; kode di bawah memakai fungsi yang sama.

Bagaimana cara melakukan tare dan mencari faktor kalibrasi?

HX711 tidak memberimu gram, melainkan angka mentah. Untuk mengubah angka itu menjadi berat kamu butuh dua nilai: offset (tare) yang terbaca ketika timbangan kosong, dan jumlah hitungan per gram, yaitu faktor kalibrasi. Rumusnya sederhana: berat = (nilai mentah − offset) / faktor. Fungsi tare() mencari offset; faktornya kamu hitung sekali, memakai benda yang beratnya kamu ketahui. Misalnya, jika timbangan kosong terbaca 84.120 dan nilainya menjadi 298.870 ketika kamu meletakkan beban 500 g di atasnya, selisihnya 214.750 dan faktornya 214.750 / 500 = 429.5.

1. Pasang sel dengan kokoh di platform; kalibrasi harus dilakukan dengan timbangan dalam bentuk akhirnya.
2. Upload kode di bawah, buka Serial Monitor di 9600 baud, dan tunggu proses tare selagi timbangan kosong.
3. Letakkan benda yang beratnya diketahui di tengah. Botol air yang sudah ditimbang di timbangan lain juga bisa; beban sekitar setengah kapasitas memberi hasil terbaik.
4. Ketik berat benda dalam gram di Serial Monitor (mis. 500) dan tekan Enter. Kode menghitung dan mencetak faktornya lalu langsung mengambil pembacaan untuk pengecekan.
5. Catat faktornya dan masukkan ke kode timbanganmu. Mengulang beberapa kali dengan beban berbeda lalu merata-ratakannya meningkatkan akurasi.

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}

Kode ini menganggap rata-rata 20 pembacaan sebagai nol dengan tare(20); pada 10 SPS itu butuh sekitar 2 detik. Ketika kamu menambahkan beban, get_value(20) mengembalikan selisih mentah setelah tare, dan membaginya dengan gram yang diketahui menghasilkan faktornya. Jangan khawatir jika faktornya negatif: itu hanya berarti kabel sinyal terbalik, dan timbangan tetap bekerja dengan benar dengan faktor negatif. Agar tidak perlu memasukkan faktor setiap kali menyala, kamu bisa menulisnya ke memori permanen Arduino dengan EEPROM.put() dan membacanya kembali dengan EEPROM.get(); detailnya ada di artikel EEPROM Arduino.

Timbangan digital Arduino: menampilkan gram di LCD dengan tombol tare

Sekarang mari buat timbangan sungguhan memakai faktormu. Berat ditampilkan di LCD I2C 16x2, dan tombol di D4 melakukan tare kapan saja, jadi kamu bisa meletakkan wadah dulu, tare, lalu menimbang isinya saja. LCD tersambung ke A4 (SDA) dan A5 (SCL); lihat artikel layar LCD I2C untuk detailnya dan artikel pengkabelan tombol untuk memakai pull-up internal.

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}

Kode ini memakai tiga trik kecil. Pertama, exponential moving average (EMA): setiap pembacaan baru hanya menyumbang 30 persen ke hasil, sehingga getarannya halus. Kedua, jika berat tiba-tiba berubah lebih dari 5 g, filter dilewati dan layar langsung melompat ke nilai baru; filter hanya bekerja dengan beban yang tetap. Ketiga, dead band: nilai di bawah ±0,5 g ditampilkan sebagai 0, jadi angka yang menari-nari seperti 0,3, -0,2, 0,1 hilang ketika timbangan kosong. Karena get_units(4) menunggu empat pembacaan setiap kali dipanggil, pada 10 SPS layar diperbarui sekitar 2,5 kali per detik.

Pembacaan tidak stabil: getaran, drift, dan cara mengatasinya

Kebanyakan masalah di proyek HX711 berasal dari mekaniknya, bukan kodenya. Load cell batang bekerja seperti balok kantilever: satu ujung disekrup ke alas dan ujung lainnya ke pelat atas, dengan pengganjal beberapa milimeter (ring atau blok cetak 3D) di tiap ujung. Dengan begitu sel duduk dalam bentuk Z dan bagian tengahnya bisa melengkung bebas. Jika bagian tengah sel menyentuh alas atau pelat, jika sekrupnya terlalu kencang, atau jika pelatnya melentur, pembacaan akan terus bergeser. Pastikan panah di sel mengarah ke arah gaya (ke bawah), dan jangan biarkan apa pun menyentuh bagian tengah tempat strain gauge berada.

• Alas yang kaku: Alas dan pelat tidak boleh melentur; pakai triplek tebal, MDF, atau lembaran aluminium. Getaran dari meja juga muncul di pembacaan.
• Kabel pendek dan terikat: Buat kabel sel tetap pendek, pilin bersama, dan kunci posisinya. Kabel yang menggantung mendorong sel dan mengubah nilainya.
• Daya yang bersih: Port USB laptop bisa berisik. Menambahkan kapasitor 100 nF dan 10 µF di antara VCC dan GND modul serta menjauhkannya dari motor, relay, dan antena Wi-Fi akan membantu.
• Waktu pemanasan: Selama beberapa menit pertama setelah menyala, ketika sel dan modul memanas, titik nol bisa bergeser beberapa gram; tunggu dulu sebelum pengukuran presisi, lalu lakukan tare.
• Rata-rata: get_units(10) memangkas noise sekitar tiga kali tapi butuh 1 detik pada 10 SPS. Seimbangkan kecepatan dan stabilitas; untuk metode penyaringan lain, lihat artikel menyaring data sensor.
• Creep: Di bawah beban yang lama diam di atasnya, nilainya bisa berubah beberapa gram dalam hitungan menit. Ini sifat alami sel dan lebih terasa pada sel murah.
• Harapan yang realistis: Stabilitas 0,5–1 g dengan sel 5 kg yang terpasang baik, dan 50–100 g pada timbangan badan dari empat sel 50 kg, sudah termasuk hasil yang bagus.

Timbangan dengan ESP32: layar OLED dan kalibrasi permanen

Library yang sama berjalan tanpa perubahan di ESP32. Contoh di bawah menampilkan berat dengan angka besar di OLED SSD1306 0,96 inci, melakukan tare dengan tombol di GPIO 27, dan menyimpan faktor kalibrasi ke flash dengan library Preferences. Cukup ketik berat yang diketahui dalam gram di Serial Monitor, lalu faktor baru dihitung dan disimpan permanen. Untuk pengkabelan OLED (SDA GPIO 21, SCL GPIO 22) dan library-nya, lihat artikel layar 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}

Ketika kamu memberi daya HX711 dari pin 3V3 ESP32, regulator modul tidak bisa mencapai 4,3 V dan jembatan bekerja di sedikit di bawah 3,3 V. Karena pengukurannya ratiometrik, faktornya hampir tidak berubah; hanya noise-nya yang sedikit naik. ESP32 juga siap untuk Wi-Fi: menampilkan berat di halaman web atau mengirim notifikasi ke ponselmu ketika mangkuk makanan kosong hanya butuh beberapa baris tambahan. Untuk memulai, baca Apa Itu ESP32?. Pada timbangan sarang lebah bertenaga baterai, kamu menidurkan HX711 di antara pembacaan dengan scale.power_down() dan ESP32 dengan deep sleep. Agar SCK tetap HIGH selama ESP32 tidur, kunci pin itu dengan gpio_hold_en(); kalau tidak, pin akan mengambang dan HX711 bisa bangun sendiri. Ingat juga untuk membuang pembacaan dari 400 ms pertama setelah bangun.

HX711 dengan Raspberry Pi Pico (MicroPython)

MicroPython tidak membawa modul HX711 bawaan, tapi protokolnya begitu sederhana sehingga kamu bisa menulis driver-nya sendiri dalam beberapa baris. Kelas di bawah menunggu jalur DT menjadi LOW, membaca data dengan mengirim 24 pulsa di SCK, mengirim 1–3 pulsa tambahan untuk memilih penguatan, dan mengubah hasil dari komplemen dua menjadi angka bertanda. Interupsi dimatikan sebentar selama pembacaan, jadi jalur SCK tidak pernah HIGH lebih dari 60 µs dan HX711 tidak tertidur tanpa sengaja. Untuk instalasi MicroPython, lihat Apa Itu 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)

Logika kalibrasinya sama seperti di Arduino: dengan hx.scale = 1.0, letakkan beban yang diketahui dan bagi hasil get_units() dengan beratnya dalam gram untuk mendapat faktornya. Di Pico, beri daya HX711 dari pin 3V3(OUT) juga. Jika kamu ingin menampilkan berat di layar, tambahkan OLED dengan driver ssd1306.py dan cetak nilainya dengan oled.text().

Ide proyek dengan HX711 dan load cell

• Timbangan dapur: Sel 5 kg, tombol tare, dan layar OLED untuk timbangan dengan resolusi 1 g.
• Timbangan badan: Empat sel dari timbangan badan bekas, HX711, dan LCD I2C yang menampilkan kilogram.
• Pemberi makan hewan pintar: Ketika berat mangkuk turun di bawah nilai tertentu, ESP32 mengirim notifikasi dan motor servo membuka katup untuk menjatuhkan makanan.
• Timbangan pot tanaman: Hitung berapa banyak air yang dibutuhkan tanaman seiring pot menjadi lebih ringan, dan bandingkan hasilnya dengan sensor kelembapan tanah.
• Pemantau sarang lebah: Pasang 4 sel di bawah sarang, ikuti aliran madu lewat kenaikan berat harian, dan catat datanya lewat Wi-Fi.
• Penghitung komponen: Ajari berat satu sekrup, lalu hitung berapa sekrup di dalam kotak dari berat totalnya.
• Pencatatan data: Kirim pembacaan ke komputermu lewat port serial dan buat grafiknya dengan metode mengirim data ke Excel.

Kesalahan umum dan cara memperbaikinya

Begitu load cell dengan HX711 terpasang dan terkalibrasi dengan benar, kamu punya perangkat yang mengukur sampai gram dengan komponen murah. Simpan faktor kalibrasimu, buat mekanik yang kokoh, dan sesuaikan filter dengan kecepatan proyekmu; sisanya terserah imajinasimu. Untuk gambaran yang lebih luas tentang mengukur berbagai hal, lihat Panduan Sensor Arduino. Di aplikasi BlueGrays kamu akan menemukan proyek untuk membaca sensor, menampilkan nilai di layar LCD dan OLED, serta mencatat data dengan ESP32, lengkap dengan skema rangkaian dan kode langkah demi langkah, sehingga kamu bisa menggabungkannya dengan timbanganmu.