Tutorial Arduino #0010 – Módulo 3G, Ultrasonidos, Keypad & Led RGB

Bienvenid@s a un nuevo tutorial Arduino!

Aprovecho para deciros que estamos inmersos en grandes cambios, tanto de imagen, como de infraestructura para mejorar la calidad del proyecto, espero no crear demasiadas inconveniencias, comentar también, que este pasado 1 de mayo cerramos el foro de Arduino Academy (ahora Arduteka) para darle continuidad desde el foro oficial en Arduino.cc donde solventaré todas las dudas que os surjan de este tutorial en este post.

Como novedad, a partir de ahora vamos a incluir un Premium Pack descargable con cada tutorial que realicemos y para obtenerlo, tan solo tendrás que regalarnos un Tweet o Post en Facebook!! Barato, no?

Lo mejor de todo es que este Pack nos trae alguna que otra sorpresa!! Como adelanto, os digo que en su interior tendréis archivos para Arduino de cada proyecto, librerías utilizadas, en este tutorial, también los sonidos, una versión de todo el tutorial en PDF para disfrutarlo sin conexión.. y alguna sorpresita más!! Descárgalo ahora haciendo click en este botón!!

Parte 1: ¿Que vamos a hacer?

En este proyecto vamos a aprender a utilizar una parte de todas las opciones que nos ofrece el nuevo módulo 3G/GPRS de cooking hacks, en este tutorial lo usaremos para reproducir mp3 por un altavoz conectado directamente al propio módulo, para mandar un sms y un mms, para tomar fotografías y para almacenarlas en una tarjeta SD, además de esto, vamos a ver como se integrar un teclado matricial 4×4 en nuestros proyectos Arduino, un Led RGB y un sensor de ultrasonidos, no está mal, no? Ahora veamos que hacemos con todo esto!

Vamos a construirnos una alarma totalmente casera, a través del sensor de ultrasonidos, escanearemos continuamente el espacio situado enfrente suyo con un radio aproximado de 30º, cuando algún objeto o persona se sitúe en su campo de actuación a una distancia inferior a la que establezcamos, haremos sonar una alarma, tomaremos una fotografía, el Led RGB que antes estaba verde, pasará a color azul y daremos 10 segundos para poder desactivar la alarma a través de nuestro teclado matricial, si la desactivamos, volverá de nuevo a escanear el campo, pero si no!! Reproducirá un sonido contundente y se dispondrá a mandarnos un sms a nuestro teléfono móvil y la fotografía a nuestro correo electrónico.

Veámoslo en video!!

Os recuerdo también que el hilo oficial de este proyecto, donde podréis evolucionarlo, consultar dudas y demás será ESTE ENLACE alojado en la página oficial de Arduino.

Material necesario para este tutorial:

• 1 x Arduino Uno
• 1 x Protoboard
• 1 x Módulo 3G/GPRS de Cooking Hacks
• 1 x Tarjeta SIM
• 1 x Altavoz (Incluido en el kit de audio/video de Cooking Hacks)
• 1 x Cámara (Incluido en el kit de audio/video de Cooking Hacks)
• 1 x Tarjeta microSD
• 1 x Sensor de Ultrasonidos
• 1 x Teclado Matricial
• 1 x Led RGB
• 3 x Resistencias 470Ω
• 1 x Juego de Cables

Parte 2: Diseñando el Hardware…

Empecemos por conocer un poco más a fondo el nuevo módulo 3G de Cooking Hacks ya que será parte fundamental en este proyecto.

Este módulo es de los más completos que he podido probar hasta la fecha, pues aúna en un único shield las siguiente características:

• Compatibilidad con WCDMA y HSPA.
• Hacer y recibir llamadas y video llamadas.
• Mandar sms y mms.
• GPS interno compatible con A-GPS (GPS asistido) y S-GPS (Gps simultáneo).
• Video cámara compatible con foto y video.
• Podemos conectar un micrófono, un altavoz y hasta unos cascos con manos libres.
• Tarjetas SD hasta 32 Gb.
• Podemos utilizarlo como modem 3G.
• Comunicación directa por HTTP/HTTPS.
• Subir y bajar archivos vía FTP/FTPS.
• Mandar y recibir correos POP3/SMTP.
• Reproducir y grabar archivos de audio.

Todo esto descrito, lo podremos gestionar por comandos AT desde nuestro Arduino como veremos en la parte de programación.

En cuanto a conexiones específicas para este módulo, vamos a usar la salida de “loudspeaker”, el socket para la tarjeta SIM, el socket para la tarjeta microSD y la cámara VGA.

También deberemos tener en cuenta la posición de los dos jumpers que conmutan la dirección de comunicación, pues podremos controlarlo desde nuestro Arduino, o directamente por su puerto USB mediante Cutecom, hyperterminal o similar.

En la siguiente imagen podemos ver todas las conexiones disponibles del módulo.

Imagen by Cooking Hacks

Lo bueno que tienen este tipo de shields, es que al estar diseñado para Arduino, van directamente “pinchados” en él y vamos a poder seguir utilizando casi todas las funcionalidades de este, pues tan solo necesita de tres pines para su funcionamiento, pin 0 y 1 para la comunicación y el pin 2 que activa o desactiva el módulo, algo muy interesante si queremos ahorrar consumo en nuestros proyectos, podríamos estar recogiendo datos durante todo el día, y que solo a cierta hora, encendiera el módulo, nos mandara los datos, y lo vuelva a apagar!

Ahora sigamos con el resto de componentes de nuestro proyecto!

Como detector de intrusos, vamos a usar un sensor de ultrasonidos con un rango de 3cm a 300cm , como vemos en la imagen, tan solo constan de tres patillas, dos son para alimentación (Vcc y Gnd) y una tercera conectada a nuestro Arduino por la que “dispararemos” los pulsos y a su vez los recibiremos, estos pulsos no son más que una señal acústica a una frecuencia imperceptible al oído humano.

La secuencia de funcionamiento es la siguiente:

• Si mandamos un pulso (HIGH) desde Arduino de entre 2μS y 10μS, este lo interpretará como un disparador (trigger) y emitirá un tren de 8 pulsos a una frecuencia de 40Khz.
• Automáticamente deberemos poner el pin donde tenemos conectado SIGNAL como entrada, pues si ese tren de pulsos acústicos rebota en algún objeto y vuelve al sensor, este lo detectará y lo transformará en una señal eléctrica que deberemos interpretar desde Arduino, algo parecido a cuando gritamos ECO!! y a los segundos lo escuchamos de vuelta.
• En función del tiempo que ese “ECO” haya tardado en volver al sensor, podremos determinar la distancia a la que ha rebotado, pues conocemos la velocidad de propagación del sonido en el aire, y el tiempo que ha tardado en volver a nosotros, para ello usaremos esta fórmula:

El funcionamiento es muy sencillo, como su propio nombre indica, es una matriz de conexiones dispuestas en filas y columnas, de izquierda a derecha y de arriba a abajo, de manera que si pulsamos el número 1, estaremos uniendo fila 1 con columna 1, si pulsamos el número 0, estaremos uniendo fila 4 con columna 2, etc.. mejor veamos una representación de sus conexiones internas:

&nsbp;En cuanto a la configuración de pines, es muy sencilla, con las teclas hacia nosotros, tendremos de izquierda a derecha, primero las filas en orden, y luego las columnas.

Para gestionar estas combinaciones, tendremos la librería keypad.h que nos va a facilitar en gran medida la programación como veremos posteriormente.

Por último, vamos a usar un Led RGB de ánodo común para visualizar los diferentes estados de nuestra alarma, cuando esté esperando un intruso, estará en verde, durante el margen de tiempo para desactivarla, estará en azul, y si agotamos ese tiempo, o introducimos una contraseña incorrecta, se pondrá en color rojo.

Este diodo led es en si mismo, tres diodos integrados en un mismo encapsulado, uno de color Rojo (R), otro de color Verde (G) y uno de color Azul (B) y tiene la característica de que podemos reproducir teóricamente cualquier color combinando las intensidades de cada uno de ellos.

Como hemos indicado, este Led RGB en concreto, es de ánodo común, es decir, hay una de las patillas conectada constantemente a positivo, y para polarizar cada color, deberemos llevarlo a negativo con su correspondiente resistencia para limitar la corriente que pasa por él, tomando como referencia la más larga, que se corresponderá con el ánodo.

Por último, si queremos saber la combinación de intensidades de cada color para obtener uno en concreto, podemos usar cualquier programa de diseño fotográfico para sacar un paleta de colores, y sobre ella, al seleccionar un color, veremos que nos devuelve un valor decimal para R, G y B de 0 a 255, que casualmente se corresponde con nuestro rango de pwm, entendéis por donde voy?

Con esto espero haber aclarado todo el tema del hardware para este proyecto, así que simplemente os voy a enumerar que debe ir conectado a cada pin de Arduino para que se corresponda con nuestro programa.

• Pin 3: Fila 1 teclado.
• Pin 4: Fila 2 teclado.
• Pin 5: Fila 3 teclado.
• Pin 6: Fila 4 teclado.
• Pin 7: SIGNAL del sensor de ultrasonidos.
• Pin 9: Color rojo del Led RGB.
• Pin 10: Color rojo del Led RGB.
• Pin 11: Color rojo del Led RGB.
• Pin 14: Columna 1 teclado.
• Pin 15: Columna 1 teclado.
• Pin 16: Columna 1 teclado.
• Pin 17: Columna 1 teclado.

Como recordamos, las entradas analógicas las podemos usar como entradas o salidas digitales además de su función de conversor analógico/digital.

Parte 3: Programando…

Cuando abráis el archivo descargado, veréis que está divido en diferentes pestañas, así que iremos analizando una por una.

Os recuerdo que tenéis los archivos del proyecto dentro del nuevo Pack Premium!! Descárgalo ahora con un Retweet!!

Veamos el código de la primera pestaña, donde tenemos toda la configuración y el loop del programa, os recuerdo que detallaremos aquel código que no hayamos visto hasta ahora, si tenéis alguna duda, os recomiendo repasar los tutoriales anteriores donde encontraréis toda la información.

// Incluimos la libreria para el teclado
#include <Keypad.h>

//Declaramos las variables para el proyecto

int onModulePin = 2;        // Pin para activar o desactivar el módulo 3G
int maxsms = 1;             // Numero de sms máximo
int count = 0;              // Contador de sms enviados

char name[20];              // Almacena el nombre de la foto tomada
char nameVideo[20];         // Almacena el nombre del video

int time = 0;               // Guardaremos un tiempo en concreto
int time2 = 0;              // Guardaremos un segundo tiempo para compara con el primero
boolean alarma = false;     // Estado de la alarma
int timeDesc = 11000;       // Tiempo para desactivarla

int pingPin = 7;            // Pin para la señal del sensor de ultrasonidos      
long duracion;              // Almacena el tiempo que ha tardado en volver el pulso
int distancia = 0;          // Almacena la distancia del sensor de ultrasonidos

// Pines para las patillas de cada color del Led RGB
int rojo = 9;
int verde = 10;  
int azul = 11;

char clave[]="0000";        // Clave para desconectar la alarma
int longitud = 4;           // Longitud de nuestra contraseña
char buffer[5];             // Clave introducida para comparar
int x = 0;                  // Variable para rotar la posicion de array donde guardar la contraseña introducida

//Configuramos el teclado
const byte ROWS = 4;       // Cuatro filas
const byte COLS = 4;       // Cuatro columnas

//Definimos los simbolos que tiene nuestro teclado
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte rowPins[ROWS] = {3, 4, 5, 6};               // Pines de Arduino para las filas
byte colPins[COLS] = {14, 15, 16, 17};           // Pines de Arduino para las columnas

//Creamos un nuevo teclado
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

char telefono[]="xxxxxxxxx";                     // Numero de telefono para mandar sms
char correo[]="xxxx@xxxx.com";                   // Correo o telefono donde envia los mms

void setup(){

    //Configuramos puerto UART
    Serial.begin(115200);                
    delay(2000);

    // Pin para activar modulo como salida
    pinMode(onModulePin, OUTPUT);

    //Activamos el módulo 3G
    Serial.println("Activando modulo 3G...");
    digitalWrite(onModulePin,HIGH);
    delay(2000);
    digitalWrite(onModulePin,LOW);

    //Esperamos 25 segundos
    for (int i=0;i < 5;i++){
        delay(5000);
    } 

    //Comprobamos si existe comunicacion con el modulo
    Serial.println("AT");
    while(Serial.read()!='K');
    Serial.println("Existe comunicacion...");

    delay(1500);

    //Introducimos PIN
    Serial.println("AT+CPIN=4611");
    while(Serial.read()!='K');
    Serial.println("Pin Correcto! Iniciando configuracion...");
    delay(5000);

    //Configuramos punto de acceso para MMS
    Serial.println("CONFIGURANDO MODULO GSM...");
    Serial.println("AT+CMMSCURL=\"mmss\"");
    while(Serial.read()!='K');
    Serial.println("URL para mms correcta...");
    Serial.println("at+cmmsproto=1,\"193.209.134.141\",80");
    while(Serial.read()!='K');
    Serial.println("Configuración de proxy y puerto MMS correcta...");
    Serial.println("at+cgsockcont=1,\"IP\",\"mms\"");
    while(Serial.read()!='K');
    Serial.println("Configuración de APN correcta...");

    //Configuramos SD como espacio de almacenamiento principal.
    Serial.println("AT+FSLOCA=1");
    while(Serial.read()!='K');
    Serial.println("Configuración de almacenamiento en SD correcta...");
    Serial.println("Esperando Alarma");

    //Configuramos el LED RGB
    pinMode(9, OUTPUT);
    pinMode(10, OUTPUT);
    pinMode(11, OUTPUT);
    digitalWrite(rojo, HIGH);
    digitalWrite(verde, HIGH);
    digitalWrite(azul,HIGH);

    //Ponemos el Led en color verde
    ledVerde();

}

void loop(){

  //Medimos la distancia
  delay(100); 
  medirDistancia();
  Serial.println(distancia);

  //Comparamos que sea menor que 20 centimetros
  if (distancia < 20)                              //Si lo es, activa la alarma
    {                                          
         alarma = true;
         if (count < maxsms)                      //Si el contador de mensajes es menor que el maximo de mensajes
         {  
           ledAzul();                              //Activamos led alarma
           Serial.println("##### Alarma Activada #####");      //lo imprimimos

           sonidoAlarma();                         //Reproducimos un sonido de alerta
           delay(1000);
           tomaFoto();                             //Tomamos una foto
           delay(500);

           time = millis();                        //Configuramos la cuenta atras
           delay(10);

           Serial.println("10 sg para desconectar");
           Serial.flush();                         //Vaciamos el buffer

       while ((time2 - time) <= timeDesc)          //Durante X segundos...
          {

             time2 = millis();                             //Revisamos el tiempo

             char customKey = customKeypad.getKey();       //Almacenamos la tecla pulsada en customKey 
                  if (customKey != NO_KEY)                 //Si esta pulsada
                      {
                        buffer[x]=customKey;               //La añadimos al buffer  
                        x++;                               //Sumamos 1 al contador;
                       }

            //Cuando ya hemos pulsado el numero maximo de digitos para nuestra contraseña
            if(x == longitud)
              {

                buffer[x]='\0';             //Le decimos que aqui finaliza la cadena
                Serial.print("Se ha guardado en el buffer la clave ");
                Serial.println(buffer);

                //Y comparamos la contraseña introducida con la guardada
                //Si es correcta, descactiva la alarma
                if (strcmp(clave, buffer) == 0)
                  {
                    Serial.println(buffer);
                    alarma = false;
                    Serial.println("Alarma desconectada...");
                    ledVerde();
                    Serial.println("Esperando Alarma");

                  }
                //Si no, estamos perdidos... El programa sigue su curso..  
                 else
                 {
                     Serial.print("Clave erronea ");  
                     Serial.println(buffer); 
                  }

              x=0;                    //Establecemos x a cero de nuevo
              Serial.flush();         //Limpiamos el buffer
              }

          }

      }

     //Si no hemos descanectado la alarma
     if (alarma == true)
     {
       ledRojo();                        //Ponemos el LED en color rojo        
       sonidoGun();                      //Reproducimos el sonido de disparo
       delay(4500);                      //Esperamos a que lo haya reproducido del todo
       mandaSms();                       //Mandamos el sms

       //Esperamos un tiempo para que lo envie correctamente
       for (int i=0;i < 4;i++)
       {          
       delay(5000);
       } 

       Serial.println("Mensaje sms enviado...");
       mandaMms();                        //Mandamos el mms

       for (int i=0;i < 4;i++)            //Esperamos un tiempo para que lo envie correctamente
       {          
       delay(5000);
       }

       Serial.println("Mensaje MMS enviado...");
       count++;                            //Sumamos uno al contador de mensajes enviados
      }

   }
  }

Si empezamos a leer el código, una vez pasadas las declaraciones de las variables que vamos a usar y la librería que vamos a incluir, nos encontramos con algo nuevo, la configuración de nuestro teclado matricial, como vamos a ver, utilizando la librería keypad.h no podrá ser más fácil su configuración!

//Configuramos el teclado
const byte ROWS = 4;       // Cuatro filas
const byte COLS = 4;       // Cuatro columnas

//Definimos los simbolos que tiene nuestro teclado
char hexaKeys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

byte rowPins[ROWS] = {3, 4, 5, 6};               // Pines de Arduino para las filas
byte colPins[COLS] = {14, 15, 16, 17};           // Pines de Arduino para las columnas

//Creamos un nuevo teclado
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

Lo primero que tenemos que hacer es decirle cuantas filas (rows) y columnas (cols) va a tener, a continuación creamos una matriz como la de nuestro teclado, esto lo hacemos creando un array de dos dimensiones como el que podéis ver, donde tendréis que cambiar los caracteres en función del teclado que estéis utilizando, ahora le decimos los pines asignados a las filas y las columnas y creamos un “objeto” Keypad con la siguiente sintaxis:

Keypad(makeKeymap(userKeymap), row[], col[], rows, cols)

Ya lo tenemos configurado para usarlo en nuestro proyecto Arduino!!

A continuación empezamos con el setup.

Podréis observar que activamos la comunicación serie con una velocidad de 115200 baudios, esto es así, por que es la velocidad a la que trabaja el módulo 3G.

  Serial.begin(115200);

Para activar el módulo 3G, debemos enviarle un pulso de 2sg por el pin número 2, si quisiéremos apagarlo, deberíamos hacer lo mismo, esto nos será muy útil para proyectos Arduino que estén alimentados con batería y no necesitemos tener constantemente activo el módulo.

    //Activamos el módulo 3G
    Serial.println("Activando modulo 3G...");
    digitalWrite(onModulePin,HIGH);
    delay(2000);
    digitalWrite(onModulePin,LOW);

Una vez transcurrido un tiempo de espera para que el módulo se inicie correctamente, empezaremos con su configuración mediante comandos AT.

Los comandos AT fueron desarrollados en 1977 por Dennis Hayes como un interfaz de comunicación con un MODEM para así poder configurarlo y proporcionarle instrucciones como llamar, colgar, etc…

Con el tiempo fueron las compañías Microcomm y US Robotics las que siguieron desarrollando y expandiendo el paquete de instrucciones hasta universalizarlo.

Estos comandos los denominamos así por la abreviatura de ATtention.

Aunque en un principio los comandos AT fueron diseñados para trabajar con modems, se han adoptado como estándar de comunicación con los terminales de telefonía móvil.

De esta forma, todos los teléfonos móviles poseen un juego de comandos AT específico que sirve de interfaz para configurar y proporcionar instrucciones a los terminales

De manera que cada terminal móvil posee un juego de comandos AT determinado que le permite realizar todas las tareas para las que ha sido diseñado, en nuestro caso, desde consultar nuestra posición hasta abrir una conexión de datos 3G.

Así que empecemos a configurar!!

La manera que tenemos de enviar los comandos AT a nuestro módulo, es mandándole las cadenas de texto mediante la comunicación serie a través de la instrucción Serial.println y derivados.

En primer lugar le vamos a enviar el comando AT más básico, el cual simplemente es “AT”, con esto nos vamos a asegurar que existe comunicación con el módulo, ya que cada vez que le enviamos un comando al módulo, y este lo recibe y ejecuta correctamente, nos devuelve un OK, de ahí que después de cada módulo, vamos a esperar el “OK” para continuar con el programa, esto lo hemos hecho mediante la conocida instrucción while diciéndole que hasta que no reciba una K, no siga adelante.

    Serial.println("AT");
    while(Serial.read()!='K');
    Serial.println("Existe comunicacion...");

Si queréis tener toda la guía de referencia de los comandos AT de este módulo, podéis descargarla desde este enlace:

Para evitar duplicar todo el código, os dejo un pequeño resumen de los comandos AT que usamos en este setup:

• AT+CPIN=0000 Introducimos el pin de nuestra tarjeta SIM.
• AT+CMMSCURL=”mmss” URL del servidor MMS de nuestro operador sin el http:// delante. (Ponemos la contra barra para que no nos coja las comillas como fin de cadena, ya que la url debe ir entrecomillada).
• AT+CMMSPROTO=1,”193.209.134.141″,80 Establecemos los parámetros del protocolo (0=Wap 1=http), el proxy MMS y el puerto de nuestro operador.
• AT+CGSOCKCONT=1,”IP”,”mms” Definimos los parámetros PDP (Packet Data Protocol) entre los que está el punto de acceso (APN) para MMS de nuestro operador, en nuestro caso, “mms”
• AT+FSLOCA=1 Seleccionamos la SD como lugar de almacenamiento (0 = C:/ 1 =D:/).

Con estos parámetros configurados ya tendremos a nuestro módulo 3G preparado para empezar a ejecutar el loop!

Veamos un diagrama de flujo para entenderlo rápidamente.

Cuando la distancia es inferior a la establecida, almacenamos en una variable que la alarma está activada…

 alarma = true;

Comprobamos que el contador de sms enviados no ha llegado a su limite…

if (count < ; maxims)

Llamamos a la función que nos ilumina en color azul al diodo Led RGB…

ledAzul();

Reproducimos un mp3 y tomamos una fotografía, observar que hacemos un delay del tiempo que dura nuestro mp3 para evitar que se siga ejecutando instrucciones durante ese tiempo y uno de 500 milisegundos para asegurarnos que la foto se ha almacenado correctamente.

sonidoAlarma();
delay(1000);
tomaFoto();
delay(500);

Por último almacenamos el tiempo que lleva conectada la placa para utilizarla como contador y comparar después el tiempo transcurrido para la desconexión.

El ciclo while durará tanto como hayamos configurado en la variable timeDesc, debido a que va a comprobar continuamente que la diferencia entre time2 (tiempo que se actualiza constantemente) y time1 (tiempo que se ha fijado al activar la alarma) sea inferior a timeDesc.

Dentro de este ciclo nos vamos a encontrar la instrucción que lee cuando hemos pulsado una tecla de nuestro keypad:

char customKey = customKeypad.getKey();

Es decir, constantemente va a almacenarse en customKey el carácter que hayamos pulsado, acto seguido ponemos una condición tal que si el valor almacenado en customKey es diferente a NO_KEY (tecla no pulsada) nos lo guardará en un buffer para compararlo luego con nuestra contraseña predefinida.

if (customKey != NO_KEY)                    //Si esta pulsada
        {
         buffer[x]=customKey;               //La añadimos al buffer
         x++;                               //Sumamos 1 al contador
        }

Así vamos llenando el buffer hasta que tiene la longitud definida.

Cuando ha llegado a ese punto, simplemente comparamos las cadenas de caracteres almacenadas en buffer y en clave para tomar la decisión de colocar la variable alarma en false o true dependiendo de si está o no desactivada.

Para finalizar el loop, si el estado de alarma es igual a true, ejecutaremos las funciones que nos colocarán el led en color rojo, nos reproducirá un sonido de alarma más contundente, mandará un sms y por último un mms.

Ahora veamos todas las funciones a las que llamamos por separado.

En primer lugar, vemos las funciones que nos cambiarán de color nuestro diodo Led RGB, como podéis observar no tiene ningún misterio, tan solo deberemos colocar en LOW aquella patilla que se corresponda con el color que queremos mostrar gracias a que no tenemos que mezclar ningún color para obtener los que necesitamos.

void ledVerde()
{
  digitalWrite(verde, LOW);
  digitalWrite(rojo, HIGH);
  digitalWrite(azul, HIGH);
}

void ledRojo()
{
  digitalWrite(verde, HIGH);
  digitalWrite(rojo, LOW);
  digitalWrite(azul, HIGH);
}

void ledAzul()
{
  digitalWrite(verde, HIGH);
  digitalWrite(rojo, HIGH);
  digitalWrite(azul, LOW);
}

Ahora veamos la función que nos va medir la distancia que nos manda nuestro sensor de ultrasonidos conectado a Arduino, como he explicado en la sección de hardware, lanzaremos un pulso por la patilla pingPin de 5 milisegundos para disparár el tren de pulsos de alta frecuencia, y automáticamente nos pondremos a escuchar, una vez recibido el eco, lo almacenamos y lo transformamos en la distancia gracias a la fórmula explicada.

void medirDistancia()
{
  pinMode(pingPin, OUTPUT);                    //Ponemos el el pin como salida
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);                        //Lo ponemos en nivel bajo 2 micro segundos para tener un disparo alto limpio
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);                        //Realizamos el disparo para que emita el tren de pulsos
  digitalWrite(pingPin, LOW);
  pinMode(pingPin, INPUT);                     //Nos ponemos a escuchar cuando vuelve el sonido
  duracion = pulseIn(pingPin, HIGH);           //Nos dice cuanto tiempo ha tardado en recibir una señal
  distancia = duracion / 29 / 2;               //la pasamos a centimetros
}

Para reproducir sonidos vamos a ejecutar dos funciones, una para cada mp3 almacenado, pues necesitamos llamar al archivo en concreto, como veremos son las mismas, solo que cambiando el nombre del archivo a reproducir.

void sonidoAlarma(){
     Serial.println("AT+FSCD=D:/Audio");                //Indicamos en que carpeta esta nuestro mp3
     while(Serial.read()!='K');
     Serial.println("carpeta configurada");
     Serial.println("AT+CSDVC=3");                      //Le decimos por donde queremos que lo reproduzca
     while(Serial.read()!='K');
     Serial.println("altavoz seleccionado");
     Serial.println("AT+CCMXPLAY="alarma.MP3",0");    //Le damos al play
     while(Serial.read()!='K');
     Serial.println("reproduciendo");
    }

void sonidoGun(){
     Serial.println("AT+FSCD=D:/Audio");                //Indicamos en que carpeta esta nuestro mp3
     while(Serial.read()!='K');
     Serial.println("carpeta configurada");
     Serial.println("AT+CSDVC=3");                      //Le decimos por donde queremos que lo reproduzca
     while(Serial.read()!='K');
     Serial.println("altavoz seleccionado");
     Serial.println("AT+CCMXPLAY="gun.MP3",0");       //Le damos al play
     while(Serial.read()!='K');
     Serial.println("reproduciendo");
    }

Los comandos AT que hemos utilizado son los siguientes:

• AT+FSCD=D:/Audio Le decimos que se ubique en la carpeta Audio de nuestra tarjeta SD, que es donde están los mp3.
• AT+CSDVC=3 Le decimos que use el Speaker para reproducir el mp3 (1=manos libre, 2=speaker, 3=loudspeaker, 4=interface pcm)
• AT+CCMXPLAY=”alarma.MP3″,0 Le decimos el nombre del archivo a reproducir y si queremos reproducirlo durante una llamada o no.

Para realizar la foto, veremos que una vez configurada la cámara, y la foto está tomada, debemos darle a guardar, pero esta vez en lugar de devolvernos un OK, nos devolverá el nombre del archivo de la foto que deberemos guardar en un array para usarlo después en el envío del mms.

void tomaFoto(){
  Serial.println("Haciendo fotografia...");
  Serial.println("AT+CCAMS"); //Iniciamos la camara
  while(Serial.read()!='K');
  Serial.println("AT+CCAMSETD=640,480");         //Indicamos la resolucion
  while(Serial.read()!='K');
  Serial.println("AT+CCAMTP");                   //Tomamos la fotografia
  while(Serial.read()!='K');
  delay(2000);
  Serial.println("AT+CCAMEP");                   //Guardamos la foto
  Serial.flush();
  while(Serial.read()!='/');                     //Seleccionamos a partir de donde vamos a empezar a guardar el nombre de la foto
  while(Serial.read()!='/');

  //Guardamos el nombre de la foto para luego enviarla
  int z=0;
  //Mientras z sea menor que 19...
  do
    {
     while(Serial.available()==0);               //Mientras no haya nada en el puerto serie.. ahi quieto parao..
     name[z]=Serial.read();                      //A paritr de que reciba algo, lo empieza a almacenar
     z++;
    }

  while(z < ; 19);

    while(Serial.read()!='K');
    delay(500);
    Serial.print("El nombre de la foto es ");
    Serial.println(name);
    Serial.println("AT+CCAME"); //paramos la camara
    while(Serial.read()!='K');
    Serial.println("Foto almacenada correctamente...");
}

Los comandos AT que hemos utilizado son los siguientes:

• AT+CCAMS Iniciamos las cámara, y nos asegura que está bien conectada.
• AT+CCAMSETD=640,480 Ajustamos la resolución de la fotografía.
• AT+CCAMTP Tomamos la fotografía.
• AT+CCAMEP Guardamos la fotografía.
• AT+CCAME Paramos la cámara.

Para enviar los sms, además de los comandos AT normales, las características de estos módulos nos dice que debemos enviarle para enviar el sms un Crtl+Z y un CR + LF, esto lo haremos con la instrucción Serial.Write(); que como recordamos, nos sirve para enviar datos binarios por puerto serie, en lugar de los caracteres directamente, para ello enviaremos 0x1A para Crtl+Z, 0x0D para CR y 0x0A para LF.

void mandaSms()
{

        Serial.println("AT+CMGF=1");             //Seleccionamos modo texto
        delay(3000);
        Serial.print("AT+CMGS="");		 //Añadimos el numero de telefono
        Serial.print(telefono);
	Serial.println(""");
        delay(3000);
        Serial.print("Alarma activada!! Revisa tu correo!!");     //cuerpo del mensaje
        delay(500);
        Serial.write(0x1A);      //Mandamos un Ctrl+Z
        Serial.write(0x0D);     //Mandamos un CR
        Serial.write(0x0A);     //Mandamos un LF
        delay(5000);
}

Los comandos AT que hemos utilizado son:

• AT+CMGF=1 Seleccionamos el formato del sms (0=PDU 1=texto)
• AT+CMGS=”telefono” Teléfono es la variable donde tenemos almacenado nuestro destinatario.

Y para finalizar, prepararemos y enviaremos nuestro mms a nuestro correo o teléfono móvil con la foto del intruso que ha hecho saltar la alarma.

void mandaMms(){
  Serial.println("Enviando MMS...");
  Serial.println("AT+FSCD=D:");                        //Le decimos la unidad donde esta nuestra foto
  while(Serial.read()!='K');
  delay(2000);
  Serial.println("AT+FSCD=PICTURE");                    //Le decimos la carpeta
  while(Serial.read()!='K');
  delay(5000);
  Serial.println("AT+CMMSEDIT=1");                      //Entramos en modo edicion de mms
  while(Serial.read()!='K');
  delay(2000);
  Serial.println("at+cmmsdowm="TITLE",6");            //Le decimos que el titulo del mms va a ser ladron
  delay(2000);
  Serial.println("LADRON");
  delay(4000);
  Serial.print("AT+CMMSDOWN="FILE",4,"");            //Le decimos el nombre de la foto a mandar
  Serial.print(name);
  Serial.println(""");
  delay(5000);
  while(Serial.read()!='K');
  delay(2000);
  Serial.print("AT+CMMSRECP="");                        //Le añadimos un destinatario
  Serial.print(correo);
  Serial.println(""");
  while(Serial.read()!='K');
  delay(2000);
  Serial.println("AT+CMMSSEND");                        //Y lo enviamos!!!
  while(Serial.read()!='K');
  delay(15000);
}