Jordbävningsdetektorlarm med arduino

En jordbävning är en oförutsägbar naturkatastrof som orsakar skador på liv och egendom. Det händer plötsligt och vi kan inte stoppa det men vi kan larmas från det. I dagens tid finns det många tekniker som kan användas för att upptäcka små skakningar och slag, så att vi kan vidta försiktighetsåtgärder före några stora vibrationer i jorden. Här använder vi Accelerometer ADXL335 för att detektera vibrationerna före jordbävningen. Accelerometer ADXL335 är mycket känslig för skakningar och vibrationer tillsammans med alla de tre axlarna. Här bygger vi en Arduino-baserad jordbävningsdetektor med hjälp av Accelerometer.

Vi bygger här den här jordbävningsdetektorn som en Arduino Shield på PCB och kommer också att visa vibrationsdiagrammet på datorn med Processing.

Komponenter som krävs:

Arduino UNO
Accelerometer ADXL335
16x2 LCD
Summer
BC547 transistor
1k motstånd
10K POT
LED
Strömförsörjning 9v / 12v
Berg pinnar man / kvinna

Accelerometer:

Stift Beskrivning av accelerometer:

Vcc 5 volt matning ska anslutas vid denna stift.
X-OUT Denna stift ger en analog utgång i x-riktning
Y-UT Denna stift ger en analog utgång i y-riktning
Z-OUT Denna stift ger en analog utgång i z-riktning
GND Ground
ST Denna stift används för att ställa in sensorns känslighet

Kontrollera även våra andra projekt med Accelerometer:

Ping Pong Game med Arduino
Accelerometerbaserad handstyrd robot.
Arduino-baserat varningssystem för bilolyckor med GPS, GSM och accelerometer

Arbetsförklaring:

Att arbeta med denna jordbävningsdetektor är enkelt. Som vi nämnde tidigare har vi använt Accelerometer för att detektera jordbävningsvibrationer längs någon av de tre axlarna så att när vibrationer uppstår känner accelerometer av vibrationer och omvandlar dem till motsvarande ADC-värde. Därefter läses dessa ADC-värden av Arduino och visas över 16x2 LCD-skärmen. Vi har också visat dessa värden på Graph med hjälp av Processing. Läs mer om Accelerometer genom att gå igenom våra andra Accelerometer-projekt här.

Först måste vi kalibrera accelerometern genom att ta proverna av omgivande vibrationer när Arduino startar. Sedan måste vi subtrahera dessa provvärden från de faktiska avläsningarna för att få de verkliga avläsningarna. Denna kalibrering behövs så att den inte visar varningar med avseende på dess normala vibrationer. Efter att ha hittat riktiga avläsningar jämför Arduino dessa värden med fördefinierade max- och minvärden. Om Arduino hittar några ändringsvärden är mer än eller mindre än de fördefinierade värdena för vilken axel som helst i båda riktningarna (negativ och positiv), så utlöser Arduino summern och visar statusen för varningen över 16x2 LCD-skärmen och en LED tänds också också. Vi kan justera känsligheten för jordbävningsdetektorn genom att ändra de fördefinierade värdena i Arduino-koden.

Demonstrationsvideo och Arduino-kod ges i slutet av artikeln.

Kretsförklaring:

Krets för denna jordbävningsdetektor Arduino Shield PCBär också enkelt. I detta projekt har vi använt Arduino som läser accelerometerns analoga spänning och omvandlar dem till de digitala värdena. Arduino driver också summer, LED, 16x2 LCD och beräknar och jämför värden och vidtar lämpliga åtgärder. Nästa del är Accelerometer som detekterar jordvibrationer och genererar analoga spänningar i 3 axlar (X, Y och Z). LCD används för att visa X-, Y- och Z-axelns förändring av värden och även visa varningsmeddelande över den. Denna LCD är ansluten till Arduino i 4-bitars läge. RS-, GND- och EN-stift är direkt anslutna till 9, GND och 8 stift av Arduino och resten av 4 datapinnar på LCD, nämligen D4, D5, D6 och D7 är direkt anslutna till digitala stift 7, 6, 5 och 4 i Arduino. Summern är ansluten till stift 12 i Arduino via en NPN BC547-transistor. En 10k-kruka används också för att styra LCD-skärmens ljusstyrka.

Programmeringsförklaring:

I den här jordbävningsdetektorn Arduino Shield har vi gjort två koder: en för Arduino för att upptäcka en jordbävning och en annan för bearbetning av IDE för att plotta jordbävningsvibrationerna över grafen på datorn. Vi kommer att lära oss om båda koderna en efter en:

Arduino-kod:

Först och främst kalibrerar vi accelerometern med avseende på dess placeringsyta, så att den inte visar varningar med avseende på dess normala vibrationer. I den här kalibreringen tar vi några prover och tar sedan ett genomsnitt av dem och lagrar i en variabel.

för (int i = 0; i

Nu när Accelerometer tar avläsningar subtraherar vi dessa provvärden från avläsningarna så att den kan ignorera omgivningsvibrationer.

int-värde1 = analogRead (x); // läser x ut int värde2 = analogRead (y); // läser ut y-värde3 = analogRead (z); // läser z ut int xValue = xsample-value1; // hitta förändring i x int yValue = ysample-value2; // hitta förändring i y int zValue = zsample-value3; // hitta förändring i z / * förskjutning av förändring i x-, y- och z-axelvärden över lcd * / lcd.setCursor (0,1); lcd.print (zValue); lcd.setCursor (6,1); lcd.print (yValue); lcd.setCursor (12,1); lcd.print (zValue); fördröjning (100)

Sedan jämför Arduino de kalibrerade (subtraherade) värdena med fördefinierade gränser. Och vidta åtgärder därefter. Om värdena är högre än fördefinierade värden piper det summern och plottar vibrationsdiagrammet på datorn med hjälp av Processing.

/ * jämför förändring med fördefinierade gränser * / if (xValue <minVal - xValue> maxVal - yValue <minVal - yValue> maxVal - zValue <minVal - zValue> maxVal) {if (buz == 0) start = millis (); // timer start buz = 1; // summer / led-flagga aktiverad} annat om (buz == 1) // summer-flagga aktiverad och varnar jordbävningen {lcd.setCursor (0,0); lcd.print ("Earthquake Alert"); om (millis ()> = start + buzTime) buz = 0; }

Bearbetningskod:

Nedan följer behandlingskoden bifogad, du kan ladda ner koden från länken nedan:

Bearbetningskod för jordbävningsdetektor

Vi har utformat en graf med bearbetning för jordbävningsvibrationer, där vi definierade storleken på fönstret, enheter, teckensnittsstorlek, bakgrund, läsning och visning av seriella portar, öppnad vald seriell port etc.

// ställa in fönsterstorlek: och teckensnittsstorlek f6 = createFont ("Arial", 6, true); f8 = createFont ("Arial", 8, true); f10 = createFont ("Arial", 10, true); f12 = createFont ("Arial", 12, true); f24 = createFont ("Arial", 24, true); storlek (1200, 700); // Lista alla tillgängliga seriella portar println (Serial.list ()); myPort = ny serie (detta, "COM43", 9600); println (myPort); myPort.bufferUntil ('\ n'); bakgrund (80)

I funktionen nedan har vi tagit emot data från seriell port och extraherat nödvändiga data och sedan kartlagt den med storleken på grafen.

// extrahera alla nödvändiga värden på alla tre axlarna: int l1 = inString.indexOf ("x =") + 2; Sträng temp1 = inString.substring (l1, l1 + 3); l1 = inString.indexOf ("y =") + 2; Sträng temp2 = inString.substring (l1, l1 + 3); l1 = inString.indexOf ("z =") + 2; Sträng temp3 = inString.substring (l1, l1 + 3); // mappning av x-, y- och z-värde med diagramdimensioner float inByte1 = float (temp1 + (char) 9); inByte1 = karta (inByte1, -80,80, 0, höjd-80); float inByte2 = float (temp2 + (char) 9); inByte2 = karta (inByte2, -80,80, 0, höjd-80); float inByte3 = float (temp3 + (char) 9); inByte3 = karta (inByte3, -80,80, 0, höjd-80); flottör x = karta (xPos, 0,1120,40, bredd-40);

Efter detta har vi plottat enhetsutrymme, max- och mingränser, värden på x, y och z-axeln.

// ritningsdiagramfönster, enhets strokeWeight (2); stroke (175); Linje (0,0,0,100); textFont (f24); fyll (0,00255); textAlign (HÖGER); xmargin ("EarthQuake Graph By Circuit Digest", 200,100); fyll (100); strokeWeight (100); linje (1050,80,1200,80);………………

Efter detta plottar vi värdena över diagrammet med 3 olika färger som blått för x-axelvärde, grön färg för y-axeln och z representeras av röd färg.

stroke (0,0,255); om (y1 == 0) y1 = höjd-inByte1-skift; linje (x, y1, x + 2, höjd-inByte1-skift); y1 = höjd-inByte1-skift; stroke (0,255,0); om (y2 == 0) y2 = höjd-inByte2-shift; linje (x, y2, x + 2, höjd-inByte2-skift); y2 = höjd-inByte2-shift; stroke (255,0,0); om (y2 == 0) y3 = höjd-inByte3-skift; linje (x, y3, x + 2, höjd-inByte3-skift); y3 = höjd-inByte3-shift;

Lär dig också mer om bearbetning genom att gå igenom våra andra bearbetningsprojekt.

Krets- och kretskortsdesign med EasyEDA:

EasyEDA är inte bara enstanslösning för schematisk infångning, kretssimulering och PCB-design, de erbjuder också en låg kostnad PCB-prototyp och Components Sourcing-tjänst. De lanserade nyligen sin komponentinköpstjänst där de har ett stort lager av elektroniska komponenter och användare kan beställa sina komponenter tillsammans med PCB-beställningen.

Medan du designar dina kretsar och kretskort kan du också göra din krets- och kretskortsdesign offentlig så att andra användare kan kopiera eller redigera dem och dra nytta av det, vi har också gjort hela krets- och kretskortlayouterna offentliga för denna jordbävningsindikatorsköld för Arduino UNO, kolla länken nedan:

easyeda.com/circuitdigest/EarthQuake_Detector-380c29e583b14de8b407d06ab0bbf70f

Nedan är ögonblicksbilden av toppskiktet av PCB-layout från EasyEDA, du kan se vilket lager som helst (Top, Bottom, Topsilk, bottomsilk etc) på PCB genom att välja lagret från 'Layers' Window.

Du kan också se fotovy av PCB med EasyEDA:

Beräkning och beställning av prover online:

Efter att ha slutfört designen av PCB kan du klicka på ikonen för Fabrication-utdata , som tar dig till PCB-beställningssidan. Här kan du se din PCB i Gerber Viewer eller ladda ner Gerber-filer på din PCB. Här kan du välja antalet PCB du vill beställa, hur många kopparlager du behöver, PCB-tjockleken, kopparvikten och till och med PCB-färgen. När du har valt alla alternativ klickar du på "Spara i kundvagn" och slutför din beställning. Nyligen har de tappat sina PCB-priser avsevärt och nu kan du beställa 10 st 2-lager PCB med 10 cm x 10 cm storlek bara för $ 2.

Här är de kretskort som jag fick från EasyEDA:

Nedan visas bilderna på final Shield efter lödning av komponenterna på PCB: