Salve su vida con el monitor de colapso de edificios: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Analice estructuras de hormigón, metal y madera en busca de curvas y ángulos y avise si se han desviado de la posición original.

Paso 1: Introducción

Con el desarrollo del campo de la ingeniería civil, podemos identificar muchas construcciones en todas partes. Estructuras metálicas, Vigas de hormigón, Edificios multiplataforma son algunos de ellos. Además, la mayoría de nosotros estamos acostumbrados a permanecer en un edificio o en una casa durante la mayor parte del día. Pero, ¿cómo podemos asegurarnos de que el edificio sea lo suficientemente seguro para permanecer? ¿Qué pasa si hay una pequeña grieta o una viga demasiado inclinada en su edificio? Arriesgaría cientos de vidas.

Terremotos, dureza del suelo, tornados y muchas cosas más, podrían ser factores de grietas internas y la desviación de las estructuras o vigas de la posición neutra. La mayoría de las veces no somos conscientes de la situación de las estructuras circundantes. Tal vez el lugar en el que entramos todos los días tiene vigas de concreto agrietadas y puede colapsar en cualquier momento. Pero sin saberlo estamos entrando libremente. Como solución para esto, necesitamos un buen método para monitorear vigas de concreto, madera, metal de las construcciones donde no podemos llegar.

Paso 2: solución

"Structure Analyzer" es un dispositivo portátil que se puede montar en una viga de hormigón, estructura metálica, losas, etc. Este dispositivo mide el ángulo y analiza las curvas donde está montado y envía los datos a la aplicación móvil a través de Bluetooth. Este dispositivo usa un acelerómetro / giroscopio para medir el ángulo en los planos x, y, z y un sensor de flexión para monitorear las curvas. Todos los datos sin procesar se procesan y la información se envía a la aplicación móvil.

Paso 3: circuito

Recopile los siguientes componentes.

• Tablero Arduino 101
• 2 X sensores Flex
• 2 resistencias de 10k

Para reducir la cantidad de componentes, aquí se utiliza la placa Arduino 101, ya que contiene un acelerómetro y un módulo BLE. Los sensores de flexión se utilizan para medir la cantidad de flexión a medida que cambia su resistencia al doblarse. El circuito es muy pequeño ya que solo se necesitaban conectar 2 resistencias y 2 sensores flexibles. El siguiente diagrama muestra cómo conectar un sensor flexible a la placa Arduino.

Un pin de la resistencia está conectado al pin A0 de la placa Arduino. Siga el mismo procedimiento para conectar el segundo sensor flexible. Utilice el pin A1 para conectar la resistencia.

Conecte el zumbador directamente al pin D3 y al pin Gnd.

Paso 4: Finalización del dispositivo

Después de realizar el circuito, hay que fijarlo dentro de un recinto. De acuerdo con el modelo 3D anterior, se deben colocar 2 sensores flexibles en el lado opuesto del gabinete. Deje espacio para que el puerto USB programe la placa y suministre energía. Como este dispositivo debe utilizarse durante un período prolongado, el mejor método para suministrar energía es utilizar un paquete de energía fijo.

Paso 5: aplicación móvil

Descargue e instale Blynk desde la Play Store de Android. Inicie un nuevo proyecto para Arduino 101. Seleccione el método de comunicación como BLE. Agregue 1 terminal, 2 botones y BLE a la interfaz. Las siguientes imágenes le muestran cómo hacer la interfaz.

Paso 6: archivos de código Blynk

Después de realizar la interfaz en Blynk, recibirá un código de autorización. Ingrese ese código en el siguiente lugar.

#include #include char auth = "**************"; // Código de autorización de Blynk

Terminal WidgetTerminal (V2);

BLEPeripheral blePeripheral;

En el proceso de calibración, las lecturas actuales del sensor se guardan en la EEPROM.

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

EEPROM.write (1, flx2);

EEPROM.write (2, x);

EEPROM.write (3, y);

EEPROM.write (4, z);

terminal.print ("Calibración exitosa");

Después de la calibración, el dispositivo comparará la desviación con los valores de umbral y emite un pitido si superan el valor.

valores(); if (abs (flex1-m_flx1)> 10 o abs (flex2-m_flx2)> 10) {

terminal.println ("Over Bend");

tono (zumbador, 1000);

}

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

terminal.println ("Inclinado excesivo");

tono (zumbador, 1000);

}

Paso 7: funcionalidad

Pegue el dispositivo a la estructura que necesita ser monitoreada. Pegue también los 2 sensores flexibles. Suministre energía a la placa mediante el cable USB.

Abra la interfaz de Blynk. Conéctese con el dispositivo tocando el icono de Bluetooth. Presione el botón de calibración. Después de calibrar, el terminal mostrará un mensaje como "Calibrado exitosamente". Reinicie el dispositivo. Ahora controlará la estructura y le notificará a través del zumbador si se desvía o deforma. Puede comprobar los valores de ángulo y curvatura en cualquier momento pulsando el botón Estado. Puede parecer un dispositivo pequeño. Pero sus usos no tienen precio. A veces nos olvidamos de comprobar el estado de nuestro hogar, oficina, etc., con nuestras ocupadas agendas. Pero si hay un pequeño problema, podría terminar como en la figura anterior.

Pero con este dispositivo, se pueden salvar cientos de vidas informando los pequeños pero peligrosos problemas en las construcciones.

Paso 8: Archivo de código Arduino101

#define BLYNK_PRINT Serie

#define flex1 A0

#define flex2 A1 // Definir el sensor flexible y los pines del zumbador

#define zumbador 3

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

#include "CurieBLE.h"

#include "Wire.h"

#include "EEPROM.h"

#include "SPI.h"

char auth = "**************"; // Terminal WidgetTerminal del código de autorización de Blynk (V2);

BLEPeripheral blePeripheral;

int m_flx1, m_flx2, m_x, m_y, m_z; // valores guardados en la memoria

int flx1, flx2, x, y, z; // Lecturas actuales

valores vacíos () {para (int i = 0; i <100; i ++) {

flx1 = analogRead (flex1); // Obtenga lecturas sin procesar de los sensores

flx2 = analogRead (flex2);

x = CurieIMU.readAccelerometer (X_AXIS) / 100;

y = CurieIMU.readAccelerometer (Y_AXIS) / 100;

z = CurieIMU.readAccelerometer (Z_AXIS) / 100;

retraso (2);

}

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

x = x / 100; // Obtener los valores medios de las lecturas

y = y / 100;

z = z / 100;

}

configuración vacía () {// pinMode (3, SALIDA);

pinMode (flex1, ENTRADA);

pinMode (flex2, ENTRADA); // Configuración de los modos de los pines del sensor

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); // Leer valores de sensor guardados previamente de EEPROM

m_y = EEPROM.read (3);

m_z = EEPROM.read (4);

}

bucle vacío () {Blynk.run ();

blePeripheral.poll ();

valores();

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

tono (zumbador, 1000);

}

if (abs (x-m_x)> 15 o abs (y-m_y)> 15 o abs (z-m_z)> 15) {terminal.println ("Over Inclined");

tono (zumbador, 1000);

}

tono (zumbador, 0);

}

/ * VO indica el modo de calibración. En este modo, los valores de los sensores * se guardan en la EEPROM

*/

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

if (pinValue == 1) {

valores();

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

EEPROM.write (2, x);

EEPROM.write (3, y);

EEPROM.write (4, z);

terminal.print ("Calibración exitosa");

}

}

/ * Podemos solicitar valores de desviación actuales * presionando el botón V1

*/

BLYNK_WRITE (V1) {

int pinValue = param.asInt ();

if (pinValue == 1) {

valores(); terminal.print ("Desviación del ángulo X-");

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

terminal.println ();

terminal.print ("Desviación del ángulo Y-");

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

terminal.println ();

terminal.print ("Desviación del ángulo Z-");

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

terminal.println ();

terminal.print ("Desviación Flex 1-");

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

terminal.println ();

terminal.print ("Desviación Flex 2-");

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

terminal.println ();

}

}

BLYNK_WRITE (V2) {

}