Alarme Detector de Terremoto usando Arduino

Tempo de leitura: 8 minutes

Um terremoto é um desastre natural imprevisível que causa danos a vidas e propriedades. Acontece de repente e não podemos impedi-lo, mas podemos ser alertados disso. Nos dias de hoje, existem muitas tecnologias que podem ser usadas para detectar pequenos choques e batidas, para que possamos tomar precauções antes de algumas vibrações importantes na terra. Aqui estamos usando o Acelerômetro ADXL335 para detectar as vibrações pré-terremoto. O acelerômetro ADXL335 é altamente sensível a vibrações e vibrações junto com os três eixos. Aqui estamos construindo um Detector de Terremoto baseado em Arduino usando Acelerômetro.

Estamos construindo este detector de terremotos como um Arduino Shield no PCB  e também mostramos o Gráfico de Vibrações no computador usando Processing.

Componentes Necessários:

  • Arduino UNO
  • Acelerômetro ADXL335
  • 16×2 LCD
  • Buzzer
  • Transistor BC547
  • 1k Resistores
  • 10K POT
  • LED
  • Fonte de alimentação 9v/12v
  • Cabinhos macho/fêmea
Acelerômetro:
Pin Descrição do acelerômetro:
  1.  Vcc         Uma fonte de 5 volts deve se conectar neste pino.
  2.  X-OUT   Este pino fornece uma saída analógica na direção x
  3.  Y-OUT   Este pino fornece uma saída analógica na direção y
  4.  Z-OUT   Este pino fornece uma saída analógica na direção z
  5.   GND      Ground
  6. ST          Este pino usado para definir a sensibilidade do sensor
Accelerometer Accelerometer-ADXL335

Explicação de trabalho:

Trabalhar com isso Detector de Terremoto é simples. Como mencionamos anteriormente, usamos o Acelerômetro para detectar vibrações de terremotos ao longo de qualquer um dos três eixos, de modo que, sempre que ocorrem vibrações, o acelerômetro detecta essas vibrações e as converte em valor ADC equivalente. Esses valores ADC são lidos pelo Arduino e mostrados no LCD 16×2. Também mostramos esses valores no Gráfico usando Processing.
Primeiro, precisamos calibrar o acelerômetro colhendo as amostras das vibrações ao redor sempre que o Arduino for ligado. Então, precisamos subtrair esses valores de amostra das leituras reais para obter as leituras reais. Essa calibração é necessária para que não mostre alertas com relação às vibrações normais do ambiente. Depois de encontrar leituras reais, o Arduino compara esses valores com os valores máximo e mínimo predefinidos. Se o Arduino detectar que os valores de alterações são maiores ou menores que os valores predefinidos de qualquer eixo nas duas direções (negativa e positiva), o Arduino aciona a campainha e mostra o status do alerta no LCD 16×2 e um LED também acende. Podemos ajustar a sensibilidade do detector de terremoto alterando os valores predefinidos no código do Arduino.
Earthquake indicator arduino shield using accelerometer block diagram
Código Arduino são apresentados no final do artigo.

Explicação do circuito:

O circuito deste Detector de terremoto Arduino Shield PCB também é simples. Neste projeto, usamos o Arduino que lê a tensão analógica do acelerômetro e os converte em valores digitais. O Arduino também aciona a campainha, LED, e calcule e compare valores e tome as medidas apropriadas. A próxima parte é o acelerômetro, que detecta vibrações da terra e gera tensões analógicas em 3 eixos (X, Y e Z). O LCD é usado para mostrar as mudanças nos valores dos eixos X, Y e Z e também mostrar uma mensagem de alerta sobre ele. Este LCD está conectado ao Arduino no modo de 4 bits. Os pinos RS, GND e EN são conectados diretamente aos pinos 9, GND e 8 do Arduino e o restante dos 4 pinos de dados do LCD, nomeadamente D4, D5, D6 e D7, são conectados diretamente aos pinos digitais 7, 6, 5 e 4 do Arduino. A campainha é conectada ao pino 12 do Arduino através de um transistor NPN BC547. Um pote de 10k também é usado para controlar o brilho do LCD.
Earthquake indicator arduino shield using accelerometer circuit diagram

Explicação de programação:

Neste Escudo de Arduino do Detector de Terremoto, criamos dois códigos: um para o Arduino detectar um terremoto e outro para o Processing IDE para plotar as vibrações do terremoto sobre o gráfico no computador. Vamos aprender sobre os códigos um por um:
Código Arduino:
Antes de tudo, calibramos o acelerômetro  com relação à sua superfície de colocação, para que ele não mostre alertas com relação ao ambiente normal vibrações. Nesta calibração, coletamos algumas amostras e, em seguida, coletamos uma média delas e as armazenamos em uma variável.
  for(int i=0;i<samples;i++)      // colhendo amostras para calibração
  {
    xsample+=analogRead(x);
    ysample+=analogRead(y);
    zsample+=analogRead(z);
  }

  xsample/=samples;   // taking avg for x
  ysample/=samples;   // taking avg for y
  zsample/=samples;   // taking avg for z
  
  delay(3000);
  lcd.clear();
  lcd.print("Calibrated");
  delay(1000);
  lcd.clear();
  lcd.print("Device Ready");
  delay(1000);
  lcd.clear();
  lcd.print(" X     Y     Z   ");
Agora, sempre que o acelerômetro fizer leituras, subtrairemos esses valores de amostra das leituras para que ele possa ignorar as vibrações do ambiente.
    int value1=analogRead(x);   //lendo x fora
    int value2=analogRead(y);   //lendo y fora
    int value3=analogRead(z);   //lendo z

    int xValue=xsample-value1;    // encontrando mudança em x
    int yValue=ysample-value2;    // encontrando mudanças em y
    int zValue=zsample-value3;    // encontrando mudança em z

  /*displying change in x,y and z axis values over lcd*/
    lcd.setCursor(0,1);
    lcd.print(zValue);
    lcd.setCursor(6,1);
    lcd.print(yValue);
    lcd.setCursor(12,1);
    lcd.print(zValue);
    delay(100)
Em seguida, o Arduino compara esses valores calibrados (subtraídos) com limites predefinidos. E aja de acordo. Se os valores forem maiores que os valores predefinidos, ele emitirá um sinal sonoro e tocará o gráfico de vibração no computador usando Processamento.
     /* Comparando Mudança com Limites Predefinidos */
    if(xValue < minVal || xValue > maxVal  || yValue < minVal || yValue > maxVal  || zValue < minVal || zValue > maxVal)
    { 
      if(buz == 0)
      start=millis();   // início do temporizador
       buz=1;       // sinalizador sonoro / led ativado
    } 

   else if(buz == 1)     // sinalizador de campainha ativado e alertando terremoto
   {
      lcd.setCursor(0,0);
      lcd.print("Earthquake Alert   ");
      if(millis()>= start+buzTime)    
      buz=0;
   }
Código Processing:
Abaixo está o código de processamento anexado, você pode fazer o download do código no link abaixo:
Projetamos um gráfico usando Processing, para vibrações de terremotos, nos quais definimos o tamanho da janela, unidades, tamanho da fonte, plano de fundo, leitura e exibição de portas seriais, porta serial aberta selecionada etc.
  //defina o tamanho da janela: e tamanho da fonte
  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);
  size(1200, 700);        
 
 //Listar todas as portas seriais disponíveis
 println(Serial.list());
 myPort = new Serial(this, "COM43", 9600);
 println(myPort);
 myPort.bufferUntil('\n');
 background(80)
Na função abaixo, recebemos dados da porta serial e extraímos os dados necessários e, em seguida, mapeamos com o tamanho do gráfico.
 //extraindo todos os valores necessários dos três eixos:
 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);
 
 //mapeando os valores x, ye z com dimensões do gráfico
 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);
Depois disso, plotamos o espaço unitário, os limites máximos e mínimos, os valores dos eixos x, ye z.
  //janela de gráfico de plotagem, unidade
  strokeWeight(2);
  stroke(175);                        
  Line(0,0,0,100);
  textFont(f24);       
  fill(0,00,255);
  textAlign(RIGHT);
  xmargin("EarthQuake Graph",200,100); 
  
   fill(100); 
   strokeWeight(100);
   line(1050,80,1200,80);
   .... ....
   ..........
Depois disso, plotamos os valores no gráfico usando 3 cores diferentes como azul para o valor do eixo x, a cor verde para o eixo y e z é representada pela cor vermelha.
   stroke(0,0,255);         
   if(y1 == 0)
   y1=height-inByte1-shift;
   line(x, y1, x+2, height-inByte1-shift) ;
   y1=height-inByte1-shift;
   
   stroke(0,255,0);            
   if(y2 == 0)
   y2=height-inByte2-shift;
   line(x, y2, x+2, height-inByte2-shift) ;
   y2=height-inByte2-shift;
   
   stroke(255,0,0);             
   if(y2 == 0)
   y3=height-inByte3-shift;
   line(x, y3, x+2, height-inByte3-shift) ;
   y3=height-inByte3-shift;

Projeto de circuitos e placas de circuito impresso usando o EasyEDA:

O EasyEDA não é apenas a solução completa para o captura esquemática, simulação de circuitos e design de placas de circuito impresso, eles também oferecem a Protótipo de PCB de baixo custo e serviço de Sourcing de componentes. Recentemente, eles lançaram seu serviço de fornecimento de componentes onde eles têm um grande estoque de componentes eletrônicos e os usuários podem solicitar os componentes necessários junto com o pedido de PCB.
Ao projetar seus circuitos e PCBs, você também pode tornar públicos seus projetos de circuitos e PCBs para que outros usuários possam copiá-los ou editá-los e tirar proveito deles, também tornamos públicos todos os nossos layouts de circuitos e PCBs para Escudo indicador de terremoto para o Arduino UNO,  verifique o link abaixo:
>>Projeto abaixo foi criado pelo criador original do projeto, qualquer duvida, no proprio link do mesmo tem como entrar em contato.<<
Abaixo está o instantâneo da camada superior do layout de PCB do EasyEDA, você pode visualizar qualquer camada (superior, inferior, topsilk, bottomsilk etc.) do PCB selecionando a forma da camada “Camadas” Janela.
Earthquake detector arduino shield PCBs top layer
Você também pode ver Visualização de fotos do PCB usando o EasyEDA:
Earthquake detector arduino shield PCB photoview

Cálculo e pedido de amostras on-line:

Após concluir o design do PCB, você pode clicar no ícone do Saída da fabricação, que o levará ao página PCB  Aqui você pode ver seu PCB em  Gerber Viewer ou baixe arquivos Gerber do seu PCB. Aqui você pode selecionar o número de placas de circuito impresso que deseja solicitar, quantas camadas de cobre você precisa, a espessura da placa de circuito impresso, o peso do cobre e até a cor da placa de circuito impresso. Após o  você ter selecionado todas as opções, clique em “Salvar no carrinho” e complete seu pedido. Recentemente, eles diminuíram significativamente as taxas de PCB e agora você pode encomendar 10 PCBs de duas camadas com 10cm x 10cm de tamanho por apenas US $2.
Earthquake indicator arduino shield PCB order easyeda
Aqui estão os PCBs que obtive do EasyEDA:
Earthquake detector arduino shield PCBs
Earthquake detector arduino shield PCBs easyeda
Abaixo estão as fotos dofotos do Shield final após a soldagem dos componentes no PCB:
Earthquake detector arduino PCB using accelerometer
Código: (Mantido em Ingles)
#include<LiquidCrystal.h>      // lcd Header
LiquidCrystal lcd(9,8,7,6,5,4);   // pins for LCD Connection
#define buzzer 12 // buzzer pin
#define led 13  //led pin
#define x A0  // x_out pin of Accelerometer
#define y A1  // y_out pin of Accelerometer
#define z A2  // z_out pin of Accelerometer
/*variables*/
int xsample=0;
int ysample=0;
int zsample=0;
long start;
int buz=0;
/*Macros*/
#define samples 50
#define maxVal 20   // max change limit
#define minVal -20    // min change limit
#define buzTime 5000  // buzzer on time
void setup()
{
  lcd.begin(16,2);  //initializing lcd
  Serial.begin(9600); // initializing serial
  delay(1000);
  lcd.print("EarthQuake ");
  lcd.setCursor(0,1);
  lcd.print("Detector    ");
  delay(2000);
  lcd.clear();
  lcd.print("Circuit Digest ");
  lcd.setCursor(0,1);
  lcd.print("Saddam Khan    ");
  delay(2000);
  lcd.clear();
  lcd.print("Calibrating.....");
  lcd.setCursor(0,1);
  lcd.print("Please wait...");
  pinMode(buzzer, OUTPUT);
  pinMode(led, OUTPUT);
  buz=0;
  digitalWrite(buzzer, buz);
  digitalWrite(led, buz);
  for(int i=0;i<samples;i++)      // taking samples for calibration
  {
    xsample+=analogRead(x);
    ysample+=analogRead(y);
    zsample+=analogRead(z);
  }
  xsample/=samples;   // taking avg for x
  ysample/=samples;     // taking avg for y
  zsample/=samples;   // taking avg for z
 
  delay(3000);
  lcd.clear();
  lcd.print("Calibrated");
  delay(1000);
  lcd.clear();
  lcd.print("Device Ready");
  delay(1000);
  lcd.clear();
  lcd.print(" X     Y     Z   ");
}
void loop()
{
    int value1=analogRead(x);   // reading x out
    int value2=analogRead(y);   //reading y out
    int value3=analogRead(z);   //reading z out
    int xValue=xsample-value1;    // finding change in x
    int yValue=ysample-value2;    // finding change in y
    int zValue=zsample-value3;    // finding change in z
  /*displying change in x,y and z axis values over lcd*/
    lcd.setCursor(0,1);
    lcd.print(zValue);
    lcd.setCursor(6,1);
    lcd.print(yValue);
    lcd.setCursor(12,1);
    lcd.print(zValue);
    delay(100);
  /* comparing change with predefined limits*/
    if(xValue < minVal || xValue > maxVal  || yValue < minVal || yValue > maxVal  || zValue < minVal || zValue > maxVal)
    {
      if(buz == 0)
      start=millis();   // timer start
       buz=1;       // buzzer / led flag activated
    } 
   else if(buz == 1)        // buzzer flag activated then alerting earthquake
   {
      lcd.setCursor(0,0);
      lcd.print("Earthquake Alert   ");
      if(millis()>= start+buzTime)  
      buz=0;
   }
 
    else
    {
      lcd.clear();
      lcd.print(" X     Y     Z   ");
    }
    digitalWrite(buzzer, buz);    // buzzer on and off command
    digitalWrite(led, buz);   // led on and off command
  /*sending values to processing for plot over the graph*/
    Serial.print("x=");
    Serial.println(xValue);
    Serial.print("y=");
    Serial.println(yValue);
    Serial.print("z=");
    Serial.println(zValue);
    Serial.println(" $");
}

 

Visits: 3 Visits: 1191462