Salvați-vă viața cu monitorul Collapse Building: 8 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Analizați structurile din beton, metal, lemn pentru coturi și unghiuri și alerte dacă acestea s-au abătut de la poziția inițială.

Pasul 1: Introducere

Odată cu dezvoltarea domeniului ingineriei civile, putem identifica o mulțime de construcții peste tot. Structuri metalice, grinzi de beton, clădiri cu mai multe platforme sunt unele dintre ele. Mai mult, majoritatea dintre noi suntem obișnuiți să rămânem într-o clădire sau acasă în majoritatea momentelor zilei. Dar cum putem asigura că clădirea este suficient de sigură pentru a rămâne? Ce se întâmplă dacă există o mică fisură sau o grindă supra-înclinată în clădirea dvs.? Ar risca sute de vieți.

Cutremurele, duritatea solului, tornadele și multe altele, ar putea fi factori pentru fisurile interne și abaterea structurilor sau a grinzilor de la poziția neutră. De cele mai multe ori nu suntem conștienți de situația structurilor înconjurătoare. Poate că locul în care mergem în fiecare zi are grinzi de beton crăpate și se poate prăbuși oricând. Dar, fără să știm, intrăm liber în interior. Ca soluție pentru aceasta, avem nevoie de o metodă bună pentru a monitoriza betonul, lemnul, grinzile metalice ale construcțiilor la care nu putem ajunge.

Pasul 2: Soluție

„Structure Analyzer” este un dispozitiv portabil care poate fi montat pe o grindă de beton, o structură metalică, plăci etc. Acest dispozitiv măsoară unghiul și analizează îndoirile în care este montat și trimite datele către aplicația mobilă prin Bluetooth. Acest dispozitiv utilizează un accelerometru / giroscop pentru a măsura unghiul în planurile x, y, z și senzorul flex pentru a monitoriza îndoirile. Toate datele brute sunt procesate și informațiile sunt trimise către aplicația mobilă.

Pasul 3: Circuit

Colectați următoarele componente.

• Placa Arduino 101
• 2 senzori X Flex
• 2 rezistențe X 10k

Pentru a reduce numărul de componente se utilizează aici placa Arduino 101 deoarece conține un accelerometru și un modul BLE. Senzorii flex sunt folosiți pentru a măsura cantitatea de îndoire, deoarece își schimbă rezistența la îndoire. Circuitul este unul foarte mic deoarece doar 2 rezistențe și 2 senzori flexori trebuie conectați. Următoarea diagramă arată cum să conectați un senzor flex la placa Arduino.

Un pin al rezistorului este conectat la pinul A0 al plăcii Arduino. Urmați aceeași procedură pentru a conecta al doilea senzor flex. Utilizați pinul A1 pentru a conecta rezistorul.

Conectați buzzerul direct la pinul D3 și pinul Gnd.

Pasul 4: Finalizarea dispozitivului

După realizarea circuitului, acesta trebuie fixat în interiorul unei incinte. Conform modelului 3D de mai sus, 2 senzori flex trebuie plasați în partea opusă a carcasei. Faceți spațiu pentru portul USB pentru a programa placa și a furniza energie. Deoarece acest dispozitiv trebuie utilizat pentru o perioadă lungă de timp, cea mai bună metodă de alimentare este utilizarea unui pachet de alimentare fix.

Pasul 5: aplicație mobilă

Descărcați și instalați Blynk din Android Play Store. Porniți un nou proiect pentru Arduino 101. Selectați metoda de comunicare ca BLE. Adăugați 1 terminal, 2 butoane și BLE la interfață. Următoarele imagini vă arată cum să creați interfața.

Pasul 6: Fișiere de cod Blynk

După realizarea interfeței pe Blynk veți primi un cod de autorizare. Introduceți acel cod la următoarea locație.

#include #include char auth = "**************"; // Cod de autorizare Blynk

Terminal WidgetTerminal (V2);

BLEPeripheral blePeripheral;

În procesul de calibrare, citirile curente ale senzorului sunt salvate în EEPROM.

valori (); EEPROM.write (0, flx1);

EEPROM.write (1, flx2);

EEPROM.write (2, x);

EEPROM.write (3, y);

EEPROM.write (4, z);

terminal.print („Calibrarea reușită”);

După calibrare, dispozitivul va compara abaterea cu valorile de prag și va emite un semnal sonor dacă acestea depășesc valoarea.

valori (); if (abs (flex1-m_flx1)> 10 sau abs (flex2-m_flx2)> 10) {

terminal.println ("Over Bend");

ton (buzzer, 1000);

}

if (abs (x-m_x)> 15 sau abs (y-m_y)> 15 sau abs (z-m_z)> 15) {

terminal.println ("Peste înclinat");

ton (buzzer, 1000);

}

Pasul 7: Funcționalitate

Lipiți dispozitivul de structura necesară monitorizării. Lipiți și cei 2 senzori flex. Alimentați placa folosind cablul USB.

Deschideți interfața Blynk. Conectați-vă cu dispozitivul atingând pictograma Bluetooth. Apăsați butonul de calibrare. După calibrare, terminalul va afișa un mesaj „Calibrat cu succes”. Resetați dispozitivul. Acum va monitoriza structura și vă va anunța prin buzzer dacă se abate de la deformare. Puteți verifica oricând valorile unghiului și îndoirii apăsând butonul Status. Acest lucru ar putea arăta ca un dispozitiv mic. Dar utilizările sale sunt neprețuite. Uneori uităm să verificăm starea casei noastre, a biroului etc., cu programele noastre ocupate. Dar dacă există o mică problemă, s-ar putea termina ca în figura de mai sus.

Dar cu acest dispozitiv, sute de vieți pot fi salvate prin informarea problemelor mici, dar periculoase din construcții.

Pasul 8: fișier de cod Arduino101

#define BLYNK_PRINT Serial

#define flex1 A0

#define flex2 A1 // Definiți senzorul flex și pinii buzzerului

#define buzzer 3

#include "CurieIMU.h" #include "BlynkSimpleCurieBLE.h"

#include „CurieBLE.h”

#include „Wire.h”

#include „EEPROM.h”

#includeți „SPI.h”

char auth = "**************"; // Blynk Authorization Code WidgetTerminal terminal (V2);

BLEPeripheral blePeripheral;

int m_flx1, m_flx2, m_x, m_y, m_z; // valori salvate în memorie

int flx1, flx2, x, y, z; // Citiri curente

valori nule () {pentru (int i = 0; i <100; i ++) {

flx1 = analogRead (flex1); // Obțineți citiri brute de la senzori

flx2 = analogRead (flex2);

x = CurieIMU.readAccelerometer (X_AXIS) / 100;

y = CurieIMU.readAccelerometer (Y_AXIS) / 100;

z = CurieIMU.readAccelerometer (Z_AXIS) / 100;

întârziere (2);

}

flx1 = flx1 / 100; flx2 = flx2 / 100;

x = x / 100; // Obțineți valorile medii ale citirilor

y = y / 100;

z = z / 100;

}

void setup () {// pinMode (3, OUTPUT);

pinMode (flex1, INPUT);

pinMode (flex2, INPUT); // Setarea modurilor pinului senzorului

Serial.begin (9600);

blePeripheral.setLocalName ("Arduino101Blynk"); blePeripheral.setDeviceName ("Arduino101Blynk");

blePeripheral.setAppearance (384);

Blynk.begin (auth, blePeripheral);

blePeripheral.begin ();

m_flx1 = EEPROM.read (0); m_flx2 = EEPROM.read (1);

m_x = EEPROM.read (2); // Citiți valorile senzorului pre-salvate din EEPROM

m_y = EEPROM.read (3);

m_z = EEPROM.read (4);

}

bucla void () {Blynk.run ();

blePeripheral.poll ();

valori ();

if (abs (flex1-m_flx1)> 10 sau abs (flex2-m_flx2)> 10) {terminal.println ("Over Bend");

ton (buzzer, 1000);

}

if (abs (x-m_x)> 15 sau abs (y-m_y)> 15 sau abs (z-m_z)> 15) {terminal.println ("Peste înclinat");

ton (buzzer, 1000);

}

ton (buzzer, 0);

}

/ * VO indică modul de calibrare. În acest mod, valorile senzorilor * sunt salvate în EEPROM

*/

BLYNK_WRITE (V0) {int pinValue = param.asInt ();

if (pinValue == 1) {

valori ();

EEPROM.write (0, flx1); EEPROM.write (1, flx2);

EEPROM.write (2, x);

EEPROM.write (3, y);

EEPROM.write (4, z);

terminal.print („Calibrarea reușită”);

}

}

/ * Putem solicita valorile curente ale abaterii * apăsând butonul V1

*/

BLYNK_WRITE (V1) {

int PinValue = param.asInt ();

if (pinValue == 1) {

valori (); terminal.print ("deviația unghiului X");

terminal.print (abs (x-m_x));

terminal.println ();

terminal.print ("deviația unghiului Y");

terminal.print (abs (y-m_y));

terminal.println ();

terminal.print ("deviația unghiului Z");

terminal.print (abs (z-m_z));

terminal.println ();

terminal.print ("deviația Flex 1");

terminal.print (abs (flx1-m_flx1));

terminal.println ();

terminal.print („Flex 2 deviation-”);

terminal.print (abs (flx2-m_flx2));

terminal.println ();

}

}

BLYNK_WRITE (V2) {

}