Timbangan Timbangan Digital Menggunakan Load Cell dan Arduino

Dalam posting ini kita akan belajar tentang load cell berbasis strain gauge. Kami akan mengeksplorasi apa itu Strain Gauge, apa itu Load Cell, efek suhu pada pengukur regangan, kompensasi suhu dengan jembatan Wheatstone dan penguat Load cell HX711, dan akhirnya kita akan belajar bagaimana membangun mesin timbangan berbasis Arduino dengan menerapkan load cell sebagai sensor berat.

Posting ini membahas tentang metode pengukuran dan pengukuran berat badan, serta menerapkan metode tersebut dalam rangkaian timbangan timbangan berbasis Arduino.

Kita semua suka melihat berat badan kita terlepas dari usia kita, anak kecil mungkin senang melihat berat badannya bertambah dan orang dewasa mungkin senang melihat penurunan berat badannya. Berat adalah konsep penting sejak zaman kuno yang membantu dalam perdagangan barang, pengembangan peralatan ilmiah dan produk komersial.

Di zaman modern, kami mengukur berat dalam kilogram, miligram bahkan mikrogram untuk keperluan laboratorium. Satu gram sama di seluruh dunia, semua alat pengukur berat harus mengukur sama. Produksi massal pil dengan perbedaan kecil beberapa miligram dosis sudah cukup untuk membuat pil penyelamat menjadi pil bunuh diri.

Apa itu Berat?

Berat adalah gaya yang diberikan pada sebuah pesawat. Besarnya gaya yang diberikan berbanding lurus dengan massa suatu benda, artinya semakin tinggi massa benda tersebut maka semakin tinggi gaya yang diberikan.

Massa adalah jumlah materi fisik yang ada dalam suatu benda.

Beratnya tergantung pada satu faktor lagi: Gravitasi.

Gravitasi konstan di seluruh dunia (Ada variasi kecil dalam gravitasi karena bentuk bumi yang bulat tidak seragam, tetapi sangat kecil). Berat 1Kg di bumi sama dengan berat 160 gram di bulan dengan massa yang sama, karena tarikan gravitasinya jauh lebih lemah.

Sekarang Anda tahu apa itu berat dan apa faktor yang membuat suatu benda menjadi berat.

Apa itu Strain gauge:

Pengukur regangan adalah transduser atau sensor yang mengukur regangan (deformasi) pada suatu benda. Ini ditemukan oleh insinyur listrik Edward E. Simmons dan insinyur mekanik Arthur Claude Ruge.

Ilustrasi Strain Gauge:

Pengukur regangan fleksibel. Ini adalah pola lembaran logam tipis yang diapit di antara dua lembaran plastik tipis dan harus dipasang pada permukaan menggunakan lem yang sesuai atau bahan perekat apa pun.

Ketika kita menerapkan berat atau gaya pada permukaan itu berubah bentuk dan pengukur regangan juga berubah bentuk. Deformasi pengukur regangan menyebabkan hambatan listrik dari lembaran logam berubah.

Sekarang perubahan strain gauge pada resistansinya berbanding lurus dengan berat atau gaya yang diterapkan pada permukaan.

Dalam kehidupan nyata, perubahan resistansi strain gauge sangat tidak signifikan untuk dideteksi. Untuk mendeteksi perubahan kecil dalam hambatan, kami menggunakan jembatan Wheatstone.

Mari kita lihat apa itu jembatan Wheatstone secara singkat.

Memahami jembatan Wheatstone:

Jembatan batu gandum adalah sirkuit yang dapat digunakan untuk menentukan hambatan yang tidak diketahui. Jembatan Wheatstone dirancang oleh Samuel Hunter Christie, kemudian jembatan Wheatstone ditingkatkan dan disebarluaskan oleh Sir Charles

Wheatstone.

Ilustrasi rangkaian jembatan Wheatstone:

Multimeter digital modern kami dapat membaca nilai resistansi mulai dari kisaran mega ohm, kilo ohm, dan ohm.

Dengan menggunakan jembatan batu Gandum kita dapat mengukur hambatan dalam kisaran mili ohm.

Jembatan batu gandum terdiri dari 4 resistor, dari empat resistor, 3 diketahui resistansi dan satu resisten tidak diketahui.

Beda potensial (voltase) diterapkan pada titik 'A' dan 'C' dan dari titik 'B' dan 'D' sebuah voltmeter dihubungkan.

Jika semua resistor sama, tidak ada arus yang mengalir pada titik 'B' dan 'D' dan voltmeter akan menunjukkan angka nol. Ini disebut jembatan seimbang.

Jika resistansi resistor berbeda dari tiga resistor lainnya, akan ada aliran tegangan antara titik 'B' dan 'D' dan voltmeter akan membaca beberapa nilai sebanding dengan resistansi yang tidak diketahui. Ini disebut jembatan tidak seimbang.

Di sini resistansi yang tidak diketahui adalah pengukur regangan, ketika resistansi diubah, itu mencerminkan voltmeter.

Sekarang, kami telah mengubah deformasi atau berat atau gaya menjadi sinyal tegangan. Tegangan ini perlu diperkuat untuk mendapatkan beberapa pembacaan yang berguna, yang akan diumpankan ke mikrokontroler untuk mendapatkan pembacaan dalam gram.

Sekarang mari kita bahas bagaimana suhu mempengaruhi kinerja pengukur regangan.

Efek suhu pada Strain Gauge:

Pengukur regangan sensitif terhadap suhu dan dapat mengacaukan pembacaan berat / gaya sebenarnya. Ketika ada perubahan suhu sekitar, lembaran logam mengalami pemuaian logam, yang secara langsung mempengaruhi resistansi.

Kita bisa membatalkan efek suhu menggunakan jembatan Wheatstone. Mari kita lihat bagaimana kita dapat mengkompensasi suhu menggunakan jembatan Wheatstone.

Kompensasi Suhu:

Kita dapat dengan mudah menetralkan efek suhu dengan mengganti semua resistor dengan pengukur regangan. Sekarang semua hambatan pengukur regangan akan dipengaruhi oleh suhu yang sama dan kebisingan yang tidak diinginkan akan dinihilkan oleh karakter jembatan Wheatstone.

Apa itu Load Cell?

Load cell adalah profil aluminium dengan pengukur regangan yang dipasang pada 4 sisi dalam konfigurasi jembatan Wheatstone.

Ilustrasi Load cell:

Jenis sel beban ini kaku dan biasa digunakan di industri. Ada 4 dudukan sekrup, satu sisi dibaut ke permukaan stasioner dan ujung lainnya dibaut ke dudukan (misalnya keranjang) untuk menahan benda yang akan diukur.

Ini memiliki berat maksimum yang ditentukan pada lembar data atau pada tubuhnya, melebihi spesifikasi dapat merusak sel beban.

Sel jembatan penuh terdiri dari 4 terminal yaitu E +, E-, yang merupakan kabel eksitasi di mana tegangan suplai diterapkan. Dua kabel lainnya adalah S + dan S-, yang merupakan kabel sinyal, dari mana tegangan diukur.

Sekarang tegangan ini berada dalam kisaran milivolt yang tidak cukup kuat untuk dibaca dan diproses oleh mikrokontroler. Kami membutuhkan amplifikasi dan perubahan kecil harus terlihat oleh mikrokontroler. Untuk melakukan ini, ada modul khusus yang disebut penguat sel beban, mari kita lihat ringkasannya.

Load cell Amplifier HX711:

Ilustrasi modul penguat sel beban HX711:

Penguat sel beban didasarkan pada IC HX711 yang merupakan konverter analog ke digital 24-bit yang dirancang khusus untuk mengukur berat. Ini memiliki keuntungan yang dapat dipilih berbeda 32, 64 dan 128 dan beroperasi pada 2,6 hingga 5,5 V.
Papan breakout ini membantu mendeteksi variasi kecil pada sel beban. Modul ini membutuhkan pustaka HX711.h untuk beroperasi dengannya

Arduino atau mikrokontroler lainnya.

Load cell akan dihubungkan dengan modul HX711 dan modul tersebut akan dihubungkan dengan Arduino. Sirkuit pengukur berat perlu dikembangkan dengan cara ini.

Kesimpulannya, sekarang Anda tahu apa itu pengukur regangan, apa itu jembatan Wheatstone, efek suhu pada pengukur regangan, kompensasi suhu dan apa itu penguat sel beban.

Kita telah memahami secara komprehensif bagian teori dari desain timbangan dari pembahasan di atas, sekarang mari kita lihat bagaimana sel loas dapat digunakan untuk membuat mesin timbangan praktis dengan menggunakan Arduino

Merancang Mesin Timbangan Timbangan Digital menggunakan Arduino

Dalam diskusi berikut kita akan mempelajari cara membuat mesin timbangan digital menggunakan Arduino yang dapat mengukur bobot dari beberapa gram hingga 40 Kg (bergantung pada spesifikasi sel beban Anda) dengan akurasi yang wajar. Kami akan belajar tentang klasifikasi load cell kelas presisi dan kami akan mengkalibrasi sirkuit yang diusulkan dan menyelesaikan mesin timbangan berat.

Catatan: Sirkuit ini mungkin tidak sesuai dengan standar yang diperlukan untuk implementasi komersial.

Mesin timbangan berat digunakan dalam berbagai jenis perdagangan dan penelitian mulai dari miligram hingga beberapa ton. Skala maksimum mesin timbangan berat yang diusulkan bergantung pada spesifikasi sel beban Anda. Ada berkisar dari 500 gram, 1 Kg, 5Kg, 10 Kg, 20 Kg dan 40 Kg dll.

Ada berbagai tingkat sel beban, mereka menawarkan rentang akurasi yang berbeda dan Anda harus memilih yang sesuai untuk proyek Anda.

Klasifikasi Kelas Akurasi Sel Beban:

Kelas akurasi yang berbeda ditentukan untuk jenis aplikasi yang berbeda. Klasifikasi di bawah adalah dari akurasi terendah hingga kisaran akurasi tertinggi.

Sel beban dengan akurasi yang lebih rendah (tetapi cukup akurat) diklasifikasikan sebagai D1, C1 dan C2. Ini cukup untuk proyek ini. Sel beban ini digunakan untuk mengukur berat pasir, semen atau air.

Load cell kelas C3 digunakan dalam jaminan kualitas seperti memeriksa berat bantalan bola, bagian konstruksi mesin, dll.

C4, C5, C6 adalah yang terbaik di kelas akurasi, nilai sel beban ini digunakan untuk mengukur dalam gram ke mikrogram. Kelas kelas ini digunakan dalam timbangan konter toko, pemantauan produksi skala besar, pengemasan makanan dan penggunaan laboratorium, dll.

Sekarang mari selami detail teknis proyek tersebut.

Diagram Sirkuit:

Muat koneksi sel HX711 ke Arduino dan sel beban.

Proyek ini terdiri dari papan amplifier sel beban Arduino, Load cell dan HX711 serta komputer. Outputnya dapat dipantau pada monitor Serial Arduino IDE.

Otak proyek adalah seperti biasa Arduino, Anda dapat menggunakan model papan Arduino apa pun. HX711 adalah ADC 24 bit, yang dapat menemukan kelenturan terkecil karena beban pada sel beban. Ini dapat beroperasi dari 2,7 V hingga 5 V. Daya disediakan dari papan Arduino.

Sel beban umumnya memiliki empat kabel, yang merupakan keluaran dari pengukur regangan yang dikonfigurasi jembatan Wheatstone.

Kabel merah adalah E +, kabel hitam adalah E-, kabel hijau adalah A- dan kabel putih adalah A +. Beberapa modul HX711 menentukan nama terminal sel beban dan beberapa modul HX711 menentukan warna kabel, model seperti itu diilustrasikan dalam diagram rangkaian.

Pin DATA HX711 terhubung ke pin # 3 Arduino dan pin Clock HX711 terhubung ke pin # 2 Arduino.

Cara Memasang Load cell:

Sel beban memiliki empat lubang sekrup, dua di kedua sisi. Salah satu sisi harus tidak bergerak untuk akurasi terbaik sehingga dapat ditumpuk ke kayu dengan berat yang wajar.

Kayu tipis atau pelat tipis dapat digunakan untuk menahan beban pengukur seperti yang diilustrasikan di atas.

Jadi ketika Anda menempatkan beban, sel beban menekuk begitu juga dengan pengukur regangan dan mengubah resistansinya yang diukur dengan modul HX711 dan diumpankan ke Arduino.

Setelah penyiapan perangkat keras selesai, mari unggah kode dan kalibrasi.

Mengkalibrasi sirkuit:

Ada dua program yang salah satunya adalah program kalibrasi (mencari faktor kalibrasi). Kode lainnya adalah program pengukuran berat, faktor kalibrasi yang terdapat pada kode program kalibrasi perlu dimasukkan dalam program pengukuran berat.

Faktor kalibrasi menentukan akurasi pengukuran berat.

Unduh pustaka HX711 di sini: github.com/bogde/HX711

Kode Program Kalibrasi:

//-------------------- --------------------//
#include
const int out = 3
const int clck = 2
HX711 scale(out, clck)
float CalibrationFactor = -96550
char var
void setup()
{
Serial.begin(9600)
Serial.println('------------- Weight Scale Calibration --------------')
Serial.println('Press Q,W,E,R or q,w,e,r to increase calibration factor by 10,100,1000,10000 respectively')
Serial.println('Press A,S,D,F or a,s,d,f to decrease calibration factor by 10,100,1000,10000 respectively')
Serial.println('Press 'T' or 't' for tare')
scale.set_scale()
scale.tare()
long zero_factor = scale.read_average()
Serial.print('Zero factor: ')
Serial.println(zero_factor)
}
void loop()
{
scale.set_scale(CalibrationFactor)
Serial.print('Reading: ')
Serial.print(scale.get_units(), 3)
Serial.println(' Kilogram')
Serial.print('Calibration Factor is: ')
Serial.println(CalibrationFactor)
Serial.println('--------------------------------------------')
if (Serial.available())
{
var = Serial.read()
if (var == 'q')
{
CalibrationFactor = CalibrationFactor + 10
}
else if (var == 'a')
{
CalibrationFactor = CalibrationFactor - 10
}
else if (var == 'w')
{
CalibrationFactor = CalibrationFactor + 100
}
else if (var == 's')
{
CalibrationFactor = CalibrationFactor - 100
}
else if (var == 'e')
{
CalibrationFactor = CalibrationFactor + 1000
}
else if (var == 'd')
{
CalibrationFactor = CalibrationFactor - 1000
}
else if (var == 'r')
{
CalibrationFactor = CalibrationFactor + 10000
}
else if (var == 'f')
{
CalibrationFactor = CalibrationFactor - 10000
}
else if (var == 'Q')
{
CalibrationFactor = CalibrationFactor + 10
}
else if (var == 'A')
{
CalibrationFactor = CalibrationFactor - 10
}
else if (var == 'W')
{
CalibrationFactor = CalibrationFactor + 100
}
else if (var == 'S')
{
CalibrationFactor = CalibrationFactor - 100
}
else if (var == 'E')
{
CalibrationFactor = CalibrationFactor + 1000
}
else if (var == 'D')
{
CalibrationFactor = CalibrationFactor - 1000
}
else if (var == 'R')
{
CalibrationFactor = CalibrationFactor + 10000
}
else if (var == 'F')
{
CalibrationFactor = CalibrationFactor - 10000
}
else if (var == 't')
{
scale.tare()
}
else if (var == 'T')
{
scale.tare()
}
}
}
//-------------------- --------------------//

Bagaimana cara mengkalibrasi:

• Dengan pengaturan perangkat keras yang lengkap, unggah kode di atas.
• Lepaskan pelat tipis atau kayu yang digunakan untuk menahan beban termasuk dua sekrup (sisi lain dari sel beban harus dipasang ke alas)
• Buka monitor Serial.
• Tempatkan berat yang diketahui pada sel beban secara langsung, 100 gram (katakanlah).
• tekan Q, W, E, R untuk meningkatkan faktor kalibrasi masing-masing sebesar 10.100.1000.100.000.
• tekan A, S, D, F untuk mengurangi faktor kalibrasi masing-masing sebesar 10.100.1000.100.000.
• Tekan 'Enter' setelah setiap kenaikan atau penurunan faktor kalibrasi.
• Naikkan atau turunkan faktor kalibrasi sampai bobot yang benar dari bahan bobot yang diketahui muncul.
• Fungsi tara adalah untuk mengatur timbangan menjadi nol, ini berguna ketika Anda ingin mengukur berat air (katakanlah) tanpa berat mangkuk. Tempatkan mangkuk terlebih dahulu, tekan tara dan tuangkan air.
• Catat faktor kalibrasi dan tuliskan setelah bobot yang diketahui muncul.

Sekarang ini dapat mengukur bobot yang tidak diketahui.

Kode Program Pengukuran Berat:

//---------------- ----------------//
#include
const int out = 3
const int clck = 2
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
void setup()
{
Serial.begin(9600)
Serial.println('Press 'T' or 't' to tare')
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
Serial.print('Weight: ')
Serial.print(scale.get_units(), 3)
Serial.println(' Kilogram')
if (Serial.available())
{
char var = Serial.read()
if (var == 't')
{
scale.tare()
}
if (var == 'T')
{
scale.tare()
}
}
}
//---------------- ----------------//

float CalibrationFactor = -12000

Ganti -12000 dengan faktor kalibrasi yang Anda temukan. Ini bisa berupa angka negatif atau angka positif.

Unggah kode di atas dengan pengaturan perangkat keras lengkap Anda dan mesin timbangan berat Anda siap.

Mesin Skala Berat Menggunakan Layar LCD

Artikel diatas menjelaskan sistem timbangan berbasis Arduino menggunakan PC anda, pada bagian berikut ini kami akan mencoba membangun versi praktis dari mesin timbangan berat dengan menambahkan layar LCD 16 x 2, sehingga kami tidak bergantung pada PC saat mengukur bobot. Dalam posting ini dua versi diusulkan, satu dengan LCD “I2C” 16 x 2 dan satu tanpa layar LCD “I2C” 16 x 2.

Di sini dua pilihan diberikan sehingga pembaca dapat memilih desain sesuai keinginan mereka. Perbedaan utama antara keduanya adalah koneksi kabel dengan modul adaptor I2C hanya 4 kabel (Vcc, GND, SCL dan SDA) yang diperlukan untuk fungsi layar LCD, sedangkan tanpa adaptor I2C Anda memerlukan beberapa kabel untuk menghubungkan antara Arduino dan layar LCD.

Namun kedua fungsi tersebut persis sama, beberapa lebih memilih I2C daripada yang konvensional dan beberapa lebih memilih sebaliknya jadi inilah kedua desainnya.

Mari kita lihat desain LCD konvensional:

Diagram sirkuit:

Dalam skema di atas kami memiliki arduino, layar LCD 16 x 2 dan potensiometer 10K untuk menyesuaikan kontras layar LCD.

3,3 V dapat diumpankan dari Arduino ke layar LCD untuk lampu latar. Tombol tekan disediakan untuk membawa pembacaan bobot ke nol, fungsi ini akan dijelaskan secara rinci di bagian akhir.

Ini hanyalah hubungan antara LCD dan Arduino, hubungan antara load cell dan penguat load cell ke Arduino telah ditunjukkan pada bagian sebelumnya.

Kode untuk mesin Skala Berat LCD:

// -------- Program developed by R.GIRISH -------//
#include
#include
const int rs = 10
const int en = 9
const int d4 = 8
const int d5 = 7
const int d6 = 6
const int d7 = 5
LiquidCrystal lcd(rs, en, d4, d5, d6, d7)
const int out = 3
const int clck = 2
const int Tare = 4
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
void setup()
{
lcd.begin(16, 2)
pinMode(Tare, INPUT)
digitalWrite(Tare, HIGH)
lcd.setCursor(0, 0)
lcd.print(' Weight Scale')
lcd.setCursor(0, 1)
lcd.print(' Machine')
delay(2000)
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Weight:')
lcd.print(scale.get_units(), 3)
lcd.print(' Kg')
delay(200)
if (digitalRead(Tare) == LOW)
{
scale.tare()
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Tare ......')
lcd.setCursor(0, 1)
lcd.print('Setting to 0 Kg.')
delay(1000)
}
}
// -------- Program developed by R.GIRISH -------//

Sekarang mari kita lihat bagaimana menggunakan mesin timbangan berat ini dengan layar LCD berbasis adaptor I2C.

Diagram Sirkuit Arduino dan layar LCD dengan adaptor I2C:

Di sini kami hanya memiliki layar Arduino dan LCD dengan adaptor I2C di bagian belakang. Sekarang koneksi kabel disederhanakan dan lurus ke depan.

Ilustrasi modul I2C:

Modul ini dapat disolder langsung di bagian belakang layar LCD normal 16 x 2 atau bahkan 20 x 4 dan mengikuti diagram skema.

Dan sekali lagi silakan lihat bagian sebelumnya untuk koneksi load cell, penguat load cell dan Arduino.

Unduh Library berikut untuk berbasis I2C:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

Kode untuk rangkaian skala berat berbasis I2C:

// -------- Program developed by R.GIRISH -------//
#include
#include
#include
const int out = 3
const int clck = 2
const int Tare = 4
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
LiquidCrystal_I2C lcd(0x27, 16, 2)
void setup()
{
lcd.init()
lcd.backlight()
pinMode(Tare, INPUT)
digitalWrite(Tare, HIGH)
lcd.setCursor(0,0)
lcd.print(' Weight Scale')
lcd.setCursor(0,1)
lcd.print(' Machine')
delay(2000)
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Weight:')
lcd.print(scale.get_units(), 3)
lcd.print(' Kg')
delay(200)
if (digitalRead(Tare) == LOW)
{
scale.tare()
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Tare ......')
lcd.setCursor(0,1)
lcd.print('Setting to 0 Kg.')
delay(1000)
}
}
// -------- Program developed by R.GIRISH -------//

CATATAN:

Anda harus memasukkan faktor kalibrasi dalam kode sebelum Anda mengunggah salah satu kode ke Arduino.

float CalibrationFactor = -12000

Memperoleh faktor kalibrasi dijelaskan di salah satu bagian sebelumnya di atas.

Fungsi tara:

Fungsi tara dalam timbangan adalah untuk membawa hasil pembacaan menjadi nol. Misalnya jika kita memiliki keranjang tempat memuat barang, maka berat bersihnya adalah berat keranjang + berat barang.

Jika kita menekan tombol tara dengan keranjang pada load cell sebelum memuat barang maka berat keranjang akan terbengkalai dan kita bisa mengukur berat barangnya sendiri.

Jika Anda memiliki pertanyaan tentang rangkaian mesin timbangan LCD praktis berbasis Arduino ini, silakan ungkapkan di bagian komentar Anda mungkin mendapatkan balasan cepat.