Ang alarma ng detector ng lindol gamit ang arduino

Ang lindol ay isang hindi mahuhulaan na natural na sakuna na nagdudulot ng pinsala sa buhay at pag-aari. Nangyayari ito bigla at hindi natin ito mapipigilan ngunit maalerto tayo mula rito. Sa panahon ngayon, maraming mga teknolohiya na maaaring magamit upang makita ang mga maliliit na pagyanig at pagkatok, upang makagawa kami ng pag-iingat bago ang ilang pangunahing mga panginginig sa mundo. Narito ginagamit namin ang Accelerometer ADXL335 upang makita ang mga panginginig bago ang lindol. Ang Accelerometer ADXL335 ay lubos na sensitibo sa mga pagyanig at panginginig ng boses kasama ang lahat ng tatlong palakol. Dito nagtatayo kami ng isang nakabatay sa Arduino na Earthquake Detector gamit ang Accelerometer.

Dito namin itinatayo ang detector ng Earthquake bilang isang Arduino Shield sa PCB at ipapakita rin ang Vibrations Graph sa computer gamit ang Processing.

Kinakailangan ang Mga Bahagi:

• Arduino UNO
• Accelerometer ADXL335
• 16x2 LCD
• Buzzer
• BC547 transistor
• 1k Resistors
• 10K POT
• LED
• Power Supply 9v / 12v
• Berg sticks lalaki / babae

Accelerometer:

Paglalarawan ng Pin ng accelerometer:

1. Ang supply ng Vcc 5 volt ay dapat na kumonekta sa pin na ito.
2. X-OUT Ang pin na ito ay nagbibigay ng isang output ng Analog sa x direksyon
3. Y-OUT Ang pin na ito ay nagbibigay ng isang Analog Output sa direksyon
4. Z-OUT Ang pin na ito ay nagbibigay ng isang Analog Output sa z na direksyon
5. GND Ground
6. ST Ang pin na ito ay ginamit para sa itinakdang pagiging sensitibo ng sensor

Suriin din ang aming iba pang mga proyekto gamit ang Accelerometer:

• Ping Pong Game gamit ang Arduino
• Nakokontrol na Robot na Batay sa Accelerometer na Nakabatay sa Kamay.
• Arduino Batay sa Sasakyan aksidente Alerto System gamit ang GPS, GSM at Accelerometer

Paggawa ng Paliwanag:

Ang pagtatrabaho ng Earthquake Detector na ito ay simple. Tulad ng nabanggit namin kanina na ginamit namin ang Accelerometer para sa pagtuklas ng mga pagyanig ng lindol kasama ang anuman sa tatlong mga palakol upang sa tuwing nangyayari ang mga panginginig ng damdamin ng accelerometer na ang mga pag-vibrate at i-convert ang mga ito sa katumbas na halaga ng ADC. Pagkatapos ang mga halagang ADC na ito ay binabasa ng Arduino at ipinakita sa 16x2 LCD. Ipinakita rin namin ang mga halagang ito sa Graph gamit ang Pagproseso. Matuto nang higit pa tungkol sa Accelerometer sa pamamagitan ng pagdaan sa aming iba pang mga proyekto sa Accelerometer dito.

Una kailangan naming i- calibrate ang Accelerometer sa pamamagitan ng pagkuha ng mga sample ng nakapalibot na mga vibration tuwing umaakyat ang Arduino Powers. Pagkatapos ay kailangan nating bawasan ang mga halimbawang halimbawang iyon mula sa aktwal na mga pagbasa upang makuha ang totoong mga pagbasa. Ang pagkakalibrate na ito ay kinakailangan upang hindi ito magpakita ng mga alerto hinggil sa normal na nakapalibot na mga pag-vibrate. Matapos makahanap ng totoong mga pagbabasa, ihinahambing ng Arduino ang mga halagang ito sa paunang natukoy na mga halagang max at min. Kung nahahanap ng Arduino ang anumang mga halaga ng pagbabago ay higit pa o mas kaunti sa mga paunang natukoy na halaga ng anumang axis sa parehong direksyon (negatibo at positibo) pagkatapos ay i-trigger ng Arduino ang buzzer at ipinapakita ang katayuan ng alerto sa 16x2 LCD at isang LED ay nakabukas din. Maaari naming ayusin ang pagkasensitibo ng taga-lindol ng detektor sa pamamagitan ng pagbabago ng mga Naunang natukoy na halaga sa Arduino code.

Ang Video ng Demonstrasyon at Arduino Code ay ibinibigay sa pagtatapos ng artikulo.

Paliwanag sa Circuit:

Circuit ng tagapagsiksik na ito ng Earthquake na Arduino Shield PCBsimple lang din. Sa proyektong ito, ginamit namin ang Arduino na nagbabasa ng boltahe ng analog ng accelerometer at binago ang mga ito sa mga digital na halaga. Hinihimok din ng Arduino ang buzzer, LED, 16x2 LCD at kinakalkula at ihambing ang mga halaga at gumawa ng naaangkop na aksyon. Susunod na bahagi ay ang Accelerometer na nakakakita ng panginginig ng lupa at bumubuo ng mga analog voltages sa 3 axes (X, Y, at Z). Ginagamit ang LCD para sa pagpapakita ng pagbabago ng axis ng X, Y at Z sa mga halaga at nagpapakita din ng mensahe ng alerto dito. Ang LCD na ito ay naka-attach sa Arduino sa 4-bit mode. Ang mga RS, GND, at EN pin ay direktang konektado sa 9, GND at 8 pin ng Arduino at natitirang 4 data pin ng LCD na katulad ng D4, D5, D6 at D7 ay direktang konektado sa digital pin 7, 6, 5 at 4 ng Arduino. Ang buzzer ay konektado sa pin 12 ng Arduino sa pamamagitan ng isang NPN BC547 transistor. Ginagamit din ang isang 10k na palayok para sa pagkontrol sa liwanag ng LCD.

Paliwanag sa Programming:

Sa Earthquake Detector na Arduino Shield, gumawa kami ng dalawang mga code: isa para sa Arduino upang makita ang isang lindol at isa pa para sa Processing IDE upang lagyan ng plano ang mga pagyanig ng lindol sa grap sa Computer. Malalaman namin ang tungkol sa parehong mga code isa-isa:

Arduino code:

Una sa lahat, kinakalkula namin ang accelerometer na may paggalang sa paglalagay nito sa ibabaw, upang hindi ito magpakita ng mga alerto hinggil sa normal na mga nakapaligid na panginginig nito. Sa pagkakalibrate na ito, kumukuha kami ng ilang mga sample at pagkatapos ay kumukuha ng average sa kanila at nag-iimbak sa isang variable.

para sa (int i = 0; i

Ngayon tuwing ang Accelerometer ay tumatagal ng mga pagbabasa, ibabawas namin ang mga halimbawang halimbawang iyon mula sa mga pagbasa upang mabalewala nito ang mga panginginig ng paligid.

int halaga1 = analogRead (x); // pagbabasa x out int halaga2 = analogRead (y); // pagbabasa y out int halaga3 = analogRead (z); // reading z out int xValue = xsample-value1; // paghahanap ng pagbabago sa x int yValue = ysample-value2; // paghahanap ng pagbabago sa y int zValue = zsample-value3; // paghahanap ng pagbabago sa z / * hindi pagtanggap ng pagbabago sa mga halagang x, y at z axis sa lcd * / lcd.setCursor (0,1); lcd.print (zValue); lcd.setCursor (6,1); lcd.print (yValue); lcd.setCursor (12,1); lcd.print (zValue); antala (100)

Pagkatapos ay ihinahambing ni Arduino ang mga na-calibrate (ibawas) na mga halaga sa mga paunang natukoy na mga limitasyon. At gumawa ng pagkilos nang naaayon. Kung ang mga halaga ay mas mataas kaysa sa paunang natukoy na mga halaga pagkatapos ito ay beep ng buzzer at lagyan ng lagay ang graph ng panginginig sa computer gamit ang Pagproseso.

/ * paghahambing ng pagbabago sa paunang natukoy na mga limitasyon * / if (xValue <minVal - xValue> maxVal - yValue <minVal - yValue> maxVal - zValue <minVal - zValue> maxVal) {if (buz == 0) start = millis (); // timer start buz = 1; // buzzer / led flag activated} iba pa kung (buz == 1) // buzzer flag na naaktibo pagkatapos ay nagbabala sa lindol {lcd.setCursor (0,0); lcd.print ("Lindol na Alerto"); kung (millis ()> = start + buzTime) buz = 0; }

Pagproseso ng code:

Sa ibaba ay naka-attach ang Processing Code, maaari mong i-download ang code mula sa ibaba na link:

Code ng Pagpoproseso ng Earth Quake Detector

Nagdisenyo kami ng isang grap na gumagamit ng Pagproseso, para sa mga pagyanig ng lindol, kung saan tinukoy namin ang laki ng window, mga yunit, laki ng font, background, nagbabasa at nagpapakita ng mga serial port, bukas na napiling serial port atbp.

// itakda ang laki ng window: at laki ng font f6 = createFont ("Arial", 6, true); f8 = createFont ("Arial", 8, totoo); f10 = createFont ("Arial", 10, totoo); f12 = createFont ("Arial", 12, totoo); f24 = createFont ("Arial", 24, totoo); laki (1200, 700); // Ilista ang lahat ng magagamit na mga serial port println (Serial.list ()); myPort = bagong Serial (ito, "COM43", 9600); println (myPort); myPort.bufferUntil ('\ n'); background (80)

Sa pagpapaandar sa ibaba, nakatanggap kami ng data mula sa serial port at kinukuha ang kinakailangang data at pagkatapos ay nai-map ito sa laki ng grap.

// pagkuha ng lahat ng kinakailangang halaga ng lahat ng tatlong axis: int l1 = inString.indexOf ("x =") + 2; String temp1 = inString.substring (l1, l1 + 3); l1 = inString.indexOf ("y =") + 2; String temp2 = inString.substring (l1, l1 + 3); l1 = inString.indexOf ("z =") + 2; String temp3 = inString.substring (l1, l1 + 3); // mapping x, y at z halaga na may mga sukat ng grap na lumutang saByte1 = float (temp1 + (char) 9); inByte1 = mapa (inByte1, -80,80, 0, taas-80); float inByte2 = float (temp2 + (char) 9); inByte2 = mapa (inByte2, -80,80, 0, taas-80); float inByte3 = float (temp3 + (char) 9); inByte3 = mapa (inByte3, -80,80, 0, taas-80); float x = mapa (xPos, 0,1120,40, lapad-40);

Pagkatapos nito, nagplano kami ng puwang ng unit, mga limitasyon ng max at min, mga halagang x, y at z-axis.

// ploting graph window, unit strokeWeight (2); stroke (175); Linya (0,0,0,100); textFont (f24); punan (0,00,255); textAlign (TAMA); xmargin ("EarthQuake Graph By Circuit Digest", 200,100); punan (100); strokeWeight (100); linya (1050,80,1200,80);………………

Pagkatapos nito ay binabalangkas namin ang mga halaga sa grap sa pamamagitan ng paggamit ng 3 magkakaibang mga kulay tulad ng Asul para sa halaga ng x-axis, berdeng kulay para sa y axis at z ay kinakatawan ng pulang kulay.

stroke (0,0,255); kung (y1 == 0) y1 = taas-inByte1-shift; linya (x, y1, x + 2, taas-inByte1-shift); y1 = taas-inByte1-shift; stroke (0,255,0); kung (y2 == 0) y2 = taas-inByte2-shift; linya (x, y2, x + 2, taas-inByte2-shift); y2 = taas-inByte2-shift; stroke (255,0,0); kung (y2 == 0) y3 = taas-inByte3-shift; linya (x, y3, x + 2, taas-inByte3-shift); y3 = taas-inByte3-shift;

Alamin din ang tungkol sa pagproseso sa pamamagitan ng pagdaan sa aming iba pang mga proyekto sa Pagproseso.

Circuit at Disenyo ng PCB gamit ang EasyEDA:

Ang EasyEDA ay hindi lamang ang one stop solution para sa pagkuha ng eskematiko, circuit simulation at disenyo ng PCB, nag-aalok din sila ng isang mababang gastos sa serbisyo ng PCB Prototype at Components Sourcing. Kamakailan ay inilunsad nila ang kanilang sangkap ng serbisyo sa sourcing kung saan mayroon silang malaking stock ng mga elektronikong sangkap at ang mga gumagamit ay maaaring mag-order ng kanilang mga kinakailangang sangkap kasama ang order ng PCB.

Habang dinidisenyo ang iyong mga circuit at PCB, maaari mo ring gawing pampubliko ang iyong mga disenyo ng circuit at PCB upang ang ibang mga gumagamit ay maaaring kopyahin o mai-edit ang mga ito at maaaring makinabang mula doon, ginawa rin naming pampubliko ang aming buong mga layout ng Circuit at PCB para sa Earthquake Indicator Shield na ito para sa Arduino UNO, suriin ang link sa ibaba:

easyeda.com/circuitdigest/EarthQuake_Detector-380c29e583b14de8b407d06ab0bbf70f

Nasa ibaba ang Snapshot ng Nangungunang layer ng layout ng PCB mula sa EasyEDA, maaari mong tingnan ang anumang Layer (Tuktok, Ibaba, Topsilk, bottomsilk atbp) ng PCB sa pamamagitan ng pagpili ng layer na bumubuo sa Window na 'Mga Layers'.

Maaari mo ring makita ang Photo view ng PCB gamit ang EasyEDA:

Pagkalkula at Pag-order ng Mga Sampol sa online:

Matapos makumpleto ang disenyo ng PCB, maaari mong i-click ang icon ng Fabrication output , na magdadala sa iyo sa pahina ng order ng PCB. Dito maaari mong tingnan ang iyong PCB sa Gerber Viewer o i-download ang mga Gerber file ng iyong PCB. Dito maaari mong piliin ang bilang ng mga PCB na nais mong mag-order, kung gaano karaming mga layer ng tanso ang kailangan mo, ang kapal ng PCB, bigat ng tanso, at maging ang kulay ng PCB. Matapos mong mapili ang lahat ng mga pagpipilian, i-click ang "I-save sa Cart" at kumpletuhin ang iyong order. Kamakailan lamang ay bumaba ang kanilang mga rate ng PCB nang malaki at ngayon ay maaari kang mag-order ng 10 pcs 2-layer PCB na may laki na 10cm x 10cm sa halagang $ 2 lamang.

Narito ang mga PCB na Nakuha Ko mula sa EasyEDA:

Nasa ibaba ang mga larawan ng panghuling Shield pagkatapos ng paghihinang ng mga sangkap sa PCB: