- Componentes requeridos:
- Explicación de trabajo:
- Explicación del circuito:
- Explicación de programación:
- Diseño de circuitos y PCB con EasyEDA:
- Cálculo y pedido de muestras en línea:
Un terremoto es un desastre natural impredecible que causa daños a vidas y propiedades. Ocurre de repente y no podemos detenerlo, pero podemos estar alerta. En la actualidad, existen muchas tecnologías que se pueden utilizar para detectar pequeños temblores y golpes, de modo que podamos tomar precauciones antes de algunas vibraciones importantes en la tierra. Aquí estamos usando el acelerómetro ADXL335 para detectar las vibraciones previas al terremoto. El acelerómetro ADXL335 es muy sensible a sacudidas y vibraciones junto con los tres ejes. Aquí estamos construyendo un detector de terremotos basado en Arduino usando un acelerómetro.
Estamos construyendo este detector de terremotos como un Arduino Shield en PCB y también mostraremos el gráfico de vibraciones en la computadora usando Processing.
Componentes requeridos:
- Arduino UNO
- Acelerómetro ADXL335
- LCD de 16x2
- Zumbador
- Transistor BC547
- Resistencias 1k
- BOTE 10K
- LED
- Fuente de alimentación 9v / 12v
- Berg sticks macho / hembra
Acelerómetro:
Pin Descripción del acelerómetro:
- El suministro de Vcc de 5 voltios debe conectarse en este pin.
- X-OUT Este pin proporciona una salida analógica en la dirección x
- Y-OUT Este pin proporciona una salida analógica en la dirección y
- Z-OUT Este pin proporciona una salida analógica en la dirección z
- Tierra GND
- ST Este pin se usa para configurar la sensibilidad del sensor
Consulte también nuestros otros proyectos utilizando acelerómetro:
- Juego de ping pong usando Arduino
- Robot controlado por gestos manuales basado en acelerómetro.
- Sistema de alerta de accidentes de vehículos basado en Arduino mediante GPS, GSM y acelerómetro
Explicación de trabajo:
El funcionamiento de este detector de terremotos es sencillo. Como mencionamos anteriormente, hemos utilizado el acelerómetro para detectar vibraciones sísmicas a lo largo de cualquiera de los tres ejes, de modo que siempre que ocurren vibraciones, el acelerómetro detecta esas vibraciones y las convierte en un valor ADC equivalente. Luego, estos valores de ADC son leídos por Arduino y mostrados en la pantalla LCD de 16x2. También hemos mostrado estos valores en Graph usando Processing. Obtenga más información sobre el acelerómetro revisando nuestros otros proyectos de acelerómetro aquí.
Primero necesitamos calibrar el acelerómetro tomando las muestras de las vibraciones circundantes cada vez que Arduino se enciende. Luego, debemos restar esos valores de muestra de las lecturas reales para obtener las lecturas reales. Esta calibración es necesaria para que no muestre alertas con respecto a las vibraciones normales del entorno. Después de encontrar lecturas reales, Arduino compara estos valores con valores máximos y mínimos predefinidos. Si Arduino encuentra algún cambio, los valores son más o menos que los valores predefinidos de cualquier eje en ambas direcciones (negativo y positivo), entonces Arduino activa el timbre y muestra el estado de alerta en la pantalla LCD de 16x2 y un LED también encendido. Podemos ajustar la sensibilidad del detector de terremotos cambiando los valores predefinidos en el código Arduino.
El video de demostración y el código Arduino se encuentran al final del artículo.
Explicación del circuito:
Circuito de este detector de terremotos Arduino Shield PCBtambién es simple. En este proyecto, hemos utilizado Arduino que lee el voltaje analógico del acelerómetro y lo convierte en valores digitales. Arduino también maneja el zumbador, LED, LCD 16x2 y calcula y compara valores y toma las medidas adecuadas. La siguiente parte es el acelerómetro que detecta la vibración de la tierra y genera voltajes analógicos en 3 ejes (X, Y y Z). La pantalla LCD se utiliza para mostrar el cambio de valores de los ejes X, Y y Z y también para mostrar un mensaje de alerta sobre él. Esta pantalla LCD está conectada a Arduino en modo de 4 bits. Los pines RS, GND y EN están conectados directamente a 9, GND y 8 pines de Arduino y el resto de los 4 pines de datos de la pantalla LCD, a saber, D4, D5, D6 y D7 están conectados directamente a los pines digitales 7, 6, 5 y 4 de Arduino. El zumbador está conectado al pin 12 de Arduino a través de un transistor NPN BC547. También se utiliza un potenciómetro de 10k para controlar el brillo de la pantalla LCD.
Explicación de programación:
En este Arduino Shield Detector de Terremotos, hemos creado dos códigos: uno para Arduino para detectar un terremoto y otro para Procesar IDE para trazar las vibraciones del terremoto sobre el gráfico en la Computadora. Aprenderemos sobre ambos códigos uno por uno:
Código Arduino:
En primer lugar, calibramos el acelerómetro con respecto a su superficie de colocación, para que no muestre alertas con respecto a sus vibraciones normales del entorno. En esta calibración, tomamos algunas muestras y luego tomamos un promedio de ellas y las almacenamos en una variable.
para (int i = 0; i
Ahora, siempre que el acelerómetro tome lecturas, restaremos esos valores de muestra de las lecturas para que pueda ignorar las vibraciones del entorno.
int valor1 = analogRead (x); // leyendo x int value2 = analogRead (y); // leyendo y int value3 = analogRead (z); // leyendo z out int xValue = xsample-value1; // encontrando cambio en x int yValue = ysample-value2; // encontrando cambio en y int zValue = zsample-value3; // encontrar cambios en z / * mostrar cambios en los valores de los ejes x, y y z sobre lcd * / lcd.setCursor (0,1); lcd.print (zValue); lcd.setCursor (6,1); lcd.print (yValue); lcd.setCursor (12,1); lcd.print (zValue); retraso (100)
Luego, Arduino compara esos valores calibrados (restados) con límites predefinidos. Y actúe en consecuencia. Si los valores son más altos que los valores predefinidos, sonará el zumbador y trazará el gráfico de vibración en la computadora usando Processing.
/ * comparando el cambio con límites predefinidos * / if (xValue <minVal - xValue> maxVal - yValue <minVal - yValue> maxVal - zValue <minVal - zValue> maxVal) {if (buz == 0) start = millis (); // inicio del temporizador buz = 1; // indicador de zumbador / led activado} else if (buz == 1) // indicador de zumbador activado y alerta de terremoto {lcd.setCursor (0,0); lcd.print ("Alerta de terremoto"); if (millis ()> = inicio + buzTime) buz = 0; }
Código de procesamiento:
A continuación se muestra el Código de procesamiento adjunto, puede descargar el código desde el siguiente enlace:
Código de procesamiento del detector de terremotos
Hemos diseñado un gráfico utilizando Processing, para vibraciones de terremotos, en el que definimos el tamaño de la ventana, unidades, tamaño de fuente, fondo, lectura y visualización de puertos serie, puerto serie seleccionado abierto, etc.
// establece el tamaño de la ventana: y el tamaño de fuente f6 = createFont ("Arial", 6, true); f8 = createFont ("Arial", 8, verdadero); f10 = createFont ("Arial", 10, verdadero); f12 = createFont ("Arial", 12, verdadero); f24 = createFont ("Arial", 24, verdadero); tamaño (1200, 700); // Lista todos los puertos serie disponibles println (Serial.list ()); myPort = new Serial (esto, "COM43", 9600); println (myPort); myPort.bufferUntil ('\ n'); fondo (80)
En la siguiente función, hemos recibido datos del puerto serie y extraemos los datos necesarios y luego los asignamos con el tamaño del gráfico.
// extraer todos los valores necesarios de los tres ejes: 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); // mapeo del valor x, y y z con las dimensiones del 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); flotar x = mapa (xPos, 0,1120,40, ancho-40);
Después de esto, hemos trazado el espacio unitario, los límites máximo y mínimo, los valores de los ejes x, y y z.
// trazando la ventana del gráfico, unidad strokeWeight (2); accidente cerebrovascular (175); Línea (0,0,0,100); textFont (f24); llenar (0,00,255); textAlign (DERECHA); xmargin ("Gráfico de EarthQuake por resumen de circuitos", 200,100); llenar (100); strokeWeight (100); línea (1050,80,1200,80);………………
Después de esto, trazamos los valores sobre el gráfico usando 3 colores diferentes como el azul para el valor del eje x, el color verde para el eje yyz está representado por el color rojo.
accidente cerebrovascular (0,0,255); if (y1 == 0) y1 = altura-enByte1-shift; línea (x, y1, x + 2, altura-inByte1-shift); y1 = altura-inByte1-shift; accidente cerebrovascular (0,255,0); if (y2 == 0) y2 = altura-inByte2-shift; línea (x, y2, x + 2, altura-inByte2-shift); y2 = altura-inByte2-shift; carrera (255,0,0); if (y2 == 0) y3 = altura-inByte3-shift; línea (x, y3, x + 2, altura-inByte3-shift); y3 = altura-inByte3-shift;
También obtenga más información sobre el procesamiento revisando nuestros otros proyectos de procesamiento.
Diseño de circuitos y PCB con EasyEDA:
EasyEDA no es solo la solución integral para captura de esquemas, simulación de circuitos y diseño de PCB, sino que también ofrece un servicio de suministro de componentes y prototipos de PCB de bajo costo. Recientemente, lanzaron su servicio de abastecimiento de componentes donde tienen un gran stock de componentes electrónicos y los usuarios pueden solicitar los componentes necesarios junto con el pedido de PCB.
Mientras diseña sus circuitos y PCB, también puede hacer públicos sus diseños de circuitos y PCB para que otros usuarios puedan copiarlos o editarlos y puedan beneficiarse de ellos, también hemos hecho públicos todos nuestros diseños de circuitos y PCB para este escudo indicador de terremotos para Arduino UNO, consulte el siguiente enlace:
easyeda.com/circuitdigest/EarthQuake_Detector-380c29e583b14de8b407d06ab0bbf70f
A continuación se muestra la instantánea de la capa superior del diseño de PCB de EasyEDA, puede ver cualquier capa (superior, inferior, seda superior, seda inferior, etc.) de la PCB seleccionando la capa de la ventana 'Capas'.
También puede ver la vista de fotos de PCB usando EasyEDA:
Cálculo y pedido de muestras en línea:
Después de completar el diseño de PCB, puede hacer clic en el icono de salida de fabricación , que lo llevará a la página de pedido de PCB. Aquí puede ver su PCB en Gerber Viewer o descargar archivos Gerber de su PCB. Aquí puede seleccionar la cantidad de PCB que desea pedir, cuántas capas de cobre necesita, el grosor de la PCB, el peso del cobre e incluso el color de la PCB. Una vez que haya seleccionado todas las opciones, haga clic en "Guardar en el carrito" y complete su pedido. Recientemente, han reducido significativamente sus tarifas de PCB y ahora puede pedir 10 piezas de PCB de 2 capas con un tamaño de 10 cm x 10 cm por solo $ 2.
Aquí están los PCB que obtuve de EasyEDA:
A continuación se muestran las imágenes del escudo final después de soldar los componentes en PCB: