Scală de cântărire digitală utilizând celula de încărcare și Arduino

În acest post vom învăța despre celula de încărcare bazată pe manometru. Vom explora ce este Strain Gauge, ce este celula de încărcare, efectul temperaturii asupra tensometrului, compensarea temperaturii cu punte Wheatstone și amplificatorul de celule de încărcare HX711 și, în cele din urmă, vom învăța cum să construim o mașină de cântărit pe bază de Arduino, implementând senzorul de greutate.

Această postare tratează măsurarea greutății și metodele de măsurare și implementarea metodelor într-un circuit de cântărire bazat pe Arduino.

Cu toții ne place să ne vedem greutatea, indiferent de vârsta noastră, unui copil mic îi place să-și vadă creșterea în greutate, iar adulților le place să vadă pierderea în greutate. Greutatea este un concept vital, deoarece din cele mai vechi timpuri a contribuit la comerțul cu mărfuri, la dezvoltarea de echipamente științifice și produse comerciale.

În timpurile moderne, măsurăm greutăți în kilograme, miligrame chiar micrograme în scop de laborator. Un gram este același pe tot globul, toate dispozitivele de măsurare a greutății trebuie să măsoare la fel. Producția în masă a unei pilule cu o diferență minusculă de câteva miligrame de dozare este suficientă pentru a face o pastilă de salvare a vieții într-o pastilă de sinucidere.

Ce este Greutatea?

Greutatea este forța exercitată asupra unui plan. Cantitatea de forță exercitată este direct proporțională cu masa unui obiect, ceea ce înseamnă că masa obiectului este mai mare, cu atât este mai mare forța exercitată.

Masa este cantitatea de materie fizică prezentă într-un obiect.

Greutatea depinde de încă un factor: gravitația.

Gravitația este constantă pe tot globul (există variații minore ale gravitației datorită formei sferice neuniforme a pământului, dar este foarte mică). Greutatea de 1 kg pe pământ va cântări 160 de grame pe lună cu exact aceeași masă, deoarece luna are o atracție gravitațională mult mai slabă.

Acum știi ce este greutatea și care sunt factorii care fac un obiect greu.

Ce este gabaritul de tensiune:

Manometrul este un traductor sau un senzor care măsoară tensiunea (deformarea) pe un obiect. Aceasta a fost inventată de inginerul electric Edward E. Simmons și de inginerul mecanic Arthur Claude Ruge.

Ilustrația indicatorului de tensiune:

Dispozitivul de deformare este flexibil, este un model subțire de folie metalică inserat între două foi subțiri de plastic și trebuie atașat pe o suprafață folosind adeziv adecvat sau orice material adeziv.

Când aplicăm greutate sau forță pe suprafață, acesta se deformează, iar deformatorul se deformează și el. Deformarea manometrului determină modificarea rezistenței electrice a foliei metalice.

Acum, modificarea rezistenței indicatorului de tensiune este direct proporțională cu greutatea sau forța aplicată pe suprafață.

În viața reală, schimbarea rezistenței tensometrului este foarte nesemnificativă de detectat. Pentru a detecta mici modificări ale rezistenței, utilizăm podul Wheatstone.

Să explorăm ce este podul Wheatstone pe scurt.

Înțelegerea unui pod Wheatstone:

Un pod de piatră de grâu este un circuit care poate fi utilizat pentru determinarea rezistenței necunoscute. Podul Wheatstone a fost conceput de Samuel Hunter Christie, ulterior podul Wheatstone a fost îmbunătățit și difuzat de Sir Charles

Wheatstone.

Ilustrarea circuitului podului Wheatstone:

Multimetrele noastre digitale moderne pot citi valoarea rezistenței variind de la mega ohmi, kilo ohmi și gama ohmi.

Folosind puntea de piatră de grâu putem măsura rezistența în intervalul de mili ohmi.

Puntea de piatră de grâu este formată din 4 rezistențe, dintre cele patru, 3 sunt rezistențe cunoscute și unul este rezistență necunoscută.

Diferența de potențial (tensiune) se aplică punctelor „A” și „C”, iar din punctele „B” și „D” este conectat un voltmetru.

Dacă toate rezistențele sunt egale, nu va curge curent în punctele „B” și „D”, iar voltmetrul va citi zero. Aceasta se numește pod echilibrat.

Dacă rezistența unui rezistor este diferită de alte trei rezistențe, va exista un flux de tensiune între punctele „B” și „D”, iar voltmetrul va citi o anumită valoare proporțională cu rezistența necunoscută. Aceasta se numește pod dezechilibrat.

Aici rezistența necunoscută este tensometrul, atunci când rezistența este schimbată, aceasta se reflectă pe voltmetru.

Acum, am transformat o deformare sau greutate sau forță în semnal de tensiune. Această tensiune trebuie amplificată pentru a obține câteva citiri utile, care vor fi alimentate către un microcontroler pentru a obține citirile în grame.

Acum, să discutăm despre modul în care temperatura afectează performanțele manometrelor.

Efecte ale temperaturii asupra indicatorului de tensiune:

Dispozitivul de măsurare a tensiunii este sensibil la temperatură și se poate deranja cu valorile reale ale greutății / forței. Când există o modificare a temperaturii ambiante, folia metalică este supusă expansiunii metalice, ceea ce afectează direct rezistența.

Putem anula efectul temperaturii folosind podul Wheatstone. Să vedem cum putem compensa temperatura folosind podul Wheatstone.

Compensarea temperaturii:

Putem neutraliza cu ușurință efectul de temperatură prin înlocuirea tuturor rezistențelor cu manometru. Acum, toată rezistența manometrului va fi afectată de temperatură în mod egal, iar zgomotul nedorit va fi anulat de caracterul podului Wheatstone.

Ce este o celulă de încărcare?

O celulă de încărcare este un profil din aluminiu cu manometru atașat pe 4 laturi în configurația podului Wheatstone.

Ilustrarea celulei de încărcare:

Acest tip de celulă de încărcare este rigidă și este utilizată în mod obișnuit în industrii. Există 4 suporturi cu șurub, o parte este înșurubată pe o suprafață staționară, iar cealaltă extremitate este înșurubată pe un suport (să spunem coș) pentru a ține obiectul de măsurat.

Are greutatea maximă specificată pe foaia tehnică sau pe corpul său, depășirea specificațiilor ar putea deteriora celula de încărcare.

O celulă punte completă este formată din 4 terminale și anume E +, E-, care sunt fire de excitație prin care se aplică tensiunea de alimentare. Celelalte două fire sunt S + și S-, care sunt fire de semnal, de la care se măsoară tensiunea.

Acum, aceste tensiuni sunt în domeniul milivolților, nu suficient de puternic pentru ca un microcontroler să poată fi citit și procesat. Avem nevoie de amplificare și mici modificări ar trebui să fie vizibile pentru microcontroler. Pentru a face acest lucru, există un modul dedicat numit amplificatoare cu celule de încărcare, să facem o prezentare generală a acestui aspect.

Amplificator de celule de încărcare HX711:

Ilustrarea modulului amplificatorului de celule de încărcare HX711:

Amplificatorul cu celule de încărcare se bazează pe IC HX711, care este un convertor analogic digital pe 24 de biți conceput special pentru măsurarea greutății. Are câștiguri selectabile diferite 32, 64 și 128 și funcționează între 2,6 și 5,5 V.
Această placă de separare ajută la detectarea variațiilor minuscule ale celulei de încărcare. Acest modul necesită biblioteca HX711.h pentru a funcționa

Arduino sau orice alt microcontroler.

Celula de încărcare va fi conectată la modulul HX711 și modulul va fi interfațat cu Arduino. Circuitul de măsurare a greutății trebuie dezvoltat în acest mod.

În concluzie, acum știți ce este tensometrul, ce este puntea Wheatstone, efectele temperaturii asupra tensometrului, compensarea temperaturii și ce este amplificatorul celulei de sarcină.

Am înțeles în mod cuprinzător partea teoretică a proiectării unei cântare de cântărire din discuția de mai sus, acum să vedem cum poate fi folosită o celulă loas pentru a face o mașină de cântărire practică folosind Arduino

Proiectarea unei mașini digitale de cântărire folosind Arduino

În discuțiile următoare vom învăța cum să construim o mașină digitală de măsurare a greutății folosind Arduino, care poate măsura greutăți de la câteva grame la 40 kg (în funcție de specificațiile celulei dvs. de încărcare) cu o precizie rezonabilă. Vom învăța despre clasificarea celulelor de sarcină de precizie și vom calibra circuitul propus și vom finaliza mașina de scară a greutății.

Notă: Este posibil ca acest circuit să nu fie conform cu standardele necesare pentru implementarea comercială.

Mașinile de cântărit sunt utilizate în diferite varietăți de meserii și cercetări, de la miligrame la câteva tone. Scara maximă a mașinii de cântărit propusă depinde de specificațiile celulei de încărcare. Există intervale de la 500 grame, 1 kg, 5 kg, 10 kg, 20 kg și 40 kg etc.

Există diferite grade de celule de încărcare, acestea oferă o gamă de precizie diferită și ar trebui să o alegeți pe cea potrivită pentru proiectul dvs.

Clasificarea clasei de precizie a celulei de încărcare:

Diferitele clase de precizie sunt definite pentru diferite tipuri de aplicații. Clasificarea de mai jos este de la cea mai mică precizie la cea mai mare gamă de precizie.

Celulele de sarcină cu o precizie mai mică (dar rezonabilă) sunt clasificate ca D1, C1 și C2. Acest lucru este suficient pentru acest proiect. Aceste celule de sarcină sunt utilizate pentru măsurarea greutății nisipului, cimentului sau apei.

Celulele de sarcină de calitate C3 sunt utilizate în asigurarea calității, cum ar fi verificarea greutății rulmenților cu bile, a pieselor de construcții ale mașinilor etc.

C4, C5, C6 sunt cele mai bune acuratețe din clasă, aceste grade de celule de sarcină sunt utilizate pentru a măsura în grame până la micrograme. Aceste clase de clasă sunt folosite în cântarele de birou, la monitorizarea producției la scară largă, la ambalarea alimentelor și la utilizarea în laborator etc.

Acum să ne aruncăm în detaliile tehnice ale proiectului.

Diagrama circuitului:

Încărcați conexiunea celulei HX711 la Arduino și încărcați celula.

Proiectul constă din placa de amplificare Arduino, Load cell și HX711 și un computer. Ieșirea poate fi monitorizată pe monitorul serial al Arduino IDE.

Creierul proiectului este ca întotdeauna arduino, puteți utiliza orice model de placă Arduino. HX711 este ADC pe 24 de biți, care poate găsi cea mai mică flexibilitate datorită greutății pe celula de încărcare. Poate funcționa de la 2,7 V la 5 V. Puterea este furnizată de pe placa Arduino.

Celula de încărcare are, în general, patru fire, care este ieșirea din manometrul configurat al podului Wheatstone.

Firul roșu este E +, firul negru este E-, firul verde este A- și firul alb este A +. Unele module HX711 specifică numele terminalelor celulei de încărcare, iar unele module HX711 specifică culorile firelor, un astfel de model este ilustrat în diagrama circuitului.

Pinul DATA al HX711 este conectat la pinul 3 al Arduino, iar pinul de ceas al HX711 este conectat la pinul 2 al Arduino.

Cum se montează celula de încărcare:

Celula de încărcare are patru găuri pentru șuruburi, două pe ambele părți. Oricare dintre părți trebuie să fie staționară pentru o precizie maximă, poate fi îngrămădită pe un lemn cu o greutate rezonabilă.

Pentru a menține greutatea de măsurare, se poate folosi o lemn subțire sau o placă subțire, așa cum este ilustrat mai sus.

Deci, atunci când plasați o greutate, îndoirea celulei de sarcină la fel face tensometrul și își schimbă rezistența, care este măsurată de modulul HX711 și alimentată către Arduino.

După finalizarea configurării hardware, să încărcăm codul și să îl calibrăm.

Calibrarea circuitului:

Există două programe, unul este programul de calibrare (găsirea factorului de calibrare). Un alt cod este programul de măsurare a greutății, factorul de calibrare găsit în codul programului de calibrare trebuie introdus în programul de măsurare a greutății.

Factorul de calibrare determină acuratețea măsurării greutății.

Descărcați biblioteca HX711 aici: github.com/bogde/HX711

Codul programului de calibrări:

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

Cum se calibrează:

• Odată cu configurarea hardware finalizată, încărcați codul de mai sus.
• Îndepărtați placa subțire sau lemnul care este utilizat pentru a ține greutatea, inclusiv cele două șuruburi (cealaltă parte a celulei de încărcare trebuie fixată pe o bază)
• Deschideți monitorul serial.
• Plasați o greutate cunoscută direct pe celula de încărcare, 100 de grame (să zicem).
• presa Q, W, E, R pentru a crește factorul de calibrare cu 10,100,1000,10000, respectiv.
• presa A, S, D, F pentru a reduce factorul de calibrare cu 10,100,1000,10000, respectiv.
• Apăsați „Enter” după fiecare creștere sau scădere a factorului de calibrare.
• Măriți sau micșorați factorul de calibrare până când apare greutatea corectă a materialului cunoscut.
• Funcția Tare este de a seta greutatea la zero, acest lucru este util atunci când doriți să măsurați greutatea apei (să zicem) fără greutatea bolului. Așezați mai întâi vasul, apăsați tara și turnați apa.
• Rețineți factorul de calibrare și notați-l după ce apare greutatea cunoscută.

Acum poate măsura greutăți necunoscute.

Codul programului de măsurare a greutății:

//---------------- ----------------//
#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

Înlocuiți -12000 cu factorul de calibrare pe care l-ați găsit. Poate fi un număr negativ sau un număr pozitiv.

Încărcați codul de mai sus cu setarea completă a hardware-ului și aparatul dvs. de cântărire este gata.

Aparat de măsurat greutatea utilizând ecran LCD

Articolul de mai sus a explicat un sistem de cântărire bazat pe Arduino care utilizează computerul dvs., în secțiunea următoare vom încerca să construim o versiune practică a mașinii de cântărit prin adăugarea unui ecran LCD de 16 x 2, astfel încât să nu depindem de un PC în timpul măsurării greutăți. În acest post sunt propuse două versiuni, una cu „I2C” 16 x 2 LCD și una fără afișaj „I2C” 16 x 2 LCD.

Aici sunt oferite două opțiuni, astfel încât cititorii să poată alege designul după cum le convine. Principala diferență dintre cele două este conexiunile prin cablu cu modulul adaptor I2C doar 4 fire (Vcc, GND, SCL și SDA) sunt necesare pentru funcționarea afișajului LCD, în timp ce fără adaptor I2C aveți nevoie de mai multe fire pentru a vă conecta între ecranul Arduino și ecranul LCD.

Cu toate acestea, ambele funcții exact la fel, unii preferă I2C față de una convențională, iar unii preferă invers, așa că iată ambele modele.

Să analizăm designul LCD convențional:

Diagrama circuitului:

În schema de mai sus avem arduino, afișaj LCD de 16 x 2 și potențiometru de 10K pentru ajustarea contrastului afișajului LCD.

3,3 V pot fi alimentate de la Arduino la afișajul LCD pentru iluminare de fundal. Este furnizat un buton pentru a aduce citirea greutății la zero, această funcție va fi explicată în detaliu la sfârșit.

Aceasta este doar o conexiune între LCD și Arduino, conexiunea dintre celula de încărcare și amplificatorul de celule de încărcare la Arduino este prezentată în secțiunea anterioară.

Cod pentru aparatul de măsurare a greutății 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 -------//

Acum, să vedem cum să utilizați această mașină de cântărit cu afișaj LCD bazat pe adaptor I2C.

Schema circuitului Arduino și afișaj LCD cu adaptor I2C:

Aici avem doar un ecran Arduino și LCD cu adaptor I2C pe spate. Acum conexiunile prin cablu sunt simplificate și directe.

Ilustrarea modulului I2C:

Acest modul poate fi lipit direct pe spatele unui ecran LCD normal de 16 x 2 sau chiar de 20 x 4 și urmați schema.

Și, din nou, vă rugăm să consultați secțiunea anterioară pentru conectarea celulei de încărcare, a amplificatorului de celule de încărcare și a Arduino.

Descărcați următoarea bibliotecă pentru I2C:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

Cod pentru circuitul scalei de greutate bazat pe 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 -------//

NOTĂ:

Ar trebui să introduceți factorul de calibrare în cod înainte de a încărca oricare dintre coduri în Arduino.

float CalibrationFactor = -12000

Obținerea factorului de calibrare este explicată într-o secțiune anterioară de mai sus.

Tare function:

Funcția de tară într-o scală de greutate este de a aduce citirile la zero. De exemplu, dacă avem un coș în care mărfurile sunt încărcate, atunci greutatea netă va fi greutatea coșului + greutatea bunurilor.

Dacă apăsăm butonul de tare cu coș pe celula de încărcare înainte de încărcarea mărfurilor, greutatea coșului va fi neglijată și putem măsura greutatea mărfurilor singuri.

Dacă aveți întrebări cu privire la acest circuit practic al mașinii de cântărit LCD pe bază de Arduino, vă rugăm să exprimați în secțiunea de comentarii, puteți primi un răspuns rapid.