- Ano ang Turbidity sa Liquid?
- Paano Masusukat ang Karubal gamit ang Arduino?
- Mga Sangkap na Kinakailangan para sa Paggawa ng Turbidity Meter
- Pangkalahatang-ideya ng Turbidity Sensor
- Pangunahing Mga Tampok ng Turbidity Module
- Ang Interfacing Turbidity Sensor na may Arduino - Circuit Diagram
- Pagprogram ng Arduino upang Sukatin ang Kalubaan sa Tubig
Pagdating sa mga likido, ang kaguluhan ay isang mahalagang term. Dahil ito ay may mahalagang papel sa likidong dynamics at ginagamit din upang sukatin ang kalidad ng tubig. Kaya sa tutorial na ito, talakayin natin kung ano ang kaguluhan, kung paano sukatin ang labo ng isang likido gamit ang Arduino. Kung nais mong gawin ang proyektong ito nang higit pa, maaari mo ring isaalang-alang ang pag-interfaced ng isang meter ng ph sa Arduino at basahin din ang halaga ng pH ng tubig upang mas mahusay na masuri ang kalidad ng tubig. Dati ay nakabuo rin kami ng isang IoT batay sa kalidad ng aparato sa pagsubaybay sa kalidad gamit ang ESP8266, maaari mo ring suriin iyon kung interesado. Sinabi na, magsimula na tayo
Ano ang Turbidity sa Liquid?
Ang kaguluhan ay ang antas o antas ng ulap o pagkabalisa ng isang likido. Nangyayari ito dahil sa pagkakaroon ng maraming bilang ng mga hindi nakikita na mga maliit na butil (na may mata na mata) na katulad ng puting usok sa hangin. Kapag ang ilaw ay dumaan sa mga likido, ang mga ilaw na alon ay nakakalat Dahil sa pagkakaroon ng mga maliliit na particle na ito. Ang kaguluhan ng isang likido ay direktang proporsyonal sa mga libreng nasuspindeng mga maliit na butil na kung ang bilang ng mga maliit na butil ay nagdaragdag ng kalungkutan ay tataas din.
Paano Masusukat ang Karubal gamit ang Arduino?
Tulad ng nabanggit ko kanina, ang kaguluhan ay nangyayari dahil sa pagkalat ng mga light alon, upang masukat ang kaguluhan, dapat nating sukatin ang pagkalat ng ilaw. Kadalasang sinusukat ang kalungkot sa nephelometric turbidity unit (NTU) o Jackson turbidity unit (JTLJ), depende sa pamamaraang ginamit sa pagsukat. Ang dalawang mga yunit ay halos pantay.
Tingnan natin ngayon kung paano gumagana ang isang sensor ng turbidity, mayroon itong dalawang bahagi, transmiter at Receiver. Ang transmitter ay binubuo ng isang light source na karaniwang isang led at isang circuit ng driver. Sa dulo ng receiver, mayroong isang light detector tulad ng isang photodiode o isang LDR. Inilalagay namin ang solusyon sa pagitan ng transmiter at tatanggap.
Transmitter ay nagpapadala lamang ng ilaw, ang mga ilaw na alon ay dumaan sa solusyon at ang tatanggap ay tumatanggap ng ilaw. Karaniwan (nang walang pagkakaroon ng isang solusyon) ang nailipat na ilaw na ganap na natatanggap sa panig ng tatanggap. Ngunit sa pagkakaroon ng isang malungkot na solusyon, ang halaga ng naihatid na ilaw ay napakababa. Nasa panig iyon ng tatanggap, nakakakuha lamang kami ng isang ilaw na may mababang lakas at ang intensidad na ito ay baligtad na proporsyonal sa karamdaman. Kaya't maaari nating sukatin ang kalungkutan sa pamamagitan ng pagsukat ng ilaw ng ilaw kung ang lakas ng ilaw ay mataas, ang solusyon ay hindi gaanong magulo at kung ang ilaw ng tindi ay napakababa na nangangahulugang ang solusyon ay mas malungkot.
Mga Sangkap na Kinakailangan para sa Paggawa ng Turbidity Meter
- Module ng Karamdaman
- Arduino
- 16 * 2 I2C LCD
- Karaniwang LED na katod na RGB
- Breadboard
- Jumper wires
Pangkalahatang-ideya ng Turbidity Sensor
Ang sensor ng turbidity na ginamit sa proyektong ito ay ipinapakita sa ibaba.
Tulad ng nakikita mo, ang module ng turbidity sensor na ito ay may 3 mga bahagi. Isang lead na hindi tinatagusan ng tubig, isang circuit ng driver, at isang koneksyon na kawad. Ang pagsubok ng pagsubok ay binubuo ng parehong transmiter at tatanggap.
Ipinapakita ang imahe sa itaas, ang ganitong uri ng module ay gumagamit ng isang IR diode bilang isang mapagkukunan ng ilaw at isang IR receiver bilang isang detector. Ngunit ang prinsipyo ng pagtatrabaho ay katulad ng dati. Ang bahagi ng driver (ipinapakita sa ibaba) ay binubuo ng isang op-amp at ilang mga bahagi na nagpapalakas ng napansin na signal ng ilaw.
Ang aktwal na sensor ay maaaring konektado sa modyul na ito sa pamamagitan ng paggamit ng isang konektor ng JST XH. Mayroon itong tatlong mga pin, VCC, ground, at output. Ang Vcc ay kumokonekta sa 5v at ground sa ground. Ang output ng modyul na ito ay isang analog na halaga na nagbabago ito alinsunod sa tindi ng ilaw.
Pangunahing Mga Tampok ng Turbidity Module
- Operating Boltahe: 5VDC.
- Kasalukuyang: 30mA (MAX).
- Temperatura sa pagpapatakbo: -30 ° C hanggang 80 ° C.
- Mga katugmang sa Arduino, Raspberry Pi, AVR, PIC, atbp.
Ang Interfacing Turbidity Sensor na may Arduino - Circuit Diagram
Ang kumpletong eskematiko upang ikonekta ang sensor ng Turbidity sa Arduino ay ipinapakita sa ibaba, ang circuit ay idinisenyo gamit ang EasyEDA.
Ito ay isang napaka-simpleng diagram ng circuit. Ang output ng turbidity sensor ay analog upang konektado sa A0 pin ng Arduino, ang I2C LCD ay konektado sa I2C pin ng Arduino na SCL sa A5 at SDA sa A4. Pagkatapos ang RGB LED ay konektado sa digital pin D2, D3, at D4. Matapos ang mga koneksyon ay tapos na, ang aking pag-setup ng hardware ay ganito sa ibaba.
Ikonekta ang VCC ng sensor sa Arduino 5v, pagkatapos ay ikonekta ang lupa sa lupa. Ang output pin ng sensor sa analog 0 ng Arduino. Susunod, ikonekta ang VCC at ground ng LCD module sa 5v at ground ng Arduino. Pagkatapos ang SDA sa A4 at SCL sa A5, ang dalawang pin na ito ay ang mga I2C na pin ng Arduino. sa wakas ay nagkokonekta sa lupa ng RGB LED sa lupa ng Arduino at ikonekta ang berde sa D3, asul sa D4, at pula sa D5.
Pagprogram ng Arduino upang Sukatin ang Kalubaan sa Tubig
Ang plano ay upang ipakita ang mga halaga ng labo mula 0 hanggang 100. Iyon ang metro na dapat ipakita ang 0 para sa purong likido at 100 para sa mga lubos na magulong. Ang Arduino code na ito ay napaka-simple din at ang kumpletong code ay matatagpuan sa ilalim ng pahinang ito.
Una, isinama ko ang I2C liquid crystal library dahil gumagamit kami ng isang I2C LCD upang i-minimize ang mga koneksyon.
# isama
Pagkatapos ay itinakda ko ang integer para sa pag-input ng sensor.
int sensorPin = A0;
Sa seksyon ng pag-setup, tinukoy ko ang mga pin.
pinMode (3, OUTPUT); pinMode (4, OUTPUT); pinMode (5, OUTPUT);
Sa seksyon ng loop, Tulad ng nabanggit ko kanina, ang output ng sensor ay isang halagang analog. Kaya kailangan nating basahin ang mga halagang iyon. Sa tulong ng pagpapaandar ng Arduino AnalogRead , mababasa natin ang mga halaga ng output sa seksyon ng loop.
int sensorValue = analogRead (sensorPin);
Una, kailangan naming maunawaan ang pag-uugali ng aming sensor, na nangangahulugang kailangan naming basahin ang minimum na halaga at maximum na halaga ng turbidity sensor. mababasa natin ang halagang iyon sa serial monitor gamit ang serial.println function.
Upang makuha ang mga halagang ito, una, basahin nang libre ang sensor na walang anumang solusyon. Nakuha ko ang isang halaga sa paligid ng 640 at pagkatapos nito, maglagay ng isang itim na sangkap sa pagitan ng transmiter at tatanggap, nakakakuha kami ng isang halaga na ang minimum na halaga, karaniwan, ang halagang iyon ay zero. Kaya nakakuha kami ng 640 bilang maximum at zero bilang isang minimum. Ngayon kailangan naming i-convert ang mga halagang ito sa 0-100
Para doon, ginamit ko ang pagpapaandar ng mapa ng Arduino.
int turbidity = mapa (sensorValue, 0,640, 100, 0);
Pagkatapos ay ipinakita ko ang mga halagang iyon sa display ng LCD.
lcd.setCursor (0, 0); lcd.print ("kaguluhan:"); lcd.print (""); lcd.setCursor (10, 0); lcd.print (kalungkutan);
Pagkatapos nito, sa tulong ng kung kundisyon, nagbigay ako ng iba't ibang mga kundisyon.
kung (kalungkutan <20) { digitalWrite (2, TAAS); digitalWrite (3, LOW); digitalWrite (4, LOW); lcd.setCursor (0, 1); lcd.print ("MALINAW"); }
Ito ay aktibong berde na humantong at ipakita ang "malinaw" nito sa LCD kung ang halaga ng kalungkot ay mas mababa sa 20.
kung ((kalungkutan> 20) && (kalungkutan <50)) { digitalWrite (2, LOW); digitalWrite (3, TAAS); digitalWrite (4, LOW); lcd.setCursor (0, 1); lcd.print ("CLOUDY nito"); }
Ito ay aktibong asul na humantong at ipakita ang "maulap" sa LCD kung ang halaga ng kalungkot ay nasa pagitan ng 20 at 50.
kung ((kalungkutan> 50) { digitalWrite (2, LOW); digitalWrite (3, HIGH); digitalWrite (4, LOW); lcd.setCursor (0, 1); lcd.print ("its DIRTY"); }
Aktibo ito ng pulang pinuno at ipapakita ang "marumi" sa LCD kung ang halaga ng kalungkot ay mas malaki sa 50 tulad ng ipinakita sa ibaba.
Sundin lamang ang diagram ng circuit at i-upload ang code, kung tama ang lahat, dapat mong masukat ang kalubhaan ng tubig at dapat ipakita ng LCD ang kalidad ng tubig tulad ng ipinakita sa itaas.
Tandaan na ang meter ng kaguluhan na ito ay nagpapakita ng porsyento ng kalungkutan at maaaring hindi ito isang tumpak na pang-industriya na halaga, ngunit maaari pa rin itong magamit upang ihambing ang kalidad ng tubig ng dalawang tubig. Ang kumpletong pagtatrabaho ng proyektong ito ay matatagpuan sa video sa ibaba. Inaasahan kong nasiyahan ka sa tutorial at natutunan ang isang bagay na kapaki-pakinabang kung mayroon kang anumang katanungan, maaari mong iwanan ang mga ito sa seksyon ng komento sa ibaba o gamitin ang mga forum ng CircuitDigest para sa pag-post ng iyong mga teknikal na katanungan o magsimula ng isang nauugnay na talakayan.