Digital veievekt ved hjelp av veiecelle og Arduino

I dette innlegget skal vi lære om belastningscelle basert på strekkmåler. Vi vil utforske hva Strain Gauge er, hva Load Cell er, temperatureffekt på strekkmåler, temperaturkompensasjon med Wheatstone bridge og Load cell forsterker HX711, og til slutt vil vi lære hvordan vi bygger en Arduino-basert veiingmaskin ved å implementere lastecelle som vektføleren.

Dette innlegget handler om vektmåling og målemetoder, og implementering av metodene i en Arduino-basert vektvektkrets.

Vi elsker alle å se vekten vår uavhengig av alder, et lite barn kan elske å se sin vektøkning og voksne kan elske å se vekttapet hans. Vekt er et viktig begrep siden antikken, det hjalp til med å handle varer, utvikling av vitenskapelig utstyr og kommersielle produkter.

I moderne tid måler vi vekter i kilogram, milligram til og med mikrogram for laboratorieformål. Ett gram er det samme over hele kloden, alt måleinstrument må måle det samme. Masseproduksjonen av en pille med liten forskjell på få milligram dosering er nok til å lage en livreddende pille til en selvmordspille.

Hva er vekt?

Vekt er den kraften som utøves på et plan. Mengden utøvd kraft er direkte proporsjonal med massen til et objekt, noe som betyr at høyere objektets masse, jo høyere kraften utøves.

Masse er mengden fysisk materie som er tilstede i et objekt.

Vekten avhenger av en faktor til: Tyngdekraften.

Tyngdekraften er konstant over hele kloden (Det er liten variasjon i tyngdekraften på grunn av ikke-ensartet sfærisk form på jorden, men den er veldig liten). Vekten på 1 kg på jorden vil veie 160 gram på månen med nøyaktig samme masse, fordi månen har mye svakere tyngdekraft.

Nå vet du hva som er vekt og hvilke faktorer som gjør et objekt tungt.

Hva er strekkmåler:

Strekkmåleren er en svinger eller en sensor som måler belastningen (deformasjon) på en gjenstand. Dette ble oppfunnet av elektroingeniør Edward E. Simmons og maskiningeniør Arthur Claude Ruge.

Illustrasjon av strekkmåler:

Stammåleren er fleksibel, det er et tynt metallfoliemønster som er klemt mellom to tynne plastark, og det må festes på en overflate med passende lim eller lim.

Når vi bruker vekt eller kraft på overflaten, deformeres den og strekkmåleren deformeres også. Deformasjonen av strekkmåleren fører til at den elektriske motstanden til metallfolien endres.

Nå er belastningsmålerens endring i motstand direkte proporsjonal med vekt eller påført kraft på overflaten.

I det virkelige liv er endringen i motstand av strekkmåler veldig ubetydelig å oppdage. For å oppdage små endringer i motstanden bruker vi Wheatstone bridge.

La oss utforske hva Wheatstone bridge er i et nøtteskall.

Forstå en Wheatstone-bro:

En hvetesteinbro er en krets som kan brukes til å bestemme ukjent motstand. Wheatstone-broen ble utviklet av Samuel Hunter Christie, senere ble Wheatstone-broen forbedret og spredt av Sir Charles

Wheatstone.

Illustrasjon av Wheatstone bridge circuit:

Våre moderne digitale multimetre kan lese motstandsverdien fra mega ohm, kilo ohm og ohm rekkevidde.

Ved hjelp av Wheat stone bridge kan vi måle motstand i milliohm-området.

Hvetesteinbroen består av 4 motstander, av de fire er 3 kjent motstand og en er ukjent motstand.

Potensialforskjellen (spenning) påføres punktene “A” og “C” og fra punktene “B” og “D” kobles et voltmeter til.

Hvis alle motstandene er like, vil ingen strøm strømme ved punktene “B” og “D”, og voltmeteret vil lese null. Dette kalles balansert bro.

Hvis en motstands motstand er forskjellig fra andre tre motstander, vil det være spenningsflyt mellom punktene 'B' og 'D', og voltmeteret vil lese noen verdi proporsjonal med ukjent motstand. Dette kalles ubalansert bro.

Her er den ukjente motstanden strekkmåler, når motstanden endres, reflekteres den på voltmeteret.

Nå har vi konvertert en deformasjon eller vekt eller kraft til spenningssignal. Denne spenningen må forsterkes for å få noen nyttige avlesninger, som vil bli matet til en mikrokontroller for å få avlesningene i gram.

La oss nå diskutere hvordan temperaturen påvirker ytelsen på strekkmåler.

Temperatureffekter på strekkmåler:

Strekkmåleren er temperaturfølsom og kan ødelegge den faktiske vekt- / kraftavlesningen. Når det er en endring i omgivelsestemperaturen, utsettes metallfolien for metallutvidelse, noe som direkte påvirker motstanden.

Vi kan oppheve temperatureffekten ved hjelp av Wheatstone bridge. La oss se hvordan vi kan kompensere temperaturen ved hjelp av Wheatstone-broen.

Temperaturkompensasjon:

Vi kan enkelt nøytralisere temperatureffekten ved å erstatte alle motstandene med strekkmåler. Nå vil all belastningsmålerens motstand påvirkes av temperaturen likt, og uønsket støy vil bli opphevet av Wheatstone-broens karakter.

Hva er en veiecelle?

En veiecelle er en aluminiumsprofil med strekkmåler festet til 4 sider i Wheatstone brokonfigurasjon.

Illustrasjon av veiecelle:

Denne typen lastecelle er stiv og brukes ofte i bransjer. Det er fire skruefester, den ene siden er boltet til en stasjonær overflate og den andre enden er boltet til en holder (si kurv) for å holde gjenstanden som skal måles.

Den har maksimal vekt spesifisert på databladet eller på kroppen, hvis du overskrider spesifikasjonen, kan det skade lastcellen.

En hel brocelle består av 4 terminaler, nemlig E +, E-, som er magnetiseringskabler som forsyningsspenningen påføres. De to andre ledningene er S + og S-, som er signaltråder hvorfra spenningen måles.

Nå er disse spenningene i millivoltområdet ikke sterke nok til at en mikrokontroller kan lese og behandle. Vi trenger forsterkning, og små endringer skal være synlige for mikrokontrolleren. For å gjøre dette er det dedikerte moduler som kalles lastcelleforsterkere.

Lastcelleforsterker HX711:

Illustrasjon av HX711 Load cell amplifier module:

Lastcelleforsterkeren er basert på IC HX711, som er 24-bit analog til digital omformer spesielt designet for vektmål. Den har forskjellige valgbare gevinster 32, 64 og 128, og den opererer på 2,6 til 5,5 V.
Dette breakout-kortet hjelper til med å oppdage liten variasjon på lastcellen. Denne modulen krever HX711.h bibliotek å operere med

Arduino eller andre mikrokontrollere.

Lastcellen blir koblet til HX711-modulen og modulen vil være grensesnittet med Arduino. Vektmålekretsen må utvikles på denne måten.

Avslutningsvis, nå vet du hva strekkmåler er, hva Wheatstone bridge er, temperatureffekter på strekkmåler, temperaturkompensasjon og hva lastcelleforsterker er.

Vi har forstått den teoretiske delen av veievektdesignet fra diskusjonen ovenfor. La oss nå se hvordan en tyngdecelle kan brukes til å lage en pratisk vektvektemaskin ved hjelp av Arduino.

Designe en digital vektmaskin ved hjelp av Arduino

I de følgende diskusjonene vil vi lære hvordan du konstruerer en digital vektmaskin ved hjelp av Arduino som kan måle vekter fra få gram til 40 kg (avhengig av spesifikasjonene til veiecellen din) med rimelig nøyaktighet. Vi vil lære om klassifisering av presisjonsgradsbelastningsceller, og vi skal kalibrere den foreslåtte kretsen og fullføre vekten.

Merk: Denne kretsen er muligens ikke i samsvar med standardene som kreves for kommersiell implementering.

Vekt skala maskiner brukes i forskjellige varianter av bransjer og forskning som spenner fra milligram til flere tonn. Den foreslåtte vektmaskinens maksimale skala avhenger av lastecellens spesifikasjoner. Det er områder fra 500 gram, 1 kg, 5 kg, 10 kg, 20 kg og 40 kg etc.

Det er forskjellige lasteceller, de tilbyr forskjellige nøyaktighetsområder, og du bør velge den som passer for prosjektet ditt.

Klassifisering av nøyaktighetsklasse for lastceller:

De forskjellige nøyaktighetsklassene er definert for forskjellige typer applikasjoner. Klassifiseringen nedenfor er fra laveste nøyaktighet til høyeste nøyaktighetsområde.

Lastcellene med lavere nøyaktighet (men rimelig nøyaktige) er klassifisert som D1, C1 og C2. Dette er nok for dette prosjektet. Disse lastcellene brukes til å måle vekten av sand, sement eller vann.

C3-klasse belastningscelle brukes til kvalitetssikring, for eksempel å sjekke vekten på kulelager, maskinkonstruksjonsdeler etc.

C4, C5, C6 er de beste i klassens nøyaktighet. Disse gradene av lastceller brukes til å måle i gram til mikrogram. Disse klasseklassene brukes i butikkdisker, storskala produksjonsovervåking, matpakking og laboratoriebruk etc.

La oss nå dykke ned i tekniske detaljer om prosjektet.

Kretsdiagram:

Lastcelleforbindelse HX711 til Arduino og lastecelle.

Prosjektet består av Arduino, Load cell og HX711 load cell forsterkerkort og en datamaskin. Utgangen kan overvåkes på den serielle skjermen til Arduino IDE.

Hjernen til prosjektet er som alltid arduino, du kan bruke hvilken som helst Arduino-brettmodell. HX711 er 24-biters ADC, som kan finne den minste bøyningen på grunn av vekten på lastcellen. Den kan operere fra 2,7 V til 5 V. Strømmen leveres fra Arduino-kortet.

Lastcellen har generelt fire ledninger, som er utgangen fra Wheatstone-brokonfigurert strekkmåler.

Den røde ledningen er E +, den svarte ledningen er E-, den grønne ledningen er A- og den hvite ledningen er A +. Noen HX711-moduler angir navnet på terminalene på lastecellen, og noen HX711-moduler angir fargene på ledningene. En slik modell er illustrert i kretsskjemaet.

DATA-pinnen på HX711 er koblet til pinne nr. 3 i Arduino og klokkepinnen på HX711 er koblet til pinne nr. 2 i Arduino.

Hvordan montere lastecellen:

Lastcellen har fire skruehull, to på begge sider. En hvilken som helst side må være stasjonær for å få best mulig nøyaktighet, den kan heves til et tre med rimelig vekt.

Et tynt tre eller en tynn plate kan brukes til å holde målevekten som illustrert ovenfor.

Så når du legger vekt, bøyer lastcellen bøyningen, og belastningsmåler gjør det og endrer motstanden som måles av HX711-modulen og mates til Arduino.

Når maskinvareoppsettet er fullført, la oss laste opp koden og kalibrere.

Kalibrere kretsen:

Det er to programmer, det ene er kalibreringsprogrammet (finne kalibreringsfaktoren). En annen kode er vektmålingsprogram. Kalibreringsfaktoren som finnes fra kalibreringsprogramkoden, må legges inn i vektmålingsprogrammet.

Kalibreringsfaktoren bestemmer nøyaktigheten av vektmålingen.

Last ned HX711-biblioteket her: github.com/bogde/HX711

Kalibreringer Programkode:

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

Hvordan kalibrere:

• Med fullført maskinvareoppsett laster du opp koden ovenfor.
• Fjern den tynne platen eller treet som brukes til å holde vekten, inkludert de to skruene (den andre siden av lastcellen skal festes til en base)
• Åpne seriell skjerm.
• Legg en kjent vekt direkte på lastecellen, 100 gram (si).
• trykk Q, W, E, R for å øke kalibreringsfaktoren med henholdsvis 10 100 100 000 100 000.
• trykk A, S, D, F for å redusere kalibreringsfaktoren med henholdsvis 10 100 000 100 000.
• Trykk “Enter” etter hver økning eller reduksjon av kalibreringsfaktoren.
• Øk eller reduser kalibreringsfaktoren til riktig vekt av kjent vektmateriale vises.
• Tara-funksjonen er å sette vektskalaen til null, dette er nyttig når du vil måle vekten av vann (si) uten vekten av bollen. Plasser bollen først, trykk tara og hell vannet.
• Legg merke til kalibreringsfaktoren og skriv den ned etter at kunnskapsvekten vises.

Nå kan den måle ukjente vekter.

Vektmålingsprogramkode:

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

Erstatt -12000 med kalibreringsfaktoren du fant. Det kan være et negativt tall eller et positivt tall.

Last opp koden ovenfor med fullstendig maskinvareoppsett, og vektskalaen din er klar.

Vektvektemaskin ved hjelp av LCD-skjerm

Ovennevnte artikkel forklarte et Arduino-basert veieskala-system ved hjelp av PC-en din, i det følgende avsnittet vil vi prøve å bygge en praktisk versjon av Weight-scale-maskin ved å legge til 16 x 2 LCD-skjerm, slik at vi ikke er avhengige av en PC mens vi måler vekter. I dette innlegget foreslås to versjoner, en med “I2C” 16 x 2 LCD og en uten “I2C” 16 x 2 LCD-skjerm.

Her er to valg gitt slik at leserne kan velge design i henhold til deres praktiske. Hovedforskjellen mellom de to er ledningstilkoblinger med I2C adaptermodul, bare 4 ledninger (Vcc, GND, SCL og SDA) er nødvendige for å fungere på LCD-skjermen, mens uten I2C-adapter trenger du flere ledninger for å koble mellom Arduino og LCD-skjermen.

Imidlertid fungerer begge funksjonene nøyaktig likt, noen foretrekker I2C fremfor konvensjonelle, og noen foretrekker motsatt, så her er begge designene.

La oss se på det konvensjonelle LCD-designet:

Kretsskjema:

I skjemaet ovenfor har vi arduino, 16 x 2 LCD-skjerm og 10K potensiometer for justering av LCD-skjermkontrast.

3,3 V kan mates fra Arduino til LCD-skjerm for bakgrunnsbelysning. En trykknapp er gitt for å bringe vektavlesningen til null, denne funksjonen vil bli forklart i detalj til slutt.

Dette er bare forbindelse mellom LCD og Arduino, forbindelsen mellom lastcelle og lastcelleforsterker til Arduino er vist i forrige avsnitt.

Kode for LCD vektmaskin:

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

La oss nå se hvordan du bruker denne vektvektsmaskinen med I2C-adapterbasert LCD-skjerm.

Kretsdiagram Arduino og LCD-skjerm med I2C-adapter:

Her har vi bare en Arduino og LCD-skjerm med I2C-adapter på baksiden. Nå er ledningstilkoblingene forenklet og rett frem.

Illustrasjon av I2C-modulen:

Denne modulen kan loddes direkte på baksiden av en vanlig 16 x 2 eller til og med 20 x 4 LCD-skjerm, og følg skjematisk diagram.

Og igjen, se forrige avsnitt for tilkobling av lastcelle, lastcelleforsterker og Arduino.

Last ned følgende bibliotek for I2C-basert:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

Kode for I2C-basert vektvektkrets:

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

MERK:

Du bør angi kalibreringsfaktoren i koden før du laster opp en av koden til Arduino.

float CalibrationFactor = -12000

Å oppnå kalibreringsfaktor er forklart i en av forrige avsnitt ovenfor.

Tarafunksjon:

Tara-funksjonen i en vektskala er å bringe avlesningene til null. For eksempel hvis vi har en kurv der varene er lastet, vil nettovekten være vekten av kurven + vekten av varene.

Hvis vi trykker på taraknappen med kurv på lastecellen før du laster varer, blir kurvens vekt neglisjert, og vi kan måle vekten av varene alene.

Hvis du har spørsmål angående denne Arduino-baserte praktiske LCD-vektvektemaskinkretsen, vennligst uttrykk i kommentarseksjonen, du kan få et raskt svar.