Erdbebenmelder Alarm mit Arduino

Ein Erdbeben ist eine unvorhersehbare Naturkatastrophe, die Leben und Eigentum schädigt. Es passiert plötzlich und wir können es nicht aufhalten, aber wir können darauf aufmerksam gemacht werden. In der heutigen Zeit gibt es viele Technologien, mit denen kleine Erschütterungen und Stöße erkannt werden können, damit wir vor einigen größeren Erdschwingungen Vorsichtsmaßnahmen treffen können. Hier verwenden wir den Beschleunigungsmesser ADXL335, um die Schwingungen vor dem Erdbeben zu erfassen. Der Beschleunigungsmesser ADXL335 ist zusammen mit allen drei Achsen sehr empfindlich gegen Erschütterungen und Vibrationen. Hier bauen wir einen Arduino-basierten Erdbebendetektor mit Beschleunigungsmesser.

Wir bauen diesen Erdbebendetektor hier als Arduino Shield auf der Leiterplatte und zeigen auch das Schwingungsdiagramm auf dem Computer mithilfe der Verarbeitung.

Erforderliche Komponenten:

Arduino UNO
Beschleunigungsmesser ADXL335
16x2 LCD
Summer
BC547 Transistor
1k Widerstände
10K POT
LED
Stromversorgung 9V / 12V
Berg klebt männlich / weiblich

Beschleunigungsmesser:

Pin Beschreibung des Beschleunigungsmessers:

Die Vcc 5 Volt Versorgung sollte an diesem Pin angeschlossen werden.
X-OUT Dieser Pin gibt einen Analogausgang in x-Richtung
Y-OUT Dieser Pin gibt einen Analogausgang in y-Richtung
Z-OUT Dieser Pin gibt einen Analogausgang in z-Richtung
GND Ground
ST Dieser Pin dient zum Einstellen der Empfindlichkeit des Sensors

Überprüfen Sie auch unsere anderen Projekte mit dem Beschleunigungsmesser:

Ping-Pong-Spiel mit Arduino
Handgestengesteuerter Roboter auf Beschleunigungsmesserbasis.
Arduino-basiertes Fahrzeugunfall-Warnsystem mit GPS, GSM und Beschleunigungsmesser

Arbeitserklärung:

Die Bedienung dieses Erdbebendetektors ist einfach. Wie bereits erwähnt, haben wir den Beschleunigungsmesser zum Erfassen von Erdbebenschwingungen entlang einer der drei Achsen verwendet, sodass der Beschleunigungsmesser bei auftretenden Schwingungen diese Schwingungen erfasst und in äquivalente ADC-Werte umwandelt. Dann werden diese ADC-Werte von Arduino gelesen und über das 16x2-LCD angezeigt. Wir haben diese Werte auch in Graph using Processing angezeigt. Erfahren Sie mehr über den Beschleunigungsmesser, indem Sie hier unsere anderen Beschleunigungsmesser-Projekte durchgehen.

Zuerst müssen wir den Beschleunigungsmesser kalibrieren, indem wir die Proben der Umgebungsschwingungen entnehmen, wenn Arduino hochfährt. Dann müssen wir diese Stichprobenwerte von den tatsächlichen Messwerten subtrahieren, um die tatsächlichen Messwerte zu erhalten. Diese Kalibrierung ist erforderlich, damit keine Warnungen in Bezug auf die normalen Umgebungsvibrationen angezeigt werden. Nachdem Arduino echte Messwerte gefunden hat, vergleicht er diese Werte mit vordefinierten Max- und Min-Werten. Wenn Arduino feststellt, dass die Änderungswerte mehr oder weniger als die vordefinierten Werte einer Achse in beiden Richtungen (negativ und positiv) sind, löst Arduino den Summer aus und zeigt den Alarmstatus über das 16x2-LCD an, und eine LED leuchtet ebenfalls auf. Wir können die Empfindlichkeit des Erdbebendetektors anpassen, indem wir die vordefinierten Werte im Arduino-Code ändern.

Demonstrationsvideo und Arduino-Code finden Sie am Ende des Artikels.

Schaltungserklärung:

Schaltung dieser Erdbebenmelder Arduino Shield PCBist auch einfach. In diesem Projekt haben wir Arduino verwendet, das die analoge Spannung des Beschleunigungsmessers liest und in digitale Werte umwandelt. Arduino steuert auch den Summer, die LED und das 16x2-LCD an, berechnet und vergleicht Werte und ergreift geeignete Maßnahmen. Der nächste Teil ist der Beschleunigungsmesser, der Erdschwingungen erfasst und analoge Spannungen in drei Achsen (X, Y und Z) erzeugt. Das LCD wird verwendet, um die Wertänderung der X-, Y- und Z-Achse anzuzeigen und darüber eine Warnmeldung anzuzeigen. Dieses LCD ist im 4-Bit-Modus an Arduino angeschlossen. RS-, GND- und EN-Pins sind direkt mit 9, GND und 8 Pins von Arduino verbunden, und die restlichen 4 Datenpins des LCD, nämlich D4, D5, D6 und D7, sind direkt mit den digitalen Pins 7, 6, 5 und 4 von Arduino verbunden. Der Summer ist über einen NPN BC547-Transistor mit Pin 12 von Arduino verbunden. Ein 10k-Topf wird auch zur Steuerung der Helligkeit des LCD verwendet.

Programmiererklärung:

In diesem Erdbebenmelder Arduino Shield haben wir zwei Codes erstellt: einen für Arduino zur Erkennung eines Erdbebens und einen für die Verarbeitung der IDE zur Darstellung der Erdbebenschwingungen über dem Diagramm auf dem Computer. Wir werden beide Codes nacheinander kennenlernen:

Arduino-Code:

Zunächst kalibrieren wir den Beschleunigungsmesser in Bezug auf seine Platzierungsfläche, damit keine Warnungen in Bezug auf seine normalen Umgebungsvibrationen angezeigt werden. Bei dieser Kalibrierung nehmen wir einige Proben und nehmen dann einen Durchschnitt davon und speichern sie in einer Variablen.

für (int i = 0; i

Wenn der Beschleunigungsmesser jetzt Messwerte erfasst, subtrahieren wir diese Probenwerte von den Messwerten, damit Umgebungsvibrationen ignoriert werden können.

int value1 = analogRead (x); // x auslesen int value2 = analogRead (y); // y auslesen int value3 = analogRead (z); // z auslesen int xValue = xsample-value1; // Änderung in x finden int yValue = ysample-value2; // Änderung in y finden int zValue = zsample-value3; // Änderung in z / * finden Änderung der x-, y- und z-Achsenwerte über lcd * / lcd.setCursor (0,1); lcd.print (zValue); lcd.setCursor (6,1); lcd.print (yValue); lcd.setCursor (12,1); lcd.print (zValue); Verzögerung (100)

Dann vergleicht Arduino diese kalibrierten (subtrahierten) Werte mit vordefinierten Grenzwerten. Und entsprechend handeln. Wenn die Werte höher als die vordefinierten Werte sind, piept der Summer und zeichnet das Vibrationsdiagramm mithilfe der Verarbeitung auf dem Computer auf.

/ * Vergleich der Änderung mit vordefinierten Grenzwerten * / if (xValue <minVal - xValue> maxVal - yValue <minVal - yValue> maxVal - zValue <minVal - zValue> maxVal) {if (buz == 0) start = Millis (); // Timer Start buz = 1; // Summer / LED-Flag aktiviert} else if (buz == 1) // Summer-Flag aktiviert, dann Erdbeben alarmieren {lcd.setCursor (0,0); lcd.print ("Erdbebenalarm"); if (millis ()> = start + buzTime) buz = 0; }}

Verarbeitungscode:

Unten ist der Verarbeitungscode beigefügt. Sie können den Code über den folgenden Link herunterladen:

Verarbeitungscode für Erdbebenmelder

Wir haben mithilfe von Processing ein Diagramm für Erdbebenvibrationen erstellt, in dem wir die Größe des Fensters, die Einheiten, die Schriftgröße, den Hintergrund, das Lesen und Anzeigen serieller Schnittstellen, das Öffnen ausgewählter serieller Schnittstellen usw. usw. definiert haben.

// setze die Fenstergröße: und Schriftgröße 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); Größe (1200, 700); // Alle verfügbaren seriellen Ports auflisten println (Serial.list ()); myPort = new Serial (dies ist "COM43", 9600); println (myPort); myPort.bufferUntil ('\ n'); Hintergrund (80)

In der folgenden Funktion haben wir Daten von der seriellen Schnittstelle empfangen, die erforderlichen Daten extrahiert und sie dann der Größe des Diagramms zugeordnet.

// Extrahieren aller erforderlichen Werte aller drei Achsen: 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); // Abbildung von x-, y- und z-Werten mit Diagrammdimensionen float inByte1 = float (temp1 + (char) 9); inByte1 = map (inByte1, -80,80, 0, height-80); float inByte2 = float (temp2 + (char) 9); inByte2 = map (inByte2, -80,80, 0, height-80); float inByte3 = float (temp3 + (char) 9); inByte3 = map (inByte3, -80,80, 0, height-80); float x = map (xPos, 0,1120,40, width-40);

Danach haben wir den Einheitsraum, die maximalen und minimalen Grenzen, die Werte der x-, y- und z-Achse aufgetragen.

// Diagrammfenster zeichnen, Einheit SchlaganfallWeight (2); Schlaganfall (175); Linie (0,0,0,100); textFont (f24); füllen (0,00,255); textAlign (RECHTS); xmargin ("EarthQuake Graph By Circuit Digest", 200.100); füllen (100); Schlaganfallgewicht (100); Linie (1050, 80, 1200, 80);………………

Danach zeichnen wir die Werte über das Diagramm, indem wir 3 verschiedene Farben als Blau für den Wert der x-Achse, grüne Farbe für die y-Achse und z durch rote Farbe darstellen.

Hub (0,0,255); if (y1 == 0) y1 = height-inByte1-shift; Linie (x, y1, x + 2, Höhe-in-Byte1-Verschiebung); y1 = Höhe-in-Byte1-Verschiebung; Hub (0,255,0); if (y2 == 0) y2 = height-inByte2-shift; Linie (x, y2, x + 2, Höhe-in-Byte2-Verschiebung); y2 = Höhe-in-Byte2-Verschiebung; Schlaganfall (255,0,0); if (y2 == 0) y3 = height-inByte3-shift; Linie (x, y3, x + 2, Höhe-in-Byte3-Verschiebung); y3 = Höhe-in-Byte3-Verschiebung;

Erfahren Sie auch mehr über die Verarbeitung, indem Sie unsere anderen Verarbeitungsprojekte durchgehen.

Schaltungs- und Leiterplattendesign mit EasyEDA:

EasyEDA ist nicht nur die One-Stop-Lösung für die schematische Erfassung, Schaltungssimulation und das PCB-Design, sondern bietet auch einen kostengünstigen Service für die Beschaffung von PCB-Prototypen und -Komponenten. Sie haben kürzlich ihren Komponentenbeschaffungsservice gestartet, bei dem sie über einen großen Bestand an elektronischen Komponenten verfügen und Benutzer ihre erforderlichen Komponenten zusammen mit der Leiterplattenbestellung bestellen können.

Während Sie Ihre Schaltkreise und Leiterplatten entwerfen, können Sie auch Ihre Schaltkreis- und Leiterplattenentwürfe veröffentlichen, damit andere Benutzer sie kopieren oder bearbeiten und davon profitieren können. Wir haben auch unsere gesamten Schaltkreis- und Leiterplattenlayouts für dieses Erdbebenindikatorschild veröffentlicht Arduino UNO, überprüfen Sie den folgenden Link:

easyeda.com/circuitdigest/EarthQuake_Detector-380c29e583b14de8b407d06ab0bbf70f

Unten finden Sie den Schnappschuss der obersten Ebene des PCB-Layouts von EasyEDA. Sie können jede Ebene (oben, unten, Oberschicht, untere Seide usw.) der Leiterplatte anzeigen, indem Sie die Ebene aus dem Fenster "Ebenen" auswählen.

Sie können die Fotoansicht der Leiterplatte auch mit EasyEDA anzeigen:

Muster online berechnen und bestellen:

Nachdem Sie das Design der Leiterplatte abgeschlossen haben, können Sie auf das Symbol der Fertigungsausgabe klicken, um zur Bestellseite für die Leiterplatte zu gelangen. Hier können Sie Ihre Platine im Gerber Viewer anzeigen oder Gerber-Dateien von Ihrer Platine herunterladen. Hier können Sie die Anzahl der zu bestellenden Leiterplatten, die Anzahl der benötigten Kupferschichten, die Leiterplattendicke, das Kupfergewicht und sogar die Leiterplattenfarbe auswählen. Nachdem Sie alle Optionen ausgewählt haben, klicken Sie auf "In Warenkorb speichern" und schließen Sie Ihre Bestellung ab. Vor kurzem haben sie ihre Leiterplattenraten deutlich gesenkt und jetzt können Sie 10 Stück 2-lagige Leiterplatten mit einer Größe von 10 cm x 10 cm nur für 2 US-Dollar bestellen.

Hier sind die Leiterplatten, die ich von EasyEDA erhalten habe:

Unten sehen Sie die Bilder von Final Shield nach dem Löten der Komponenten auf der Leiterplatte: