GMS Web Server

Este programa enciende una placa Arduino o Genuino con el escudo GSM y una tarjeta SIM habilitada en un servidor web. Cuando la placa recibe una solicitud de un cliente conectado, devuelve el valor de las entradas analógicas 0 a 5.

No todos los operadores de red permiten solicitudes de datos entrantes desde fuera de su red. Esto significa que puede crear un servidor web con el escudo GSM, pero puede no ser capaz de conectarse a él desde Internet; sólo podrá desde otro dispositivo de datos habilitado por el mismo proveedor en la misma red. Debería consultar con su proveedor para ver qué políticas específicas tienen lugar con respecto a las conexiones de datos entrantes.

Hardware necesitado

Placa Arduino o Genuino.
Escudo GSM/GPRS Telefonica + Arduino 
Tarjeta SIM habilitada para datos
6 Potenciómetros o cualquier entrada analçogica conectada a los pines A0 a A5.(opcional)

Circuito


Sensores analógicos opcionales como fotoresistores, potenciómetros y similares pueden estar conectados, como se explica en otra parte de nuestros tutoriales, a los pines A0 - A5

Código

En primer lugar, importar la biblioteca de GSM

#include <GSM.h>

Las tarjetas SIM pueden tener un número de  PIN que permite su funcionalidad. Defina el PIN de su tarjeta SIM. Si su tarjeta SIM no tiene PIN, puede dejarlo en blanco:

#define PINNUMBER ""

Definir una serie de constantes que contienen información acerca de la red GPRS a la que va a conectar. Necesitará el nombre de punto de acceso (APN), inicio de sesión (login) y contraseña (password). Para obtener esta información, póngase en contacto con su proveedor de red para la información más actualizada. Esta página tiene alguna información acerca de los diversos ajustes de operador, pero puede no estar actualizada.

#define GPRS_APN       "GPRS_APN"
#define GPRS_LOGIN     "login"
#define GPRS_PASSWORD  "password"
  
Inicializar instancias de las clases que va a utilizar. Va a necesitar las clases GSM, GPRS, y GSMserver. Cuando se instancia la clase GSMserver, se tiene que indicar a qué puerto se va a escuchar por las conexiones entrantes. El puerto 80 es el puerto por defecto para las peticiones HTTP.

GPRS gprs;
GSM gsmAccess;
GSMServer server(80);

En setup, abra una conexión serie al ordenador. Después de abrir la conexión, envíe un mensaje que indica que el programa se ha iniciado.
 
void setup(){
   Serial.begin(9600);
   Serial.println("Iniciando web cliente Arduino.");
  
Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el programa arrancado hasta que la tarjeta SIM esté conectado a la red:  

boolean notConnected = true;

Conectarse a la red llamando a gsmAccess.begin (). Se necesita el PIN de la tarjeta SIM como argumento. También podrá conectarse a la red GPRS utilizando gprs.attachGPRS (). Esto requiere el APN, el login y la password se hayan declarado anteriormente. Al colocar esto dentro de un bucle while (), se puede comprobar continuamente el estado de la conexión y esperar a que ambos se conecten realmente antes de continuar.

Cuando el módem y la conexión se hayan conectado a la red GPRS, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected como true o false. Una vez conectado, el resto de la configuración se ejecutará.

while(notConnected)
   {
     if(gsmAccess.begin(PINNUMBER)==GSM_READY)
         (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD)==GPRS_READY))
       notConnected = false;
     else
     {
       Serial.println("No conectado");
       delay(1000);
     }
   }

Iniciar el servidor utilizando server.begin (). Puede solicitar la dirección IP del servidor con grps.getIPAddress () y terminar la setup.

server.begin();

   IPAddress LocalIP = gprs.getIPAddress();
   Serial.println("Server IP address=");
   Serial.println(LocalIP);
 }
  
En loop, crear una instancia de GSMClient y comprobar si hay conexiones activas

void loop() {
   GSMClient client = server.available();

   if (client)
   {
  
Mientras que el cliente está conectado, y no hay datos esperando a ser leídos, comenzar a leer la petición. Leer los bytes disponibles hasta que un carácter de nueva línea se  reciba.

En este caso, en realidad no se hace nada con la solicitud, se asume que se trata de una petición HTTP, y podrá servir una página web.

while (client.connected())
     {
       if (client.available())
       {
         Serial.println("Receiving request!");
         bool sendResponse = false;
         while(char c=client.read()) {
           if (c == '\n') sendResponse = true;
         }
  
Una vez que la solicitud ha sido leída, comenzar a enviar un encabezado de respuesta HTTP estándar con client.print () y client.println ().

if (sendResponse)
        {
           client.println("HTTP/1.1 200 OK");
           client.println("Content-Type: text/html");
           client.println();
           client.println("<html>");

Leer las entradas analógicas y envíar los valores al cliente.

for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
             client.print("analog input ");
             client.print(analogChannel);
             client.print(" is ");
             client.print(analogRead(analogChannel));
             client.println("<br />");      
           }

Enviar una etiqueta de cierre para la página web, y detener la conexión del cliente antes de cerrar loop.

client.println("</html>");
           //necessary delay
           delay(1000);
           client.stop();
         }
       }
     }
   }
 }
  
Una vez que se carga el código, abrir el monitor serie. Una vez que la dirección IP se imprime al monitor serie, lo inserta en un navegador web. Debería ver una página web que informa de los valores de entrada analógica en seis entradas de la placa Arduino.

Si no puede conectarse a la dirección IP, asegúrese de que su operador de red permite el tráfico entrante.

El esquema completo se encuentra a continuación.

// Servidor Web GSM

 // Un sencillo servidor web que muestra el valor de los pines de las entradas
 // analógicas, usando un escudo GSM.

 //Circuito:
 // * Escudo GSM conectado
 // * Las entradas analógicas conectadas a los pines A0 a A5 (opcional)

 //creado el 8 de Marzo de 2012
 //por Tom Igoe

 // bibliotecas
 #include <GSM.h>

 // Numero dePIN
 #define PINNUMBER ""

 // datos APN
 #define GPRS_APN       "GPRS_APN" // reemplazar por su APN GPRS
 #define GPRS_LOGIN     "login"    // reemplazar por su login GPRS
 #define GPRS_PASSWORD  "password" // reemplazar por su password GPRS


 // initializa la instancia biblioteca
 GPRS gprs;
 GSM gsmAccess;     // incluye un parametro 'true' para permitir la depuracion
 GSMServer server(80); // puerto 80 (http por defecto)

 // timeout
 const unsigned long __TIMEOUT__ = 10 * 1000;

 void setup() {
   // initializa la comunicacion serie y espera a que se abra el puerto:
   Serial.begin(9600);
   while (!Serial) {
     ; // Espera a que el puerto este conectado. solo necesariopata USB nativo
   }

   // estado de la conexion
   boolean notConnected = true;

   // Inicia el escudo GSM
   // Si su SIM tiene PIN, pase este como parametro de begin() entre comillas
   while (notConnected) {
     if ((gsmAccess.begin(PINNUMBER) == GSM_READY) &
         (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD) == GPRS_READY)) {
       notConnected = false;
     } else {
       Serial.println("No conectado");
       delay(1000);
     }
   }

   Serial.println("Conectado a la red GPRS");

   // inicia el servidor
   server.begin();

   //Obtiene la IP.
   IPAddress LocalIP = gprs.getIPAddress();
   Serial.println("Direccion IP del Servidor=");
   Serial.println(LocalIP);
 }

 void loop() {


   // escucha a los clientes entrantes
   GSMClient client = server.available();



   if (client) {
     while (client.connected()) {
       if (client.available()) {
         Serial.println("Recibiendo peticion!");
         bool sendResponse = false;
         while (char c = client.read()) {
           if (c == '\n') {
             sendResponse = true;
           }
         }

         // Si ha llegado hasta el final de la línea
         if (sendResponse) {
           // enviar un encabezado de respuesta HTTP estándar
           client.println("HTTP/1.1 200 OK");
           client.println("Content-Type: text/html");
           client.println();
           client.println("<html>");
           // saca el valor de cada pin de entrada analógica
           for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
             client.print("La entrada analogica ");
             client.print(analogChannel);
             client.print(" es ");
             client.print(analogRead(analogChannel));
             client.println("<br />");
           }
           client.println("</html>");
           //temporizacion necasaria
           delay(1000);
           client.stop();
         }
       }
     }
   }
 }


No hay comentarios:

Publicar un comentario