Digitaalne kaalumisseade koormusanduri ja Arduino abil

Selles postituses õpime tundemõõturil põhinevat koormusandurit. Uurime, mis on tüvemõõtur, mis on koormusandur, temperatuuri mõju tüvemõõturile, temperatuuri kompenseerimine Wheatstone'i silla ja koormuselemendi võimendi HX711 abil ning lõpuks õpime ehitama Arduino-põhist kaalumisseadet, rakendades koormusandurit kui kaaluandur.

See postitus käsitleb kaalu mõõtmist ja mõõtmismeetodeid ning meetodite rakendamist Arduino põhises kaalumisskeemis.

Me kõik armastame oma kaalu näha olenemata vanusest, väikesele lapsele võib meeldida tema kehakaalu tõus ja täiskasvanutele tema kaalulangus. Kaal on iidsetest aegadest alates olnud oluline mõiste, mis aitas kaasa kaupade kauplemisel, teadusseadmete ja kaubanduslike toodete väljatöötamisel.

Moodsal ajal mõõdame kaalu laboratoorselt kilogrammides, milligrammides isegi mikrogrammides. Üks gramm on kogu maailmas ühesugune, kõik kaalu mõõtmise seadmed peavad mõõtma sama. Pillide masstoodang, mille erinevus on väike, milligrammide annus on piisav, et muuta elupäästev pill enesetapupilliks.

Mis on kaal?

Kaal on lennukile avaldatav jõud. Rakendatud jõu suurus on otseselt proportsionaalne objekti massiga, mis tähendab, et objekti suurem mass on seda suurem.

Mass on objektis oleva füüsilise aine kogus.

Kaal sõltub veel ühest tegurist: raskusjõud.

Raskusjõud on kogu maakeral konstantne (Maa ebaühtlase sfäärilise kuju tõttu on gravitatsioonis vähe variatsioone, kuid see on väga väike). 1 kg kaal maa peal kaalub täpselt sama massiga Kuul 160 grammi, kuna Kuul on raskem tõmbejõud.

Nüüd teate, mis on kaal ja millised tegurid muudavad eseme raskeks.

Mis on tüvemõõtur:

Pingutusmõõtur on muundur või andur, mis mõõdab objekti pinget (deformatsiooni). Selle leiutasid elektriinsener Edward E. Simmons ja mehaanikainsener Arthur Claude Ruge.

Tüvemõõtja illustratsioon:

Pingutusmõõtur on paindlik - see on õhuke metallfooliummuster, mis on asetatud kahe õhukese plastiklehe vahele ja mis tuleb kinnitada pinnale sobiva liimi või mis tahes liimainega.

Kui rakendame pinnale raskust või jõudu, siis see deformeerub ja ka deformatsioonimõõtur deformeerub. Pingutusmõõturi deformatsioon põhjustab metallfooliumi elektritakistuse muutumist.

Nüüd on pingemõõturi takistuse muutus otseselt proportsionaalne kaalu või pinnale rakendatud jõuga.

Tegelikus elus on pingemõõturi vastupanuvõime muutus tuvastamiseks väga ebaoluline. Väikeste resistentsuse muutuste tuvastamiseks kasutame Wheatstone'i silda.

Uurime, mis on Wheatstone'i sild lühidalt.

Wheatstone'i silla mõistmine:

Nisukivist sild on vooluring, mida saab kasutada tundmatu takistuse määramiseks. Wheatstone'i silla mõtles välja Samuel Hunter Christie, hiljem Wheatstone'i silda parandas ja levitas Sir Charles

Nisukivi.

Wheatstone'i silla vooluringi illustratsioon:

Meie kaasaegsed digitaalsed multimeetrid suudavad lugeda takistuse väärtust, mis ulatub megaomi, kilo oomi ja oomi vahemikku.

Nisukivisilla abil saame mõõta takistust millioomi piirides.

Nisukivisild koosneb neljast takistist, neist neljast on teada 3 ja üks tundmatu takistus.

Potentsiaalide erinevus (pinge) rakendatakse punktidele “A” ja “C” ning punktidest “B” ja “D” on ühendatud voltmeeter.

Kui kõik takistid on võrdsed, ei voola punktides “B” ja “D” voolutugevust ning voltmeeter loeb nulli. Seda nimetatakse tasakaalustatud sillaks.

Kui takisti takistus erineb ülejäänud kolmest takisti, tekib punktide B ja D vahel pingevool ja voltmeeter loeb mingit väärtust, mis on proportsionaalne tundmatu takistusega. Seda nimetatakse tasakaalustamata sillaks.

Siin on tundmatu takistus deformatsioonimõõtur, kui takistust muudetakse, peegeldub see voltmeeteril.

Nüüd oleme deformatsiooni või kaalu või jõu teisendanud pingesignaaliks. Seda kasulikku näitu saamiseks tuleb seda pinget võimendada, mis suunatakse mikrokontrollerile, et saada näiteid grammides.

Nüüd arutame, kuidas temperatuur mõjutab pingemõõturi jõudlust.

Temperatuuri mõju koormusmõõturile:

Pingutusmõõtur on temperatuuritundlik ja see võib segi ajada tegeliku kaalu / jõu näitudega. Kui toimub ümbritseva õhu temperatuuri muutus, laieneb metallkile metallile, mis mõjutab otseselt takistust.

Temperatuuri efekti saame nullida Wheatstone'i silla abil. Vaatame, kuidas saame Wheatstone'i silla abil temperatuuri kompenseerida.

Temperatuuri kompenseerimine:

Temperatuuri efekti saame kergesti neutraliseerida, asendades kõik takistid pingemõõturiga. Nüüd mõjutab temperatuur ühtlaselt kogu deformatsioonimõõturi takistust ja Wheatstone'i silla olemus nullib soovimatu müra.

Mis on koormusandur?

Koormusandur on alumiiniumprofiil, mille neljale küljele on kinnitatud koormusmõõtur Wheatstone'i silla konfiguratsioonis.

Koormusanduri illustratsioon:

Seda tüüpi koormusandurid on jäigad ja neid kasutatakse tööstuses tavaliselt. Kruvikinnitusi on 4, üks külg on kinnitatud statsionaarsele pinnale ja teine ​​ots on kinnitatud hoidiku (näiteks korvi) külge, et mõõdetavat eset hoida.

Selle maksimaalne kaal on määratud andmelehel või selle kerel, mille ületamine võib koormusandurit kahjustada.

Täissilla elemendid koosnevad neljast terminalist, nimelt E +, E-, mis on ergutusjuhtmed, mille kaudu rakendatakse toitepinget. Kaks ülejäänud juhet on S + ja S-, mis on signaaltraadid, millest mõõdetakse pinget.

Nüüd on need pinged millivolti vahemikus, mis pole mikrokontrolleri lugemiseks ja töötlemiseks piisavalt tugev. Vajame võimendust ja mikrokontrolleril peaksid olema nähtavad pisikesed muudatused. Selleks on spetsiaalne moodul, mida nimetatakse koormusanduri võimenditeks, võtame sellest ülevaate.

Koormusanduri võimendi HX711:

HX711 koormusanduri võimendi mooduli illustratsioon:

Koormusanduri võimendi põhineb IC HX711-l, mis on 24-bitine analoog-digitaalne muundur, mis on spetsiaalselt loodud kaalu mõõtmiseks. Sellel on erinevad valitavad võimendused 32, 64 ja 128 ning see töötab 2,6 kuni 5,5 V.
See läbimurdelaud aitab tuvastada koormusanduri väikseid erinevusi. Selle mooduli kasutamiseks on vaja teeki HX711.h

Arduino või mõni muu mikrokontroller.

Koormusandur ühendatakse HX711 mooduliga ja moodul liidetakse Arduinoga. Kaalu mõõtmise vooluring tuleb välja töötada sellisel viisil.

Kokkuvõtteks võib öelda, et nüüd teate, mis on deformatsioonimõõtur, mis on Wheatstone'i sild, temperatuuri mõju deformatsioonimõõturile, temperatuuri kompenseerimine ja milline on koormusanduri võimendi.

Oleme ülaltoodud arutelust põhjalikult aru saanud kaalumisskaala kujunduse teoreetilisest osast, nüüd vaatame, kuidas loasirakku saab kasutada praktilise kaalumisseadme valmistamiseks Arduino abil

Digitaalse kaalumisseadme kujundamine Arduino abil

Järgmistes aruteludes õpime, kuidas Arduino abil ehitada digitaalkaalumasinat, mis suudab mõistliku täpsusega mõõta kaalu mõnest grammist kuni 40 kg (sõltuvalt teie koormusanduri spetsifikatsioonidest). Õpime täpsusastme koormusandurite klassifitseerimise kohta, kalibreerime kavandatud vooluringi ja viime lõpule kaalumass.

Märkus. See vooluring ei pruugi vastata kaubanduslikuks rakendamiseks vajalikele standarditele.

Kaalumasinaid kasutatakse erinevates ametites ja uuringutes alates milligrammidest kuni mitme tonnini. Kavandatud massi skaala masina maksimaalne skaala sõltub teie koormusanduri spetsifikatsioonist. Vahemikud on vahemikus 500 grammi, 1 kg, 5 kg, 10 kg, 20 kg ja 40 kg jne.

Koormusandureid on erinevaid, need pakuvad erinevat täpsusvahemikku ja peaksite valima oma projekti jaoks sobiva.

Koormusanduri täpsusklassi klassifikatsioon:

Erinevad täpsusklassid on määratletud erinevat tüüpi rakenduste jaoks. Allpool toodud klassifikatsioon on madalamast täpsusest kuni kõrgeima täpsuseni.

Väiksema täpsusega (kuid mõistlikult täpsed) koormusandurid klassifitseeritakse kategooriatesse D1, C1 ja C2. Sellest projektist piisab. Neid koormusandureid kasutatakse liiva, tsemendi või vee massi mõõtmiseks.

C3 klassi koormusandurit kasutatakse kvaliteedi tagamisel, näiteks kuullaagrite, masinakonstruktsioonide osade jms kontrollimisel.

C4, C5, C6 on klassi täpsuses parimad, neid koormusandurite klassi kasutatakse grammides mikrogrammides mõõtmiseks. Neid klassiklasse kasutatakse kaupluste lettides, suuremahulises tooteseires, toiduainete pakendamises ja laboratooriumis jne.

Nüüd uurime projekti tehnilisi üksikasju.

Vooluahela skeem:

Koormuselemendi ühendus HX711 Arduinoga ja laadimisrakk.

Projekt koosneb Arduino, koormuselemendi ja HX711 koormusanduri võimendi plaadist ning arvutist. Väljundit saab jälgida Arduino IDE seeriamonitoril.

Projekti aju on nagu alati arduino, võite kasutada mis tahes Arduino lauamudelit. HX711 on 24-bitine ADC, mis suudab koormusanduri raskuse tõttu leida väikseima painde. See võib töötada vahemikus 2,7 V kuni 5 V. Toide antakse Arduino plaadilt.

Koormusanduril on üldiselt neli juhet, mis on Wheatstone'i silla konfigureeritud deformatsioonimõõturi väljund.

Punane juhe on E +, must traat on E-, roheline traat on A- ja valge traat on A +. Mõnes HX711 moodulis täpsustatakse koormusanduri klemmide nimi ja mõnes HX711 moodulis juhtmete värvid, sellist mudelit illustreeritakse skeemil.

HX711 DATA-tihvt on ühendatud Arduino tihvtiga nr 3 ja HX711 kellanupp on ühendatud Arduino tihvtiga nr 2.

Kuidas koormusandurit paigaldada:

Koormusanduril on neli kruviava, kaks mõlemal küljel. Parima täpsuse saavutamiseks peab üks külg olema statsionaarne. Selle võib sobiva kaaluga puidule künda.

Mõõtmiskaalu hoidmiseks võib kasutada õhukest puitu või õhukest plaati, nagu ülalpool illustreeritud.

Niisiis, kui panete raskuse, painutab koormusandur ka pingemõõturit ja muudab selle takistust, mida mõõdetakse HX711 mooduli abil ja suunatakse Arduinole.

Kui riistvara seadistamine on lõpule jõudnud, laadime kood üles ja kalibreerime.

Ahela kalibreerimine:

On kaks programmi, millest üks on kalibreerimisprogramm (kalibreerimisteguri leidmine). Teine kood on kaalu mõõtmise programm, kalibreerimisprogrammi koodist leitud kalibreerimistegur tuleb sisestada kaalu mõõtmise programmi.

Kalibreerimistegur määrab kaalu mõõtmise täpsuse.

Laadige HX711 teek alla siit: github.com/bogde/HX711

Kalibreerimisprogrammi kood:

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

Kuidas kalibreerida:

• Kui riistvara on seadistatud, laadige ülaltoodud kood üles.
• Eemaldage kaalu hoidmiseks kasutatav õhuke plaat või puit koos kahe kruviga (koormuselemendi teine ​​külg tuleks kinnitada aluse külge)
• Avage jademonitor.
• Pange teadaolev kaal koormusandurile otse, 100 grammi (ütleme).
• Vajutage Q, W, E, R suurendada kalibreerimistegurit vastavalt 100001000000000 võrra.
• Vajutage A, S, D, F vähendada kalibreerimistegurit vastavalt 10 100 100 000 10000 võrra.
• Pärast kalibreerimisteguri iga suurendamist või vähendamist vajutage sisestusklahvi.
• Suurendage või vähendage kalibreerimistegurit, kuni ilmub teadaoleva kaaluga materjali õige kaal.
• Taara funktsioon on kaaluskaala nulli seadmine, see on kasulik, kui soovite mõõta vee kaalu (näiteks) ilma kausi kaaluta. Pange kõigepealt kauss, vajutage taarat ja valage vett.
• Märkige kalibreerimistegur ja kirjutage see pärast teadaoleva kaalu ilmumist üles.

Nüüd saab see mõõta tundmatuid kaalu.

Kaalu mõõtmise programmi kood:

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

ujuk CalibrationFactor = -12000

Asendage -12000 leitud kalibreerimisteguriga. See võib olla negatiivne või positiivne arv.

Laadige ülaltoodud kood koos täieliku riistvaraseadistusega üles ja teie kaalude masin on valmis.

Kaalude mõõtmise masin, kasutades LCD-ekraani

Ülalolevas artiklis selgitati teie arvutit kasutades Arduino-põhist kaalumissüsteemi. Järgmises jaotises proovime luua kaalumisseadme praktilise versiooni, lisades 16 x 2 LCD-ekraani, nii et me ei sõltuks mõõtmise ajal arvutist kaalud. Selles postituses pakutakse välja kaks versiooni, üks „I2C” 16 x 2 LCD-ga ja üks ilma „I2C” 16 x 2 LCD-ekraanita.

Siin antakse kaks valikut, et lugejad saaksid valida endale sobiva kujunduse. Peamine erinevus nende kahe vahel on juhtmeühendused I2C-adapterimooduliga. LCD-ekraani toimimiseks on vaja ainult 4 juhtet (Vcc, GND, SCL ja SDA), samas kui ilma I2C-adapterita vajate Arduino ja LCD-ekraani ühendamiseks mitu juhtmest.

Mõlemad funktsioonid on täpselt samad, mõned eelistavad I2C-d tavapärasele ja mõned vastupidi, nii et siin on mõlemad kujundused.

Vaatame tavapärast LCD-disaini:

Skeem:

Ülaltoodud skeemil on LCD-ekraani kontrastsuse reguleerimiseks arduino, 16 x 2 LCD-ekraan ja 10K potentsiomeeter.

3,3 V saab toita Arduinost LCD-ekraanile tagantvalgustamiseks. Kaalu näidu nulli viimiseks on olemas nuppu, seda funktsiooni selgitatakse üksikasjalikult lõpus.

See on lihtsalt ühendus LCD ja Arduino vahel, koormusanduri ja koormusanduri võimendi ühendus Arduinoga on näidatud eelmises osas.

LCD-kaalu kaalumasina kood:

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

Vaatame nüüd, kuidas seda kaalukaitset I2C adapteril põhineva LCD-ekraaniga kasutada.

Arduino vooluringi skeem ja I2C-adapteriga LCD-ekraan:

Siin on meil lihtsalt Arduino ja LCD-ekraan I2C-adapteriga tagaküljel. Nüüd on traadiühendused lihtsustatud ja otse edasi.

I2C mooduli illustratsioon:

Selle mooduli saab jootma otse tavalise 16 x 2 või isegi 20 x 4 LCD ekraani tagaküljele ja järgida skemaatilist skeemi.

Ja veel kord, palun vaadake eelmist jaotist koormusanduri, koormusanduri võimendi ja Arduino ühendamise kohta.

Laadige alla järgmine I2C-põhine teek:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

I2C-põhise kaaluskaala ahela kood:

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

MÄRGE:

Enne kummagi koodi Arduinosse üleslaadimist peaksite koodi sisestama kalibreerimisteguri.

ujuk CalibrationFactor = -12000

Kalibreerimisteguri saamist on selgitatud ühes eelmises osas.

Taara funktsioon:

Taara funktsioon kaalukaalal on näidud nulli viia. Näiteks kui meil on korv, kuhu kaup laaditakse, on netokaal korvi kaal + kauba kaal.

Kui vajutame enne kauba laadimist koormareal taaranuppu koos korviga, jääb korvi kaal tähelepanuta ja saame kauba massi mõõta üksi.

Kui teil on selle Arduino-põhise praktilise LCD-kaalu kaalumasina vooluringi kohta küsimusi, väljendage kommentaaride jaotises kiiret vastust.