Alarme detector de terremoto usando arduino

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

Estamos aqui construindo este detector de terremoto como um Arduino Shield no PCB e também mostraremos o gráfico de vibrações no computador usando o Processing.

Componentes necessários:

Arduino UNO
Acelerômetro ADXL335
LCD 16x2
Buzzer
Transistor BC547
Resistores 1k
10K POT
CONDUZIU
Fonte de alimentação 9v / 12v
Varas Berg masculino / feminino

Acelerômetro:

Descrição do pino do acelerômetro:

A alimentação Vcc de 5 volts deve ser conectada neste pino.
X-OUT Este pino fornece uma saída analógica na direção x
Y-OUT Este pino fornece uma saída analógica na direção y
Z-OUT Este pino fornece uma saída analógica na direção z
GND Ground
ST Este pino usado para definir a sensibilidade do sensor

Verifique também nossos outros projetos usando acelerômetro:

Jogo Ping Pong usando Arduino
Robô controlado por gestos manuais baseado em acelerômetro.
Sistema de Alerta de Acidente de Veículo baseado em Arduino usando GPS, GSM e acelerômetro

Explicação de trabalho:

O funcionamento deste 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 ocorrerem vibrações, o acelerômetro detecta essas vibrações e as converte em um valor ADC equivalente. Em seguida, esses valores ADC são lidos pelo Arduino e exibidos no LCD 16x2. Também mostramos esses valores em Graph using Processing. Saiba mais sobre o Acelerômetro examinando nossos outros projetos de Acelerômetro aqui.

Primeiro, precisamos calibrar o acelerômetro pegando as amostras das vibrações circundantes sempre que o Arduino liga. Em seguida, precisamos subtrair esses valores de amostra das leituras reais para obter as leituras reais. Esta calibração é necessária para que não mostre alertas em relação às vibrações normais circundantes. Depois de encontrar leituras reais, o Arduino compara esses valores com os valores máximos e mínimos predefinidos. Se o Arduino encontrar qualquer alteração, os valores são mais ou menos do que os valores predefinidos de qualquer eixo em ambas as direções (negativa e positiva), então o Arduino aciona a campainha e mostra o status de alerta no LCD 16x2 e um LED também ligado. Podemos ajustar a sensibilidade do detector de terremoto alterando os valores predefinidos no código do Arduino.

O vídeo de demonstração e o código do Arduino são fornecidos no final do artigo.

Explicação do circuito:

Circuito deste detector de terremoto Arduino Shield PCBtambé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 o buzzer, LED, LCD 16x2 e calcula e compara valores e toma as medidas adequadas. A próxima parte é o acelerômetro que detecta a vibração da terra e gera tensões analógicas em 3 eixos (X, Y e Z). O LCD é usado para mostrar a mudança nos valores dos eixos X, Y e Z e também mostrar mensagens 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 resto dos 4 pinos de dados do LCD, ou seja, D4, D5, D6 e D7 estão diretamente conectados aos pinos digitais 7, 6, 5 e 4 do Arduino. O buzzer é conectado ao pino 12 do Arduino por meio de um transistor NPN BC547. Um potenciômetro de 10k também é usado para controlar o brilho do LCD.

Explicação de programação:

Neste Detector de terremoto Arduino Shield, fizemos dois códigos: um para o Arduino para detectar um terremoto e outro para o IDE de processamento para traçar as vibrações do terremoto sobre o gráfico no computador. Aprenderemos sobre os dois códigos um por um:

Código Arduino:

Em primeiro lugar, calibramos o acelerômetro com relação à sua superfície de colocação, de modo que ele não mostre alertas com relação às vibrações normais ao redor. Nesta calibração, pegamos algumas amostras e, em seguida, fazemos uma média delas e armazenamos em uma variável.

para (int i = 0; i

Agora, sempre que o acelerômetro fizer leituras, iremos subtrair esses valores de amostra das leituras para que ele possa ignorar as vibrações do ambiente.

valor int1 = analogRead (x); // lendo x out int value2 = analogRead (y); // leitura de y int value3 = analogRead (z); // leitura de z int xValue = xsample-value1; // encontrando a mudança em x int yValue = ysample-value2; // encontrando a mudança em y int zValue = zsample-value3; // encontrando mudança em z / * exibindo mudança nos valores dos eixos x, y e z sobre lcd * / lcd.setCursor (0,1); lcd.print (zValue); lcd.setCursor (6,1); lcd.print (yValue); lcd.setCursor (12,1); lcd.print (zValue); atraso (100)

Em seguida, o Arduino compara esses valores calibrados (subtraídos) com limites predefinidos. E aja de acordo. Se os valores forem maiores do que os valores predefinidos, ele emitirá um bipe e fará o gráfico de vibração no computador usando o Processing.

/ * comparar a mudança com os limites predefinidos * / if (xValue <minVal - xValue> maxVal - yValue <minVal - yValue> maxVal - zValue <minVal - zValue> maxVal) {if (buz == 0) start = millis (); // início do cronômetro buz = 1; // sinalizador sonoro / led ativado} else if (buz == 1) // sinalizador sonoro ativado e alertando o terremoto {lcd.setCursor (0,0); lcd.print ("Alerta de terremoto"); if (millis ()> = start + buzTime) buz = 0; }

Código de processamento:

Abaixo está o Código de Processamento em anexo, você pode baixar o código no link abaixo:

Código de processamento do detector de terremotos

Projetamos um gráfico usando Processing, para vibrações de terremotos, no qual definimos o tamanho da janela, unidades, tamanho da fonte, plano de fundo, leitura e exibição de portas seriais, porta serial selecionada aberta etc.

// definir o tamanho da janela: e tamanho da fonte f6 = createFont ("Arial", 6, true); f8 = createFont ("Arial", 8, verdadeiro); f10 = createFont ("Arial", 10, verdadeiro); f12 = createFont ("Arial", 12, verdadeiro); f24 = createFont ("Arial", 24, verdadeiro); tamanho (1200, 700); // Lista todas as portas seriais disponíveis println (Serial.list ()); myPort = novo Serial (este, "COM43", 9600); println (minhaPort); myPort.bufferUntil ('\ n'); fundo (80)

Na função abaixo, recebemos dados da porta serial, extraímos os dados necessários e os mapeamos com o tamanho do gráfico.

// extraindo todos os valores necessários de todos os 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 o valor x, y e z com as dimensões do gráfico float inByte1 = float (temp1 + (char) 9); inByte1 = mapa (inByte1, -80,80, 0, altura-80); float inByte2 = float (temp2 + (char) 9); inByte2 = mapa (inByte2, -80,80, 0, altura-80); float inByte3 = float (temp3 + (char) 9); inByte3 = mapa (inByte3, -80,80, 0, altura-80); float x = map (xPos, 0,1120,40, largura-40);

Depois disso, plotamos o espaço da unidade, os limites máximos e mínimos, os valores dos eixos x, y e z.

// janela de gráfico de plotagem, unidade strokeWeight (2); curso (175); Linha (0,0,0,100); textFont (f24); preencher (0,00,255); textAlign (RIGHT); xmargin ("EarthQuake Graph By Circuit Digest", 200,100); preencher (100); strokeWeight (100); linha (1050,80,1200,80);………………

Depois disso, plotamos os valores no gráfico usando 3 cores diferentes como azul para o valor do eixo x, cor verde para o eixo y ez é representado pela cor vermelha.

curso (0,0,255); if (y1 == 0) y1 = deslocamento de altura em Byte1; linha (x, y1, x + 2, deslocamento de altura em Byte1); y1 = deslocamento de altura em Byte1; curso (0,255,0); if (y2 == 0) y2 = deslocamento de altura em Byte2; linha (x, y2, x + 2, deslocamento de altura em Byte2); y2 = deslocamento de altura em Byte2; curso (255,0,0); if (y2 == 0) y3 = altura em Byte3-shift; linha (x, y3, x + 2, deslocamento de altura em Byte3); y3 = deslocamento de altura em Byte3;

Além disso, aprenda mais sobre processamento examinando nossos outros projetos de processamento.

Projeto de circuito e PCB usando EasyEDA:

EasyEDA não é apenas a solução completa para captura esquemática, simulação de circuito e design de PCB, mas também oferece um serviço de fornecimento de componentes e protótipos de PCB de baixo custo. Recentemente, eles lançaram seu serviço de fornecimento de componentes, onde 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 seus projetos de circuitos e PCB públicos para que outros usuários possam copiá-los ou editá-los e tirar proveito deles. Também tornamos públicos todos os nossos circuitos e circuitos de PCB para este escudo indicador de terremoto para Arduino UNO, verifique o link abaixo:

easyeda.com/circuitdigest/EarthQuake_Detector-380c29e583b14de8b407d06ab0bbf70f

Abaixo está o instantâneo da camada superior do layout do PCB do EasyEDA, você pode visualizar qualquer camada (superior, inferior, superior, inferior, etc.) do PCB selecionando a camada da janela 'Camadas'.

Você também pode ver a visualização da foto do PCB usando EasyEDA:

Calculando e solicitando amostras online:

Depois de concluir o design do PCB, você pode clicar no ícone de saída de fabricação , que o levará para a página de pedido do PCB. Aqui você pode visualizar seu PCB no Gerber Viewer ou baixar arquivos Gerber do seu PCB. Aqui você pode selecionar o número de PCBs que deseja solicitar, quantas camadas de cobre você precisa, a espessura do PCB, o peso do cobre e até mesmo a cor do PCB. Depois de selecionar todas as opções, clique em “Salvar no carrinho” e conclua seu pedido. Recentemente, eles caíram suas taxas de PCB significativamente e agora você pode solicitar 10 unidades de PCB de 2 camadas com tamanho de 10 cm x 10 cm por apenas $ 2.

Aqui estão os PCBs que obtive da EasyEDA:

Abaixo estão as fotos da blindagem final após a soldagem dos componentes no PCB: