Optimizar la programación del GPRS.

Dotarlo de mayor autonomía.

Crear una función para enviar los comandos AT

Agrupar el envío y la recepción de llamadas y SMS en un sólo programa.

 
 

 

	Arduino UNO
	Shield GPRS

 

 

En las sesiones anteriores dedicadas al GRPS hemos visto cómo conectarlo correctamente y los comandos AT necesarios para enviar y recibir llamadas y SMS de una forma bastante sencilla. Sin embargo, para el que se haya fijado, aunque los comandos AT se envían correctamente y el módulo cumple la función que buscamos, hay algunas cosillas que se pueden mejorar.

Y es que al parecer la librería SoftwareSerial no se lleva del todo bien con el módulo GPRS y los comandos AT; y al enviar simplemente estos comandos con función SIM900.println(); algunas respuestas se quedan en el limbo.

A esto podríamos añadir que, siendo el GPRS un módulo orientado hacia proyectos autónomos y sin supervisión, no tendremos acceso al monitor serie (hasta ahora lo hemos supervisado desde ahí), no estaremos seguros de que las cosas estén yendo bien y estemos realmente conectados a la red móvil.

Y por último, podría ser que durante el periodo que tengamos funcionando nuestro proyecto perdiera la alimentación del Arduino o del GPRS, o se desconectase de la red móvil por alguna razón. Así que también vamos a implementar una serie de funciones para que sea capaz de reiniciarse y configurarse de forma autónoma, y de que se asegure que estemos conectados a la red antes de enviar llamadas o SMS.

Para poder reiniciarlo de esta forma y dotarle de autonomía es imprescindible haber realizado la soldadura que habilita el encendido por software del módulo GPRS mediante un pulso en el pin 9, y conectarlo al pin 9 de Arduino que usaremos para ello (ya hablamos de esto en las sesiones anteriores).

 

Al parecer el error al recibir algunas respuestas de los comandos AT por el monitor serie se debe a que enviamos el comando siguiente antes de recibir la respuesta, y los “delays” no parecen solucionarlo, sino todo lo contrario (como casi siempre).

Por lo tanto crearemos una función enviarAT con los siguientes objetivos:

Enviar el comando AT.

Esperar una respuesta del SIM900.

Comprobar que la respuesta es correcta.

Mostrar por el monitor serie la respuesta recibida.

 
La programación de la función queda de la siguiente forma:

int enviarAT(String ATcommand, char* resp_correcta, unsigned int tiempo)
{

  int x = 0;
  bool correcto = 0;
  char respuesta[100];
  unsigned long anterior;

  memset(respuesta, '\0', 100); // Inicializa el string
  delay(100);
  while ( SIM900.available() > 0) SIM900.read(); // Limpia el buffer de entrada
  SIM900.println(ATcommand); // Envia el comando AT
  x = 0;
  anterior = millis();
  // Espera una respuesta
  do {
    // si hay datos el buffer de entrada del UART lee y comprueba la respuesta
    if (SIM900.available() != 0)
    {
        respuesta[x] = SIM900.read();
        x++;
      // Comprueba si la respuesta es correcta
      if (strstr(respuesta, resp_correcta) != NULL)
      {
        correcto = 1;
      }
    }
  }
  // Espera hasta tener una respuesta
  while ((correcto == 0) && ((millis() - anterior) < tiempo));
  Serial.println(respuesta);

  return correcto;
}

Está función la usaremos siempre que enviemos un comando AT, y si queremos verificar la respuesta, simplemente la incluiremos dentro de un if que verifique que nos el módulo nos haya devuelto la respuesta que buscamos.

Esta estructura condicional la usaremos para verificar que realmente estemos conectados a la red móvil, aunque podríamos usarlo en todos los comandos AT para que, en caso de que algo falle, nos saque un mensaje por pantalla indicándonos dónde está el error.  Realmente no totalmente necesario ya que leyendo el monitor serie se puede ver dónde falla con sólo  mirar las respuestas a los comandos AT.

 

Ya hemos hablado anteriormente acerca de cómo encender y apagar el módulo sin tener que presionar el pulsador del GPRS, enviando un pulso de un segundo desde Arduino al pin 9 de la tarjeta. Sin embargo, imaginad que enviamos las instrucciones para encenderlo y resulta que ya estaba encendido. Lo que haríamos sería apagarlo.

Así que vamos a crear también una función para encender el módulo pero comprobando antes que no está encendido ya. Es muy sencillo, si enviamos el comando “AT”  y nos devuelve OK es que estaba encendido. Si no devuelve nada tendremos que enviar el pulso para encenderlo:

 

void power_on()
{
  int respuesta = 0;

  // Comprueba que el modulo SIM900 esta arrancado
  if (enviarAT("AT", "OK", 2000) == 0)
  {
    Serial.println("Encendiendo el GPRS...");

    pinMode(9, OUTPUT);
    digitalWrite(9, HIGH);
    delay(1000);
    digitalWrite(9, LOW);
    delay(1000);

    // Espera la respuesta del modulo SIM900
    while (respuesta == 0) {
      // Envia un comando AT cada 2 segundos y espera la respuesta
      respuesta = enviarAT("AT", "OK", 2000);
      SIM900.println(respuesta);
    }
  }
}

Complementariamente a esta función vamos a crear otras dos muy sencillitas, una que apague el módulo y otra que incluya estás dos que para reiniciar el módulo, y que usaremos si perdemos la conexión a la red.

void power_off()
{
  digitalWrite(9, HIGH);
  delay(1000);
  digitalWrite(9, LOW);
  delay(1000);
}

void reiniciar()
{
  Serial.println("Conexion a la red perdida. Reiniciando el modulo...");
  power_off();
  delay (5000);
  power_on();
}

 

También tenemos funciones que ya hemos usado anteriormente, pero que tenemos que adaptar a la filosofía de esta sesión. Es decir, enviaremos los comandos AT utilizando la función que hemos creado y comprobaremos que estemos conectados correctamente a la red móvil.

Estas funciones son las que usamos para configurar el módulo correctamente y las que propiamente realizan el envío de las llamadas y los SMS.

void iniciar()
{
  enviarAT("AT+CPIN=\"1867\"", "OK", 1000);
  Serial.println("Conectando a la red...");
  delay (5000);

  //espera hasta estar conectado a la red movil
  while ( enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 0 )
  {
  }
  Serial.println("Conectado a la red.");
  enviarAT("AT+CLIP=1\r", "OK", 1000); // Activamos la identificacion de llamadas
  enviarAT("AT+CMGF=1\r", "OK", 1000); //Configura el modo texto para enviar o recibir mensajes
  enviarAT("AT+CNMI=2,2,0,0,0\r", "OK", 1000); //Configuramos el modulo para que nos muestre los SMS recibidos por comunicacion serie
  Serial.println("Preparado.");
}

void mensaje_sms()
{
  if (enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 1) //comprueba la conexion a la red
  {
    Serial.println("Enviando SMS...");
    enviarAT("AT+CMGF=1\r", "OK", 1000); //Comando AT para mandar un SMS
    sprintf(aux_str, "AT+CMGS=\"XXXXXXXXX\"", strlen(sms)); //Numero al que vamos a enviar el mensaje
    //Texto del mensaje
    if (enviarAT(aux_str, ">", 10000) == 1)
    {
      enviarAT(sms, "OK", 10000);
    }
    Serial.println("SMS enviado");
  }
  else
  {
    reiniciar();
    iniciar();
  }
}
void llamar()
{
  if (enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 1) //Comprueba la conexion a la red
  {
    Serial.println("Realizando llamada...");
    enviarAT("ATDXXXXXXXXX;", "OK", 1000);
    delay(20000); // Espera 20 segundos mientras realiza la llamada
    enviarAT("ATH", "OK", 1000); // Cuelga la llamada
    Serial.println("Llamada finalizada");
  }
  else
  {
    reiniciar();
    iniciar();
  }
}

 

Una vez hemos creado las funciones que vamos a necesitar, la estructura del programa no tiene nada demasiado complicado. Con este programa realizaremos una llamada al teclear una “l” en el monitor serie y enviaremos un SMS con la letra “s”. Evidentemente también recibiremos llamadas y SMS y mostraremos la información de ambas en pantalla, del número de teléfono y del contenido del mensaje en el caso de que sea un SMS.

#include <SoftwareSerial.h> 

SoftwareSerial SIM900(7, 8); // Configura el puerto serial para el SIM900. Para el Arduino MEGA utilizar pines 10 y 11

int respuesta;
char aux_str[50];

//Contenido del sms que enviamos. \x1A corresponde al caracter de finalizacion
char sms[] = "Mensaje enviado desde el Arduino de Prometec! \x1A \r\n";

void setup()
{
  SIM900.begin(19200); //Configura velocidad del puerto serie para el SIM900
  Serial.begin(19200); //Configura velocidad del puerto serie del Arduino
  delay(1000);
  Serial.println("Iniciando...");
  power_on();
  iniciar();
}

void loop()
{
  if (Serial.available())
    switch (Serial.read())
    {
      case 'l':
        llamar();
        break;
      case 's':
        mensaje_sms();
        break;
    }
  if (SIM900.available()) {
    Serial.write(SIM900.read());
  }
}

Podéis descargar aquí el programa completo: Envio_y_recepcion_de_llamadas_y_SMS.

 

Con este programa creemos que ya podréis afrontar vuestros proyectos con mayores garantías de éxito, otorgándoles un cierto nivel de autonomía y confianza. La estructura de tipo switch() que hemos creado nos da la posibilidad de incluir de forma muy sencilla otros casos en los que sean las lecturas de ciertos sensores las que activen las llamadas o los SMS, e incluso podrías incluir en estos últimos el valor de las lecturas dentro del texto del SMS en el caso que sea necesario.

 

En esta sesión hemos aprendido varias cosas importantes:

A enviar correctamente los comandos AT y asegurarnos de recibir la respuesta del módulo GPRS.

A verificar la respuesta cuando lo creamos necesario.

Asegurarnos de que estamos correctamente conectado a la red móvil.

A encender y reiniciar el módulo por software.

Hemos creado un programa para recibir y enviar llamadas y SMS, al que hemos dotado de capacidad de trabajar de forma autónoma con ciertas garantías de éxito.