Skala Penimbangan Digital Menggunakan Load Cell dan Arduino

Dalam catatan ini kita akan belajar mengenai sel beban berdasarkan regangan regangan. Kami akan meneroka apa itu Strain Gauge, apa itu Cell Cell, kesan suhu pada strain gauge, kompensasi suhu dengan Wheatstone bridge dan Load cell amplifier HX711, dan akhirnya kita akan belajar bagaimana membina mesin timbang berasaskan Arduino dengan menerapkan load cell sebagai pengukur berat.

Catatan ini membincangkan kaedah pengukuran dan pengukuran berat badan, dan pelaksanaan kaedah dalam litar timbangan berdasarkan Arduino.

Kita semua suka melihat berat badan kita tanpa mengira usia kita, kanak-kanak kecil mungkin suka melihat kenaikan berat badannya dan orang dewasa mungkin suka melihat penurunan berat badannya. Berat menjadi konsep penting sejak zaman kuno ini membantu dalam perdagangan barang, pengembangan peralatan saintifik dan produk komersial.

Pada zaman moden, kita mengukur berat dalam kilogram, miligram bahkan mikrogram untuk tujuan makmal. Satu gram sama di seluruh dunia, semua alat pengukur berat mesti sama. Pengambilan pil secara besar-besaran dengan sedikit perbezaan dari beberapa miligram dos sudah cukup untuk menjadikan pil penyelamat menjadi pil bunuh diri.

Berapakah Berat?

Berat adalah daya yang diberikan pada satah. Jumlah daya yang diberikan berkadar langsung dengan jisim objek, yang bermaksud semakin tinggi jisim objek, semakin tinggi daya yang diberikan.

Jisim adalah jumlah bahan fizikal yang terdapat dalam suatu objek.

Berat bergantung pada satu faktor lagi: Graviti.

Graviti tetap di seluruh dunia (Terdapat sedikit variasi graviti kerana bentuk bulatan bumi yang tidak seragam, tetapi sangat kecil). Berat 1Kg di bumi akan berat 160 gram di bulan dengan jisim yang sama, kerana bulan mempunyai tarikan graviti yang jauh lebih lemah.

Sekarang anda tahu apa itu berat dan apakah faktor-faktor yang menjadikan objek menjadi berat.

Apakah pengukur regangan:

Strain gauge adalah transduser atau sensor yang mengukur ketegangan (ubah bentuk) pada objek. Ini dicipta oleh jurutera elektrik Edward E. Simmons dan jurutera mekanikal Arthur Claude Ruge.

Ilustrasi Strain Gauge:

Strain gauge adalah fleksibel, ia adalah corak kerajang logam nipis yang diapit di antara dua kepingan plastik nipis dan harus dilekatkan pada permukaan menggunakan gam yang sesuai atau bahan pelekat.

Apabila kita menggunakan berat atau daya di permukaan ia berubah bentuk dan pengukur regangan juga berubah. Deformasi tolok regangan menyebabkan rintangan elektrik kerajang logam berubah.

Kini perubahan ketegangan pada rintangan berkadar terus dengan berat atau daya yang dikenakan di permukaan.

Dalam kehidupan nyata perubahan rintangan tolok regangan sangat tidak penting untuk dikesan. Untuk mengesan perubahan kecil dalam rintangan, kami menggunakan jambatan Wheatstone.

Mari kita terokai apa jambatan Wheatstone secara ringkas.

Memahami jambatan Wheatstone:

Jambatan batu gandum adalah litar yang dapat digunakan untuk menentukan rintangan yang tidak diketahui. Jambatan Wheatstone dirancang oleh Samuel Hunter Christie, kemudian jambatan Wheatstone diperbaiki dan disebarkan oleh Sir Charles

Batu Gandum.

Ilustrasi litar jambatan Wheatstone:

Multimeter digital moden kami dapat membaca nilai rintangan mulai dari julat mega ohm, kilo ohm dan ohm.

Dengan menggunakan jambatan batu gandum, kita dapat mengukur ketahanan dalam jarak milli ohm.

Jambatan batu gandum terdiri daripada 4 perintang, dari empat, 3 adalah rintangan yang diketahui dan satu rintangan yang tidak diketahui.

Perbezaan potensi (voltan) diterapkan pada titik 'A' dan 'C' dan dari titik 'B' dan 'D' voltmeter disambungkan.

Sekiranya semua perintang sama, arus tidak akan mengalir pada titik 'B' dan 'D' dan voltmeter akan membaca sifar. Ini dipanggil jambatan seimbang.

Sekiranya rintangan perintang berbeza dari tiga perintang lain, akan berlaku aliran voltan antara titik 'B' dan 'D' dan voltmeter akan membaca beberapa nilai yang berkadar dengan rintangan yang tidak diketahui. Ini dipanggil jambatan tidak seimbang.

Di sini rintangan yang tidak diketahui adalah pengukur regangan, apabila rintangan diubah, ia memantulkan pada voltmeter.

Sekarang, kami telah menukar ubah bentuk atau berat atau daya ke isyarat voltan. Voltan ini perlu dikuatkan untuk mendapatkan bacaan yang berguna, yang akan dimasukkan ke mikrokontroler untuk mendapatkan bacaan dalam gram.

Sekarang mari kita bincangkan bagaimana suhu mempengaruhi prestasi pengukur regangan.

Kesan suhu pada Strain Gauge:

Tolok regangan sensitif terhadap suhu dan boleh mengacaukan bacaan berat / kekuatan sebenar. Apabila terdapat perubahan suhu persekitaran, kerajang logam mengalami pengembangan logam, yang secara langsung mempengaruhi rintangan.

Kita dapat membatalkan kesan suhu menggunakan jambatan Wheatstone. Mari kita lihat bagaimana kita dapat mengimbangi suhu menggunakan jambatan Wheatstone.

Pampasan Suhu:

Kita boleh meneutralkan kesan suhu dengan mudah dengan mengganti semua perintang dengan tolok regangan. Sekarang semua rintangan tolok regangan akan dipengaruhi oleh suhu yang sama dan bunyi yang tidak diingini akan dibatalkan oleh watak jambatan Wheatstone.

Apa itu Cell Load?

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

Ilustrasi sel Beban:

Jenis sel beban ini kaku dan biasa digunakan di industri. Terdapat 4 pelekap skru, satu sisi dilekatkan ke permukaan pegun dan ujung yang lain dilekatkan pada pemegang (katakanlah bakul) untuk menahan objek yang hendak diukur.

Berat maksimum yang ditentukan pada lembar data atau badannya, melebihi spesifikasi boleh merosakkan sel beban.

Sel jambatan penuh terdiri daripada 4 terminal iaitu E +, E-, yang merupakan wayar pengujung di mana voltan bekalan digunakan. Dua wayar lain adalah S + dan S-, yang merupakan wayar isyarat, dari mana voltan diukur.

Sekarang voltan ini berada dalam julat milivolt tidak cukup kuat untuk mikrokontroler membaca dan memproses. Kita memerlukan penguatan dan perubahan kecil harus dilihat oleh mikrokontroler. Untuk melakukan ini terdapat modul khusus yang disebut penguat sel beban, mari kita ikhtisar mengenai perkara itu.

Muatkan sel Amplifier HX711:

Ilustrasi modul penguat sel HX711 Load:

Penguat sel beban didasarkan pada IC HX711 yang merupakan penukar analog ke digital 24-bit yang direka khusus untuk pengukuran berat badan. Ia mempunyai keuntungan 32, 64 dan 128 yang boleh dipilih dan beroperasi pada 2.6 hingga 5.5 V.
Papan pelarian ini membantu mengesan variasi kecil pada sel beban. Modul ini memerlukan perpustakaan HX711.h untuk beroperasi

Arduino atau pengawal mikro lain.

Sel beban akan disambungkan ke modul HX711 dan modul akan dihubungkan dengan Arduino. Litar pengukur berat perlu dikembangkan dengan cara ini.

Sebagai kesimpulan, sekarang anda tahu apa itu strain gauge, apa itu Wheatstone bridge, kesan suhu pada strain gauge, pampasan suhu dan apa itu load cell amplifier.

Kami telah memahami secara komprehensif bahagian teori dari reka bentuk skala penimbang dari perbincangan di atas, sekarang mari kita lihat bagaimana sel loas dapat digunakan untuk membuat mesin skala penimbangan pratikal menggunakan Arduino

Merancang Mesin Skala Berat Digital menggunakan Arduino

Dalam perbincangan berikut, kita akan belajar bagaimana membuat mesin skala berat digital menggunakan Arduino yang dapat mengukur berat dari beberapa gram hingga 40 Kg (bergantung pada spesifikasi sel muatan anda) dengan ketepatan yang wajar. Kami akan belajar mengenai klasifikasi sel beban gred ketepatan dan kami akan menentukur litar yang dicadangkan dan menyelesaikan mesin skala berat.

Catatan: Litar ini mungkin tidak sesuai dengan standard yang diperlukan untuk pelaksanaan komersial.

Mesin skala berat digunakan dalam pelbagai jenis perdagangan dan penyelidikan mulai dari miligram hingga beberapa ton. Skala maksimum mesin skala berat yang dicadangkan bergantung pada spesifikasi sel muatan anda. Terdapat antara 500 gram, 1 Kg, 5Kg, 10 Kg, 20 Kg dan 40 Kg dll.

Terdapat pelbagai jenis sel beban, mereka menawarkan julat ketepatan yang berbeza dan anda harus memilih yang sesuai untuk projek anda.

Klasifikasi Kelas Ketepatan sel beban:

Kelas ketepatan yang berbeza ditentukan untuk pelbagai jenis aplikasi. Pengelasan di bawah adalah dari julat ketepatan terendah hingga ketepatan tertinggi.

Sel beban dengan ketepatan yang lebih rendah (tetapi cukup tepat) diklasifikasikan sebagai D1, C1 dan C2. Ini cukup untuk projek ini. Sel beban ini digunakan untuk mengukur berat pasir, simen atau air.

Sel beban gred C3 digunakan dalam jaminan kualiti seperti memeriksa berat galas bebola, bahagian pembinaan mesin dll.

C4, C5, C6 adalah yang terbaik dalam ketepatan kelas, gred sel beban ini digunakan untuk mengukur dalam gram hingga mikrogram. Kelas kelas ini digunakan dalam skala kaunter kedai, pemantauan pengeluaran skala besar, pembungkusan makanan dan penggunaan makmal dll.

Sekarang mari kita selami butiran teknikal projek.

Rajah Litar:

Muatkan sambungan sel HX711 ke Arduino dan sel beban.

Projek ini terdiri daripada papan penguat sel beban Arduino, Load cell dan HX711 dan komputer. Keluarannya dapat dipantau pada monitor Serial Arduino IDE.

Otak projek adalah seperti biasa arduino, anda boleh menggunakan model papan Arduino apa pun. HX711 adalah ADC 24 bit, yang dapat menghasilkan kelenturan terkecil kerana berat pada sel beban. Ia boleh beroperasi dari 2.7 V hingga 5 V. Kuasa diberikan dari papan Arduino.

Sel beban mempunyai empat wayar secara amnya, yang merupakan output dari pengukur regangan dikonfigurasi jambatan Wheatstone.

Kawat Merah adalah E +, wayar hitam adalah E-, wayar hijau adalah A- dan wayar putih adalah A +. Beberapa modul HX711 menentukan nama terminal sel beban dan beberapa modul HX711 menentukan warna wayar, model sedemikian digambarkan dalam rajah litar.

Pin DATA HX711 disambungkan ke pin # 3 Arduino dan pin Jam HX711 disambungkan ke pin # 2 dari Arduino.

Cara Memasang Sel Beban:

Sel beban mempunyai empat lubang skru, dua di kedua sisi. Mana-mana satu sisi mesti pegun untuk ketepatan yang terbaik, ia boleh ditebang ke kayu dengan berat yang munasabah.

Kayu nipis atau plat nipis boleh digunakan untuk menahan berat pengukur seperti yang digambarkan di atas.

Oleh itu, apabila anda meletakkan berat badan, sel beban membengkokkan begitu juga pengukur regangan dan mengubah rintangannya yang diukur oleh modul HX711 dan diberi makan ke Arduino.

Setelah persediaan perkakasan selesai, mari muat naik kod dan kalibrasi.

Menentukur litar:

Terdapat dua program satu adalah program penentukuran (mencari faktor penentukuran). Kod lain adalah program pengukuran berat badan, faktor penentukuran yang dijumpai dari kod program penentukuran perlu dimasukkan dalam program pengukuran berat badan.

Faktor penentukuran menentukan ketepatan pengukuran berat.

Muat turun perpustakaan HX711 di sini: github.com/bogde/HX711

Kod 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()
}
}
}
//-------------------- --------------------//

Cara Mengkalibrasi:

• Dengan persediaan perkakasan yang lengkap, muat naik kod di atas.
• Tanggalkan pinggan nipis atau kayu yang digunakan untuk menahan berat termasuk kedua-dua skru (sisi lain dari sel beban harus dipasang ke dasar)
• Buka monitor Serial.
• Letakkan berat yang diketahui pada sel beban secara langsung, 100 gram (katakanlah).
• Tekan Q, W, E, R untuk meningkatkan faktor penentukuran masing-masing sebanyak 10,100,1000,10000.
• Tekan A, S, D, F untuk mengurangkan faktor penentukuran masing-masing sebanyak 10,100,1000,10000.
• Tekan 'Enter' setelah setiap kenaikan atau pengurangan faktor penentukuran.
• Menambah atau menurunkan faktor penentukuran sehingga berat bahan berat yang diketahui muncul.
• Fungsi tare adalah menetapkan skala berat ke sifar, ini berguna ketika anda ingin mengukur berat air (katakanlah) tanpa berat mangkuk. Letakkan mangkuk terlebih dahulu, tekan tare dan tuangkan air.
• Perhatikan faktor penentukuran dan tuliskan setelah berat tahu muncul.

Kini ia dapat mengukur berat yang tidak diketahui.

Kod 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()
}
}
}
//---------------- ----------------//

terapung CalibrationFactor = -12000

Ganti -12000 dengan faktor penentukuran yang anda dapati. Ia boleh menjadi nombor negatif atau nombor positif.

Muat naik kod di atas dengan persediaan perkakasan penuh anda dan mesin skala berat anda sudah siap.

Mesin Skala Berat Menggunakan Paparan LCD

Artikel di atas menjelaskan sistem timbangan berdasarkan Arduino menggunakan PC anda, di bahagian berikut ini kami akan berusaha membina versi praktikal mesin skala Berat dengan menambahkan paparan LCD 16 x 2, sehingga kami tidak bergantung pada PC sambil mengukur berat. Dalam catatan ini dua versi dicadangkan, satu dengan 'I2C' 16 x 2 LCD dan satu tanpa 'I2C' 16 x 2 paparan LCD.

Di sini dua pilihan diberikan agar pembaca dapat memilih reka bentuk mengikut kesesuaian mereka. Perbezaan utama antara keduanya adalah sambungan wayar dengan modul penyesuai I2C hanya 4 wayar (Vcc, GND, SCL dan SDA) yang diperlukan untuk fungsi paparan LCD, sedangkan tanpa penyesuai I2C anda memerlukan beberapa wayar untuk menghubungkan antara paparan Arduino dan LCD.

Walau bagaimanapun, kedua-duanya berfungsi sama, lebih suka I2C berbanding yang konvensional dan ada yang lebih suka sebaliknya jadi inilah kedua reka bentuknya.

Mari kita lihat reka bentuk LCD konvensional:

Gambarajah litar:

Dalam skema di atas kita mempunyai arduino, paparan LCD 16 x 2 dan potensiometer 10K untuk menyesuaikan kontras paparan LCD.

3.3 V boleh disalurkan dari Arduino ke paparan LCD untuk lampu latar. Butang tekan disediakan untuk menjadikan bacaan berat menjadi sifar, fungsi ini akan dijelaskan secara terperinci pada akhir.

Ini hanya hubungan antara LCD dan Arduino, hubungan antara sel beban dan penguat sel beban ke Arduino ditunjukkan di bahagian sebelumnya.

Kod 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 skala berat ini dengan paparan LCD berasaskan penyesuai I2C.

Circuit Diagram Arduino dan paparan LCD dengan penyesuai I2C:

Di sini kita hanya mempunyai paparan Arduino dan LCD dengan penyesuai I2C di bahagian belakang. Kini sambungan wayar dipermudahkan dan lurus ke hadapan.

Ilustrasi modul I2C:

Modul ini boleh disolder secara langsung di bahagian belakang paparan LCD 16 x 2 biasa atau bahkan 20 x 4 dan ikuti rajah skematik.

Dan sekali lagi sila rujuk bahagian sebelumnya untuk sambungan sel beban, penguat sel beban dan Arduino.

Muat turun Perpustakaan berikut untuk I2C berdasarkan:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

Kod untuk litar skala Berat berdasarkan 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 penentukuran dalam kod sebelum memuat naik salah satu kod tersebut ke Arduino.

terapung CalibrationFactor = -12000

Mendapatkan faktor penentukuran dijelaskan dalam bahagian sebelumnya di atas.

Fungsi tare:

Fungsi tare dalam skala berat adalah menjadikan bacaan menjadi sifar. Contohnya jika kita mempunyai bakul di mana barang dimuat, maka berat bersih adalah berat bakul + berat barang.

Sekiranya kita menekan butang tare dengan bakul di sel muatan sebelum memuat barang, berat bakul akan diabaikan dan kita dapat mengukur berat barang saja.

Sekiranya anda mempunyai pertanyaan mengenai litar mesin skala penimbang LCD praktikal Arduino ini, sila nyatakan di bahagian komen anda mungkin mendapat balasan cepat.