SENSOR DE SISMOS CON ARDUINO

Red de sensores: Construye un sensor de sismos con Arduino, un Módulo Ethernet y un QuakeAlarm

Materiales

– Arduino Uno

– Módulo Ethernet ENC28J60

– Sensor Sísmico QuakeAlarm

– Cables de conexión para protoboard y cable ethernet

modulo Ethernet

Manos a la obra

Para conectar el Módulo Ethernet ENC28J60 nos basaremos en un artículo anterior “Conexión Ethernet para Arduino” donde se detalla la instalación de la librería Arduino para el módulo y el diagrama de conexión.

En la siguiente tabla esta el conexionado entre el Módulo Ethernet y el Arduino:

ENC28J60	Arduino
VCC	3.3v
GND	GND
SCK	Pin 13
SO	Pin 12
SI	Pin 11
CS	Pin 8

2. QuakeAlarm

La conexión del Arduino con el QuakeAlarm es extremadamente simple, no será necesario “abrirlo” como en nuestro artículo anterior, solo deben sacar la tapa superior de la batería y conectar dos cables idealmente con un conector para baterías de 9V, deben colocar especial atención en la polaridad, siempre identificar correctamente cuál es el positivo. La batería de 9V que normalmente alimenta al QuakeAlarm no será necesaria ya que usaremos los 5V que entrega el Arduino Uno.

Las conexiones entre el QuakeAlarm y el Arduino son las siguientes:

QuakeAlarm	Arduino Uno
+VCC (cable rojo)	5V
+VCC (cable rojo)	A0
GND (cable negro)	GND

Notar que +VCC de QuakeAlarm debe separarse en dos cables para conectarse a 5V en el Arduino que lo alimentara de voltaje y a A0 que será la entrada analógica que detectará la caída de tensión al activarse el sensor. En la foto se usó un pequeño Protoboard para esta función.

Ahora, si realmente quieres saber como funciona el QuakeAlarm por dentro, éstos diagramas eléctricos te ayudarán a realizar una conexión más precisa del sensor de forma tal que detecta hasta el golpe mas pequeño del péndulo invertido sobre el borde.

En el diagrama solo se muestra la conexión con el QuakeAlarm usando los pines (5V, GND y A0), hay que recordar que también debe estar cableada la conexión con el módulo ethernet.3. Programación

El sketch es algo complicado, en él se une la programación del Módulo Ethernet y la del sensor QuakeAlarm, el sketch detecta la baja de voltaje al activarse el sensor sísmico y envía una petición GET a nuestro servidor.

También el sketch considera el efecto rebote, para que envíe solo la primera activación y espere un tiempo determinado antes de enviar una segunda petición GET (Normalmente en un sismo el QuakeAlarm se activa múltiples veces)

Este sketch debe ser transferido al Arduino con el software de conexión (visto en todos los artículos donde trabajamos con Arduino y en nuestro Canal de YouTube).

Todo el código esta en el repositorio de GitHub que hemos creado para QuakeAlarm.


// Sketch que integra un QuakeAlarm con Arduino
// Version 0.1

// 2013-06-25 @joniuz
// Autor: Jose Antonio Zorrilla @joniuz

#include <EtherCard.h>
// 2013-06-25 @joniuz Corrijo conexion al QuakeAlarm


// QuakeAlarm
#define QUAKEALARM A0


// ethernet interface mac address
// Variable que mantiene el valor anterior del QuakeAlarm
static int diferencia;

static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };

int qaValorPrevio = 0;
// remote website name
char website[] PROGMEM = "iot.cl";

byte Ethernet::buffer[700];
static long timer;

// Variables QUAKEALARM
int qaValor = 0;

long ultimaConexion = 0; // Tiempo en milisegundos desde la ultima conexion al servicio web
int umbralValor = 10;
int intervaloTiempo = 5000; // Intervalo de tiempo entre dos llamadas al servicio web
char url[200];

// called when the client request is complete

void setup () {   
static void my_result_cb (byte status, word off, word len) {
  Serial.print("<<< Respuesta ");   
  Serial.println((const char*) Ethernet::buffer + off); 
} 

  Serial.begin(57600);   
  Serial.println("\n[getDHCPandDNS]");   

  ether.printIp("Mi IP: ", ether.myip);   
if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)     
    Serial.println( "Error al iniciar controlador ethernet");   
  if (!ether.dhcpSetup())     
    Serial.println("Error al obtener IP del DHCP");   

  ether.printIp("GW IP: ", ether.gwip);   

  qaValor = analogRead(QUAKEALARM);   
ether.printIp("DNS IP: ", ether.dnsip); 
  if (!ether.dnsLookup(website))     
    Serial.println("Error de DNS");   
  ether.printIp("Servidor: ", ether.hisip);   

  pinMode(QUAKEALARM, INPUT); 
} 

void loop () {   
  ether.packetLoop(ether.packetReceive());   

    Serial.print("Activacion QUAKEALARM: ");
Serial.print("QuakeAlarm: ");   
  Serial.print(qaValor);   
  Serial.print(" : ");   
  Serial.println(diferencia);      
  diferencia = qaValorPrevio - qaValor;   
  if ((diferencia > 0) and (diferencia >= umbralValor) and ((millis() - ultimaConexion) > intervaloTiempo)) {

    sprintf(url,"?id=8e5cdf407a45d0f81620f327084a31b7&sensor=quakealarm&valor=%d",diferencia);
Serial.print(diferencia);
    Serial.println("\n>>> ####### Envio requerimiento a servidor web #######");
    // Hace la peticion GET al servidor web con variable id codificada en md5 unica para cada estacion
    ether.browseUrl(PSTR("/arduino/sensor.php"), url, website, my_result_cb); 

}
ultimaConexion = millis(); 
  } 

  qaValorPrevio = qaValor;

4. Servidor

El servidor esta desarrollado en php y es un ejemplo de como procesar la información enviada por el Arduino, pero se puede utilizar para cualquier dispositivo que sea capaz de enviar una petición GET como un Raspberry Pi o Beaglebone.

Esta es la primera versión y obviamente se puede mejorar en muchos aspectos. No quise agregarle mas complejidad conectándolo con una base de datos MySQL ya que la idea es que se entienda.

Para que funcione correctamente con el sketch de Arduino debe llamarse sensor.php y estar ubicado en una carpeta llamada servidor, de tal forma que puedas ejecutarlo colocando en tu browser http://direccion_de_tu_servidor.cl/arduino/sensor.php

Cada estación de sensores debe tener un identificador único asignado que en este caso corresponde a un string generado con md5

Para tuitear utiliza una llamada al sistema operativo con system, deben tener TTytter instalado (ver artículo anterior) y conocer la ubicación de la llave con las credenciales, en este ejemplo el servidor web apache se ejecuta por el usuario apache, por lo cual el archivo con la llave esta ubicado en /home/apache/.ttytterkey y debe tener permisos de lectura para el usuario apache.


<?

// InternetdelasCosas.cl
//

// Script que recibe y procesa las activaciones de sensores
// Autor: @joniuz 


$id = htmlspecialchars($_GET["id"],ENT_QUOTES);
// Obtiene las variables enviadas por el Arduino

$valor = htmlspecialchars($_GET["valor"],ENT_QUOTES);
$sensor = htmlspecialchars($_GET["sensor"],ENT_QUOTES);


switch($id) {
// Identifica la estacion que esta enviando el dato validando el id que viene codificado en md5
   case "8e5cdf407a45d0f81620f327084a31b7":

      $estacion_id = "chile_santiago";
$estacion_id = "chile_malloco";
      $estacion_nombre = "Chile/Malloco";
      break;
   case "de2d4dba9ca94e7cd4fc69c426449b11":

      $estacion_nombre = "Chile/Vina del Mar";
$estacion_nombre = "Chile/Santiago";
      break;
   case "14bfa6bb14875e45bba028a21ed38046":
      $estacion_id = "chile_vina_del_mar";
      break;
   default:

$log = fopen("/var/log/iot/sensor_" . date("Y-m-j") . ".log","a+");
$estacion_id = "no_identificada";
}

// Registra el evento en un archivo log, estos archivos se generan en /var/log/iot/

switch ($sensor) {
$linea = date("Y-m-j H:i:s", time()) . " " . $estacion_id . " " . $_SERVER["REMOTE_ADDR"] . " " . $sensor . " " . $valor . "\n";
fwrite($log, $linea); fclose($log);

// Prepara el mensaje para tuitear
   case "quakealarm":

$estado = date("Y-m-j H:i:s", time()) . " " . $estacion_nombre . " " . $mensaje;
$mensaje = "Alerta de sismo";
      break;
   case "temperatura":
      $mensaje = "Temperatura: " . $valor . " C";
      break;
   case "humedad":
      $mensaje = "Humedad: " . $valor . " %";
      break;
}



   $twitter = "/usr/local/bin/ttytter -keyf=/home/apache/.ttytterkey -status=\"" . $estado . "\"";
// Si la estacion pertenece a la red de sensores tuitea el evento utilizando TTYtter y la llave generada para el usuario apache ttytterkey

if ($estacion_id <> "no_identificada") {
   system($twitter);
}
// Como salida entrega la direccion ip del Arduino
echo $_SERVER["REMOTE_ADDR"];

?>

fuente:http://www.internetdelascosas.cl/2013/08/25/red-de-sensores-construye-un-sensor-de-sismos-con-arduino-un-modulo-ethernet-y-un-quakealarm/

Buscar este blog

Asimov56