Portable arduino weighting machine na may itinakdang pagpipilian sa timbang para sa tingi-pack

Ang mga antas ng pag-load ng digital ay isa pang himala ng modernong-araw na engineering at disenyo. Oo, pinag -uusapan natin ang tungkol sa sukat ng pagtimbang na madalas naming nakikita sa karamihan ng mga grocery store at iba pang mga lugar, ngunit naisip mo ba kung paano gumagana ang isang scale ng timbang? Upang sagutin ang katanungang iyon, sa proyektong ito, titingnan namin ang load cell at ang paggana nito. Sa wakas, magtatayo kami ng isang portable na sukat ng pag-load na nakabatay sa Arduino gamit ang HX711 Weight Sensor, na maaaring sukatin ang timbang hanggang sa 10kg.

Ang weighting machine na ito ay perpekto para sa mga lokal na tindahan, kung saan sila nag-iimpake ng mga item nang maramihan. Tulad ng mga produktong komersyal, ang aming sukat sa timbang ay magkakaroon ng isang zero button na magpapalabas sa sukatan. Gayundin, Mayroon itong pagpipilian upang maitakda ang timbang para sa pagsukat, kapag ang bigat ng pagsukat ay umabot sa itinakdang timbang, ang isang buzzer ay mabilis na pumipigil at humihinto kapag ang itinakdang timbang ay katumbas ng timbang sa pagsukat. Sa ganitong paraan, maaaring i-pack ito ng gumagamit sa pamamagitan lamang ng pakikinig ng tunog at hindi na titingnan ang display. Dahil ito ay isang napaka-simpleng proyekto, itatayo namin ito nang napakadali gamit ang mga sangkap tulad ng Arduino at pagsukat ng gauge load cell. Kaya, nang walang karagdagang pagka-antala, pasok na tayo dito.

Sa isang nakaraang artikulo, gumawa kami ng mga proyekto tulad ng Raspberry Pi Batay sa Sensor ng Timbang at IoT Smart Container na may Email Alert at Web Monitoring gamit ang tanyag na module ng load ng amplifier ng HX711 load. Kaya't suriin iyon kung iyon ang iyong kinakailangan.

Gumagawa ang Arduino Weighing Machine

Ang pangunahing bahagi ng proyektong ito ay isang module ng Load cell at HX711 load cell amplifier. Tulad ng nakikita mo, ang isang gilid ay minarkahan ng sampung kilo. Gayundin, mapapansin mo ang ilang uri ng puting proteksiyon na pandikit sa ibabaw ng cell ng pag-load at lalabas ang apat na magkakaibang kulay ng mga wire, malalaman ang lihim sa ilalim ng puting proteksiyon na pandikit at ang pag-andar ng mga apat na kulay na mga wire na ito sa artikulo

Ang isang cell ng pag-load ay isang transduser na nagbabago ng lakas o presyon sa de-koryenteng output. Mayroon itong dalawang panig, sabihin natin ang kanang bahagi at kaliwang bahagi, at gawa ito sa mga bloke ng aluminyo. Tulad ng nakikita mo sa gitna ng materyal ay pinipis ng paglalagay ng isang malaking butas. Alin ang dahilan kung bakit iyon ang puntong naghihirap ng pagpapapangit kapag ang isang pagkarga ay nakalagay sa gilid ng bundok. Ngayon isipin na ang kanang bahagi ng cell ay naka-mount sa base at ang kaliwang bahagi ay kung saan nakalagay ang pagkarga, ang pagsasaayos na ito ay nagpapapangit ng cell ng gauge load ng strain dahil sa higanteng butas sa gitna.

Kapag ang isang karga ay nakalagay sa gilid ng pag-load ng cell ng pag-load, ang tuktok na bahagi ay magdurusa ng pag-igting, at ang ilalim na bahagi ay magdurusa ng compression. Iyon ang dahilan kung bakit ang aluminyo bar ay bents pababa sa kaliwang bahagi. Kung susukatin natin ang pagpapapangit na ito, masusukat namin ang puwersa na inilapat sa bloke ng aluminyo at iyon mismo ang gagawin namin.

Ngayon, ang tanong ay nananatili kung ano ang nasa loob ng puting proteksiyon na pandikit? Sa loob ng proteksiyon na pandikit na ito, mahahanap natin ang isang manipis na nababanat na sangkap na tinatawag na isang gauge ng salaan. Ang isang gauge ng salaan ay isang sangkap na ginagamit upang sukatin ang salaan. Kung titingnan natin nang mas malapit ang sangkap na ito, maaari naming makita ang dalawang mga pad ng koneksyon, at pagkatapos ay mayroon kaming isang conductive wire pattern na may mga paulit-ulit na pagpapalihis. Ang conductive wire na ito ay may isang tinukoy na paglaban. Kapag yumuko natin ito, magbabago ang halaga ng paglaban? Kaya, ang isang gilid ng gauge ng pilay ay naka-mount at naayos sa isang lugar, kung maglalagay tayo ng isang bigat sa kabilang panig ng aluminyo bar, pipilitin nitong yumuko ang gauge ng salaan, na magdudulot ng pagbabago sa paglaban. Paano ito nangyayari nang totoo? Ang kondaktibong pattern ng gauge ng salaan ay gawa sa tanso, ang kawad na ito ay magkakaroon ng isang tiyak na lugar at haba, kaya't ang dalawang yunit na ito ay magbibigay ng paglaban ng kawad. Ang paglaban ng isang kawad ay sumasalungat sa daloy ng kasalukuyang. Ngayon ay malinaw na kung ang lugar ng kawad na ito ay lumiliit,mas kaunting mga electron ang maaaring pumasa nangangahulugang isang mas mababang kasalukuyang. Ngayon kung tataasan natin ang lugar, tataas nito ang paglaban ng isang konduktor. Kung ang ilang puwersa ay inilapat sa kawad na ito, ito ay mag-uunat ng lugar at ito ay magiging mas maliit sa parehong oras, ang pagtaas ng paglaban. Ngunit ang pagkakaiba-iba ng paglaban na ito ay napakababa. Kung iunat natin ang gauge ng salaan, tataas ang paglaban at kung i-compress natin ito, magiging mas mababa ang resistensya. Upang sukatin ang puwersa, kailangan nating sukatin ang paglaban. Ang pagsukat nang diretso ng paglaban ay hindi laging praktikal, sapagkat ang pagbabago ay napakaliit. Kaya sa halip na sukatin ang paglaban, madali nating masusukat ang mga voltages. Kaya, sa kasong ito, kailangan nating i-convert ang gauge output mula sa mga halaga ng paglaban sa mga halaga ng boltahe.Kung ang ilang puwersa ay inilapat sa kawad na ito, ito ay mag-uunat ng lugar at ito ay magiging mas maliit sa parehong oras, ang pagtaas ng paglaban. Ngunit ang pagkakaiba-iba ng paglaban na ito ay napakababa. Kung iunat natin ang gauge ng salaan, tataas ang paglaban at kung i-compress natin ito, magiging mas mababa ang resistensya. Upang sukatin ang puwersa, kailangan nating sukatin ang paglaban. Ang pagsukat nang diretso ng paglaban ay hindi laging praktikal, sapagkat ang pagbabago ay napakaliit. Kaya sa halip na sukatin ang paglaban, madali nating masusukat ang mga voltages. Kaya, sa kasong ito, kailangan nating i-convert ang gauge output mula sa mga halaga ng paglaban sa mga halaga ng boltahe.Kung ang ilang puwersa ay inilapat sa kawad na ito, ito ay mag-uunat ng lugar at ito ay magiging mas maliit sa parehong oras, ang pagtaas ng paglaban. Ngunit ang pagkakaiba-iba ng paglaban na ito ay napakababa. Kung iunat natin ang gauge ng salaan, tataas ang paglaban at kung i-compress natin ito, magiging mas mababa ang resistensya. Upang sukatin ang puwersa, kailangan nating sukatin ang paglaban. Ang pagsukat nang diretso ng paglaban ay hindi laging praktikal, sapagkat ang pagbabago ay napakaliit. Kaya sa halip na sukatin ang paglaban, madali nating masusukat ang mga voltages. Kaya, sa kasong ito, kailangan nating i-convert ang gauge output mula sa mga halaga ng paglaban sa mga halaga ng boltahe.ang resistensya ay magiging mas mababa. Upang sukatin ang puwersa, kailangan nating sukatin ang paglaban. Ang pagsukat nang diretso ng paglaban ay hindi laging praktikal, sapagkat ang pagbabago ay napakaliit. Kaya sa halip na sukatin ang paglaban, madali nating masusukat ang mga voltages. Kaya, sa kasong ito, kailangan nating i-convert ang gauge output mula sa mga halaga ng paglaban sa mga halaga ng boltahe.ang resistensya ay magiging mas mababa. Upang sukatin ang puwersa, kailangan nating sukatin ang paglaban. Ang pagsukat nang diretso ng paglaban ay hindi laging praktikal, sapagkat ang pagbabago ay napakaliit. Kaya sa halip na sukatin ang paglaban, madali nating masusukat ang mga voltages. Kaya, sa kasong ito, kailangan nating i-convert ang gauge output mula sa mga halaga ng paglaban sa mga halaga ng boltahe.

Magagawa natin ito sa tulong ng tulay ng Wheatstone. Inilalagay namin ang gauge ng salaan sa tulay ng Wheatstone kung balanse ang tulay, ang boltahe sa gitnang punto ay dapat na zero (dati ay nagtayo kami ng isang proyekto kung saan namin inilarawan kung paano gumagana ang isang tulay ng Wheatstone, maaari mong suriin iyon kung nais mong malalaman ang tungkol sa paksa). Kapag binago ng gauge ng pagsukat ang paglaban nito, hindi nito balansehin ang tulay, at magbabago rin ang boltahe. Kaya, ito ay kung paano pinapalitan ng tulay ng Wheatstone ang mga pagkakaiba-iba ng paglaban sa mga halaga ng boltahe.

Ngunit ang pagbabago ng boltahe na ito ay napakaliit pa rin, kaya upang madagdagan iyon, kailangan nating gamitin ang module na HX711. Ang HX711 ay isang 24-bit na Pagkakaiba ng ADC, sa ganitong paraan, masusukat natin ang napakaliit na pagbabago ng boltahe. magbibigay ito ng mga halaga mula 0 hanggang 2 exponential 24.

Mga Kinakailangan na Bahagi para sa Arduino Base Weighing Machine

Upang gawing simple ang proyektong ito hangga't maaari, gumamit kami ng mga pangkaraniwang bahagi na maaari mong makita sa anumang lokal na tindahan ng libangan. Ang imahe sa ibaba ay magbibigay sa iyo ng isang ideya tungkol sa mga bahagi. Bukod dito, mayroon kaming Bill of Materials (BOM) na nakalista sa ibaba.

Load cell (Gumagamit kami ng isang 10 kg load cell)
Module ng amplifier ng HX 711
Arduino Nano
I2C LCD 16X2 - Tugma sa I2C
1k resistor -2 No.
Mga LED -2No
Buzzer
Karaniwang PCB
7.4V baterya (kung nais mo itong portable)
LM7805 boltahe regulator

Nakabatay sa Arduino Machine na Tumimbang - Diagram ng Circuit

Ang load cell ay may apat na mga wire na pula, itim, berde, at puti. Ang kulay na ito ay maaaring mag-iba ayon sa mga tagagawa, kaya mas mahusay na mag-refer sa datasheet. Ikonekta ang pula sa E + ng HX711 board, ikonekta ang itim sa E-, ikonekta ang puti sa A +, at ikonekta ang berde sa A-, Dout, at orasan ng board na kumonekta sa D4 at D5 ayon sa pagkakabanggit. Ikonekta ang isang dulo ng mga pindutan ng push sa D3, D8, D9, at iba pang mga dulo sa lupa. Mayroon kaming I2C LCD, kaya ikonekta ang SDA sa A4 at SCL sa A5. Ikonekta ang lupa ng LCD, HX711, at Arduino sa lupa, ikonekta din ang mga VCC sa 5Vpin ng Arduino. Ang lahat ng mga module ay gumagana sa 5V, kaya nagdagdag kami ng isang LM7805 boltahe regulator. Kung hindi mo nais ito bilang portable, maaari mong direktang i-power ang Arduino gamit ang isang USB cable.

Paggawa ng Circuit sa isang Dotted Perfboard

Kami ay naghinang ng lahat ng mga bahagi sa isang pangkaraniwang tuldok na perfboard. Gumamit kami ng mga babaeng header upang maghinang ang Arduino at ADC gamit ang circuit board, gumamit din kami ng mga wire upang ikonekta ang lahat ng mga pushbuttons at LED. Matapos ang lahat ng proseso ng paghihinang ay natapos, nasiguro namin na ang wastong 5V ay lalabas sa LM7805. Sa wakas, naglagay kami ng isang switch sa power on / off sa circuit. Kapag natapos na kaming lahat, mukhang ang imahe sa ibaba.

Pagbuo ng isang Enclosure para sa Arduino based Weighing Machine

Tulad ng nakikita mo, ang load cell ay may ilang mga thread ng tornilyo, kaya maaari naming mai-mount ito sa isang base plate. Gumagamit kami ng isang PVC board para sa base ng aming sukat, para doon, una naming pinutol ang 20 * 20 cm square at apat na 20 * 5 na mga rektanggulo mula sa board ng PVC. Pagkatapos ay gumagamit ng matapang na pandikit, idinikit namin ang bawat piraso at gumawa ng isang maliit na enclosure.

Tandaan, hindi namin naayos ang isang panig, dahil kailangan naming ilagay ang mga pushbuttons, LEDs, at LCD dito. Pagkatapos ay gumamit kami ng isang plastic board para sa tuktok ng sukat. Bago gawing permanente ang pag-set up na ito, kailangan naming tiyakin na mayroon kaming sapat na puwang mula sa lupa hanggang sa load cell, kaya't makakayuko, kaya't inilagay namin ang mga tornilyo at mani sa pagitan ng load cell at ng base, idinagdag din namin ilang mga plastic spacer sa pagitan ng load cell at tuktok na bahagi. ginamit namin ang isang bilog na plastic sheet bilang nangungunang matalino sa balanse.

Pagkatapos ay inilagay namin ang LCD, LEDs, at mga push-button sa front panel, at lahat ng nakakonekta sa mahabang insulated wire. Matapos naming matapos ang proseso ng mga kable, idinikit namin ang front panel sa pangunahing base na may ilang pagkahilig, upang madali naming mabasa ang mga halaga mula sa LCD. sa wakas, ikinabit namin ang pangunahing switch sa gilid ng balanse at iyon lang. Ganito namin ginawa ang katawan para sa aming sukat sa timbang.

Maaari kang mag-disenyo gamit ang iyong mga ideya ngunit tandaan na ilagay ang tulad ng load ng cell tulad ng sa imahe.

Arduino Weighing Machine - Code

Habang natapos na kami ngayon sa proseso ng pagbuo para sa aming digital scale, maaari kaming lumipat sa bahagi ng programa. Para sa madaling pagprogram, gagamitin namin ang HX711 library, EEPROM Library, at ang LiquidCrystal library. Maaari mong i-download ang HX711 library mula sa opisyal na Repository ng GitHub, o pumunta sa mga tool > isama ang library > pamahalaan ang library, pagkatapos maghanap ng library gamit ang keyword na HX711, pagkatapos i-download ang library, I-install ito sa Arduino ide.

Una, kailangan nating i-calibrate ang load cell at iimbak ang halagang iyon sa EEPROM, para doon, pumunta sa file> mga halimbawa> HX 711_ADC, pagkatapos ay piliin ang code ng pagkakalibrate. Bago i-upload ang code, ilagay ang balanse sa isang matatag na ibabaw ng eroplano. Pagkatapos i-upload ang code sa Arduino at buksan ang serial monitor. Pagkatapos baguhin ang baud rate sa 572600. Ngayon subaybayan ang hilingin na kunin ang timbang, para doon kailangan nating pindutin ang t at ipasok.

Ngayon, kailangan nating ilagay ang kilalang timbang sa balanse, sa aking kaso, iyon ay 194gm. Matapos mailagay ang kilalang timbang, i-type ang timbang sa serial monitor, at pindutin ang enter.

Ngayon, tatanungin ka ng serial monitor kung nais mong i-save ang halaga sa EEPROM o hindi, kaya i-type ang Y para sa pagpili ng oo. Ngayon ay makikita na natin ang bigat sa serial monitor.

Ang pangunahing code ng proyektong ito, na binuo namin mula sa halimbawa ng sketch ng HX711 library. Maaari mong i-download ang code ng proyektong ito mula sa ibaba.

Sa seksyon ng pag-coding, una, idinagdag namin ang lahat ng tatlong mga aklatan. Ang HX711 library ay para sa pagkuha ng mga halaga ng load cell. Ang EEPROM ay ang inbuilt library ng Arduino ide, na ginagamit upang mag-imbak ng mga halaga sa EEPROM at ang library ng LiquidCrystal ay para sa l2C LCD Module.

# isama # isama # isama

Pagkatapos ay tinukoy ang mga integer para sa iba't ibang mga pin at itinalagang mga halaga. Ang pagpapaandar ng HX711_ADC loadcell ay para sa pagtatakda ng pin ng Dout at orasan.

const int HX711_dout = 4; const int HX711_sck = 5; int tpin = 3; HX711_ADC LoadCell (HX711_dout, HX711_sck); Const int calVal_eepromAdress = 0; mahaba t; Const int Up_buttonPin = 9; Const int Down_buttonPin = 8; float buttonPushCounter = 0; float up_buttonState = 0; float up_last ButtonState = 0; float down_buttonState = 0; float down_last ButtonState = 0;

Sa seksyon ng pag-setup, una, sinimulan namin ang serial monitor, para lamang ito sa pag-debug. Pagkatapos ay tinukoy namin ang mga mode ng pin, ang lahat ng mga pindutan ng push ay tinukoy bilang input. Sa tulong ng pagpapaandar ng Arduino Pull UP, itinakda namin ang mga pin sa isang lohikal na mataas sa normal. Kaya, hindi namin nais na gumamit ng anumang panlabas na resistors para doon.

pinMode (tpin, INPUT_PULLUP); pinMode (6, OUTPUT); pinMode (12, OUTPUT); pinMode (Up_buttonPin, INPUT_PULLUP); pinMode (Down_buttonPin, INPUT_PULLUP);

Ang mga sumusunod na linya ng code ay para sa pagtatakda ng I2C LCD. Una, ipinakita namin ang maligayang teksto gamit ang pagpapaandar ng LCD.print () , pagkatapos ng dalawang segundo, tinanggal namin ang display gamit ang lcd.clear () . Iyon ay, sa simula, ipinapakita ang pagpapakita ng ARDUINO BALANCE bilang maligayang teksto, at pagkatapos ng dalawang segundo, lilinawin nito at ipapakita ang mga timbang sa pagsukat.

lcd.init (); lcd.backlight (); lcd.setCursor (0, 0); lcd.print ("ARDUINO BALANCE"); lcd.setCursor (0, 1); lcd.print ("sukatin natin"); pagkaantala (2000); lcd.clear ();

Pagkatapos ay nagsimulang basahin ang mga halaga mula sa loadcell gamit ang function na loadCell.begin () , pagkatapos nito, binasa namin ang EEPROM para sa mga naka-calibrate na halaga, ginagawa namin iyon sa pamamagitan ng paggamit ng EEPROM.get () function. Iyon ay, naimbak na namin ang halaga gamit ang calibration sketch sa EEPROM address, muling kinukuha namin ang halagang iyon.

LoadCell.begin (); EEPROM.get (calVal_eepromAdress, calibrationValue);

Sa seksyon ng loop, una, suriin namin kung mayroong anumang data mula sa cell ng pag-load na magagamit gamit ang LoadCell.update (), kung magagamit, basahin at iimbak namin ang data na iyon, para doon , gumagamit kami ng LoadCell.getData () . Susunod, kailangan nating ipakita ang nakaimbak na halaga sa LCD. Upang magawa iyon, ginamit namin ang pagpapaandar ng LCD.print () . Gayundin, nai-print namin ang itinakdang timbang. Itakda ang timbang ay nagtatakda sa tulong ng counter ng Pushbutton. Ipinaliwanag iyon sa huling seksyon.

kung (LoadCell.update ()) newDataReady = true; kung (newDataReady) { kung (millis ()> t + serialPrintInterval) { float i = LoadCell.getData (); lcd.setCursor (0, 0); lcd.print ("set wei:"); lcd.setCursor (9, 0); lcd.print (buttonPushCounter); lcd.setCursor (14, 0); lcd.print ("GM"); lcd.setCursor (0, 1); lcd.print ("bigat:"); lcd.setCursor (9, 1); lcd.print (i); lcd.setCursor (14, 1); lcd.print ("GM");

Susunod, itinakda namin ang halaga ng pagkapagod, para doon , una, binasa namin ang estado ng pindutan ng tsada gamit ang pagpapaandar na digitalRead () , kung mababa ang estado, pinapayat namin ang timbang na iyon sa zero. Ang pagpapaandar ng tare ng sukat ng timbang na ito ay upang gawing zero ang mga pagbabasa. Halimbawa, kung mayroon kaming isang mangkok kung saan ang mga bagay ay na-load, kung gayon ang net weight ay ang bigat ng mangkok + ang bigat ng mga bagay. Kung pinindot namin ang pindutan ng pagkapagod gamit ang mangkok sa load cell bago mag-load ng mga bagay, ang bigat ng basket ay mabubura at maaari naming sukatin ang bigat ng mga bagay nang mag-isa.

kung (digitalRead (tpin) == LOW) { LoadCell.tareNoDelay ();

Ngayon, kailangan naming itakda ang mga kundisyon para sa iba't ibang mga indikasyon tulad ng pagtatakda ng pagkaantala ng buzzer at ng humantong status. Ginawa namin iyon gamit ang kung kundisyon, mayroon kaming isang kabuuang tatlong mga kundisyon. Una, kinakalkula namin ang pagkakaiba sa pagitan ng itinakdang timbang at pagsukat ng timbang, pagkatapos ay nakaimbak ng halagang iyon sa variable k.

float k = buttonPushCounter-i;

1. Kung ang pagkakaiba sa pagitan ng itinakdang timbang at pagsukat ng timbang ay mas malaki sa o katumbas ng 50gms, ang buzzer beep na may isang 200-millisecond na pagkaantala (dahan-dahan).

kung (k> = 50) { digitalWrite (6, TAAS); pagkaantala (200); digitalWrite (6, LOW); pagkaantala (200); }

2. Kung ang pagkakaiba sa pagitan ng itinakdang timbang at pagsukat ng timbang ay mas mababa sa 50 at mas malaki sa 1 gramo, ang buzzer beep na may isang 50-millisecond na pagkaantala (mas mabilis).

kung (k <50 && k> 1) { digitalWrite (6, TAAS); antala (50); digitalWrite (6, LOW); antala (50); }

3. Kapag ang timbang sa pagsukat ay katumbas o mas malaki kaysa sa itinakdang halaga, bubuksan nito ang berdeng humantong at patayin ang buzzer at pula na humantong.

kung (i> = buttonPushCounter) { digitalWrite (6, LOW); digitalWrite (12, TAAS); }

Mayroon kaming dalawa pang mga walang bisa na pag-andar () para sa pagtatakda ng itinakdang timbang (para sa pagbibilang ng pindutan ng pindutin).

Ang pagpapaandar na pagtaas ng itinakdang halaga ng 10gms para sa bawat pindutin. Ginagawa ito sa pamamagitan ng paggamit ng function na digitalRead ng Arduino kung mababa ang pin na nangangahulugang pinindot ang pindutan at madaragdagan ang halaga ng 10gms.

up_buttonState = digitalRead (Up_buttonPin); kung (up_buttonState! = up_last ButtonState) { kung (up_buttonState == LOW) { bPress = true; buttonPushCounter = buttonPushCounter + 10; }

Katulad din

Ang checkdown ay para sa pagbawas ng itinakdang halaga ng 10gms para sa bawat pindutin.

down_buttonState = digitalRead (Down_buttonPin); kung (down_buttonState! = down_last ButtonState) { kung (down_buttonState == LOW) { bPress = true; buttonPushCounter = buttonPushCounter - 10; }

Ito ang marka ng pagtatapos ng bahagi ng programa.

Ang antas ng elektronikong batay sa Arduino ay perpekto para sa pagsukat ng mga timbang hanggang sa 10kg (maaari nating dagdagan ang limitasyong ito sa pamamagitan ng paggamit ng isang mas mataas na rate ng loadcell). Ito ay 99% tumpak sa orihinal na mga sukat.

Kung mayroon kang anumang mga katanungan patungkol sa Arduino batay sa LCD weight balanse machine circuit, mangyaring i-post ito sa seksyon ng komento, salamat!