Salve sua vida com o monitor de colapso de edifícios: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Analise estruturas de concreto, metal e madeira quanto a curvas e ângulos e alerte se elas se desviaram da posição original.

Etapa 1: Introdução

Com o desenvolvimento do campo da engenharia civil, podemos identificar muitas construções em todos os lugares. Estruturas metálicas, vigas de concreto, edifícios multiplataformas são alguns deles. Além disso, a maioria de nós está acostumada a ficar em um prédio ou em casa durante a maior parte do dia. Mas como podemos garantir que o prédio é seguro o suficiente para ficar? E se houver uma pequena rachadura ou viga inclinada em seu prédio? Isso arriscaria centenas de vidas.

Terremotos, dureza do solo, tornados e muito mais, podem ser fatores para fissuras internas e o desvio das estruturas ou vigas da posição neutra. Na maioria das vezes não temos conhecimento da situação das estruturas circundantes. Talvez o lugar em que entramos todos os dias tenha vigas de concreto rachadas e possa desabar a qualquer momento. Mas sem sabermos entramos livremente. Como solução para isso, precisamos de um bom método para monitorar vigas de concreto, madeira, metal de construções onde não podemos chegar.

Etapa 2: Solução

“Structure Analyzer” é um dispositivo portátil que pode ser montado em uma viga de concreto, estrutura metálica, lajes etc. Este dispositivo mede o ângulo e analisa as curvas onde está montado e envia os dados para o aplicativo móvel através de Bluetooth. Este dispositivo usa um acelerômetro / giroscópio para medir o ângulo nos planos x, y, z e sensor flexível para monitorar as curvas. Todos os dados brutos são processados e as informações são enviadas para o aplicativo móvel.

Etapa 3: circuito

Colete os seguintes componentes.

• Placa Arduino 101
• 2 sensores flexíveis
• 2 resistores de 10k

Para reduzir o número de componentes, a placa Arduino 101 é usada aqui, pois contém um acelerômetro e um módulo BLE. Sensores flex são usados para medir a quantidade de flexão conforme muda sua resistência ao dobrar. O circuito é muito pequeno, pois apenas 2 resistores e 2 sensores flex precisam ser conectados. O diagrama a seguir mostra como conectar um sensor flex à placa Arduino.

Um pino do resistor é conectado ao pino A0 da placa Arduino. Siga o mesmo procedimento para conectar o segundo sensor flexível. Use o pino A1 para conectar o resistor.

Conecte a campainha diretamente ao pino D3 e ao pino Gnd.

Etapa 4: finalizando o dispositivo

Depois de fazer o circuito, ele deve ser fixado dentro de um invólucro. De acordo com o modelo 3D acima, 2 sensores flex devem ser colocados no lado oposto do invólucro. Abra espaço para a porta USB programar a placa e fornecer energia. Como esse dispositivo precisa ser usado por um longo período, o melhor método para fornecer energia é usando um pacote de energia fixo.

Etapa 5: aplicativo móvel

Baixe e instale o Blynk da Android Play Store. Inicie um novo projeto para o Arduino 101. Selecione o método de comunicação como BLE. Adicione 1 terminal, 2 botões e BLE à interface. As imagens a seguir mostram como fazer a interface.

Etapa 6: Arquivos de código Blynk

Após fazer a interface no Blynk você receberá um código de autorização. Digite esse código no seguinte local.

#include #include char auth = "**************"; // Código de autorização Blynk

Terminal WidgetTerminal (V2);

BLEPeripheral blePeripheral;

No processo de calibração, as leituras atuais do sensor são salvas na EEPROM.

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

EEPROM.write (1, flx2);

EEPROM.write (2, x);

EEPROM.write (3, y);

EEPROM.write (4, z);

terminal.print ("Calibração bem-sucedida");

Após a calibração, o dispositivo irá comparar o desvio com os valores de limite e emite um bipe se eles excederem o valor.

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

terminal.println ("Over Bend");

tom (campainha, 1000);

}

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

terminal.println ("Mais inclinado");

tom (campainha, 1000);

}

Etapa 7: Funcionalidade

Cole o dispositivo na estrutura que precisa ser monitorada. Cole os 2 sensores flex também. Forneça energia à placa usando o cabo USB.

Abra a interface Blynk. Conecte-se ao dispositivo tocando no ícone Bluetooth. Pressione o botão de calibração. Após a calibração, o terminal mostrará uma mensagem como "Calibrado com sucesso." Reinicialize o dispositivo. Agora ele vai monitorar a estrutura e avisa pela campainha se ela se desviar ou se deformar. Você pode verificar os valores de ângulo e dobra a qualquer momento pressionando o botão Status. Isso pode parecer um pequeno dispositivo. Mas seus usos não têm preço. Às vezes esquecemos de verificar o estado de nossa casa, escritório, etc., com nossas agendas lotadas. Mas se houver um pequeno problema, ele pode terminar como na figura acima.

Mas com este dispositivo, centenas de vidas podem ser salvas, informando os pequenos, mas perigosos problemas em construções.

Etapa 8: Arquivo de código Arduino101

#define BLYNK_PRINT Serial

#define flex1 A0

#define flex2 A1 // Define o sensor flex e os pinos da campainha

# define buzzer 3

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

#include "CurieBLE.h"

#include "Wire.h"

#include "EEPROM.h"

#include "SPI.h"

char auth = "**************"; // Código de autorização Blynk Terminal WidgetTerminal (V2);

BLEPeripheral blePeripheral;

int m_flx1, m_flx2, m_x, m_y, m_z; // valores salvos na memória

int flx1, flx2, x, y, z; // Leituras atuais

valores vazios () {para (int i = 0; i <100; i ++) {

flx1 = analogRead (flex1); // Obtenha leituras brutas de sensores

flx2 = analogRead (flex2);

x = CurieIMU.readAccelerometer (X_AXIS) / 100;

y = CurieIMU.readAccelerometer (Y_AXIS) / 100;

z = CurieIMU.readAccelerometer (Z_AXIS) / 100;

atraso (2);

}

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

x = x / 100; // Obtenha os valores médios das leituras

y = y / 100;

z = z / 100;

}

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

pinMode (flex1, INPUT);

pinMode (flex2, INPUT); // Configurando os modos dos pinos do 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); // Leia os valores do sensor pré-salvos da EEPROM

m_y = EEPROM.read (3);

m_z = EEPROM.read (4);

}

loop vazio () {Blynk.run ();

blePeripheral.poll ();

valores ();

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

tom (campainha, 1000);

}

if (abs (x-m_x)> 15 ou abs (y-m_y)> 15 ou abs (z-m_z)> 15) {terminal.println ("Sobre-inclinado");

tom (campainha, 1000);

}

tom (campainha, 0);

}

/ * VO indica o modo de calibração. Neste modo os valores dos sensores * são salvos na 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 ("Calibração bem-sucedida");

}

}

/ * Podemos solicitar valores de desvio de corrente * pressionando o botão V1

*/

BLYNK_WRITE (V1) {

int pinValue = param.asInt ();

if (pinValue == 1) {

valores (); terminal.print ("desvio do ângulo X-");

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

terminal.println ();

terminal.print ("desvio do ângulo Y-");

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

terminal.println ();

terminal.print ("desvio do ângulo Z-");

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

terminal.println ();

terminal.print ("Flex 1 desvio-");

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

terminal.println ();

terminal.print ("Flex 2 desvio-");

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

terminal.println ();

}

}

BLYNK_WRITE (V2) {

}