f Arduino GSM Tutorial ~ Ingenieria a nivel industrial

Visita mi canal de youtube

sábado, 24 de septiembre de 2016

Arduino GSM Tutorial

GSM Web Client

Este bosquejo se conecta una placa Arduino o Genuino para la página de Arduino, http://arduino.cc, a través del escudo GSM. A continuación, imprime el contenido de la página a través del monitor de serie del software de Arduino (IDE).

hardware necesario

_Arduino o Genuino
_Arduino + Telefónica GSM / GPRS Escudo
_tarjeta SIM de datos para permitir

Circuito



Código

En primer lugar, importar la biblioteca de GSM

#include <GSM.h>


tarjetas SIM pueden tener un número PIN que permite su funcionalidad. Definir 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 que va a conectar. Necesitará el nombre de punto de acceso (APN), inicio de sesión y contraseña. Para obtener esta información, póngase en contacto con su proveedor de red para la información más actualizada. Esta página no 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 vas a utilizar. Vas a necesitar las clases de clientes GSM, GPRS y GSM.


GSMClient client;
GPRS gprs;
GSM gsmAccess;

Crear algunas variables para contener el servidor, la ruta y el puerto que desea conectarse.

char server[] = "arduino.cc";
char path[] = "/";
int port = 80;


En setup , abra una conexión en serie al ordenador. Después de abrir la conexión, envía un mensaje que indica el dibujo se ha iniciado.


void setup(){
  Serial.begin(9600); 
  Serial.println("Starting Arduino web client.");

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:



boolean notConnected = true;


Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. También podrá conectarse a la red GPRS utilizando gprs.attachGPRS (). Esto requiere el APN, el inicio de sesión y la contraseña que ha 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 convierten en true antes de proceder.



Cuando el módem y la conexión se haya conectado a la red GPRS, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de true o false. Una vez conectado, el resto de la setup 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("Not connected");
      delay(1000);
    }
  }

Intentará conectarse al servidor utilizando client.connect (). connect () requiere dos argumentos, el servidor y el puerto. Una vez conectado al servidor, realizar una solicitud HTTP llamando client.print (). Una solicitud web típica se parece a "GET ruta de acceso HTTP / 1.0". print enviará el mensaje, al igual que lo haría un navegador.

if (client.connect(server, port))
  {
    Serial.println("connected");
    client.print("GET ");
    client.print(path);
    client.println(" HTTP/1.0");
    client.println();
  }

Si la conexión con el servidor no pudo, hacer una nota de ello en el monitor serie, y cerrar la instalación.

else
  {
    Serial.println("connection failed");
  }
}

Dentro del loop , comprobar para ver si hay bytes devueltos por el servidor. Si es así, leerlos e imprimirlos al monitor de serie.if (client.available())
  {
    char c = client.read();
    Serial.print(c);
  }

Si se desconecta el servidor, lo que se suele hacer una vez que se ha completado la solicitud HTTP, detener el cliente a nivel local y cerrar el loop.

if (!client.available() && !client.connected())
  {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();

    // do nothing forevermore:
    for(;;)
      ;
  }
}

Una vez que se carga el código, abrir el monitor serie. Debería ver el código HTML de http://arduino.cc imprimir en pantalla cuando se recibe. Tarda aproximadamente un minuto, por lo que no se preocupe si usted no tiene una retroalimentación inmediata!

El esquema completo se encuentra por debajo.


/*
  Web client

 This sketch connects to a website through a GSM shield. Specifically,
 this example downloads the URL "http://www.arduino.cc/asciilogo.txt" and
 prints it to the Serial monitor.

 Circuit:
 * GSM shield attached to an Arduino
 * SIM card with a data plan

 created 8 Mar 2012
 by Tom Igoe

 http://www.arduino.cc/en/Tutorial/GSMExamplesWebClient

 */


// libraries
#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// APN data
#define GPRS_APN       "GPRS_APN" // replace your GPRS APN
#define GPRS_LOGIN     "login"    // replace with your GPRS login
#define GPRS_PASSWORD  "password" // replace with your GPRS password

// initialize the library instance
GSMClient client;
GPRS gprs;
GSM gsmAccess;

// URL, path & port (for example: arduino.cc)
char server[] = "arduino.cc";
char path[] = "/asciilogo.txt";
int port = 80; // port 80 is the default for HTTP

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Starting Arduino web client.");
  // connection state
  boolean notConnected = true;

  // After starting the modem with GSM.begin()
  // attach the shield to the GPRS network with the APN, login and password
  while (notConnected) {
    if ((gsmAccess.begin(PINNUMBER) == GSM_READY) &
        (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD) == GPRS_READY)) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("connecting...");

  // if you get a connection, report back via serial:
  if (client.connect(server, port)) {
    Serial.println("connected");
    // Make a HTTP request:
    client.print("GET ");
    client.print(path);
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(server);
    client.println("Connection: close");
    client.println();
  } else {
    // if you didn't get a connection to the server:
    Serial.println("connection failed");
  }
}

void loop() {
  // if there are incoming bytes available
  // from the server, read them and print them:
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  // if the server's disconnected, stop the client:
  if (!client.available() && !client.connected()) {
    Serial.println();
    Serial.println("disconnecting.");
    client.stop();

    // do nothing forevermore:
    for (;;)
      ;
  }
}

GSM Web Server



Este bosquejo gira la placa Arduino o Genuino con el escudo de datos GSM y una tarjeta SIM habilitada en un servidor web. Cuando la Junta reciba una solicitud de un cliente conectado, devuelve el valor de las entradas analógicas 0-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 la Internet pública; Sólo a partir de otros datos del dispositivo habilitado para el mismo proveedor en la misma red. Debería consultar con su proveedor para ver qué políticas específicas que tienen en su lugar con respecto a las conexiones de datos entrantes.


hardware necesario
_Arduino vs Genuino placa Arduino + Telefónica GSM / GPRS Escudo
_tarjeta SIM habilitada para datos
_ (Opcional) 6 potenciómetros u otras entradas analógicas asociadas a A0-A5


Codigo:

En primer lugar, importar la biblioteca de GSM


#include <GSM.h>


tarjetas SIM pueden tener un número PIN que permite su funcionalidad. Definir 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 que va a conectar. Necesitará el nombre de punto de acceso (APN), inicio de sesión y contraseña. Para obtener esta información, póngase en contacto con su proveedor de red para la información más actualizada. Esta página no 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 vas a utilizar. Vas a necesitar las clases GSM, GPRS, y de GSMserver. Cuando se instancia la clase de GSMserver, se tendrá que indicar a qué puerto se para escuchar 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 en serie al ordenador. Después de abrir la conexión, envía un mensaje que indica el dibujo se ha iniciado.

void setup(){
  Serial.begin(9600); 
  Serial.println("Starting Arduino web client.");

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:


boolean notConnected = true;


Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. También podrá conectarse a la red GPRS utilizando gprs.attachGPRS (). Esto requiere el APN, el inicio de sesión y la contraseña que ha 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 convierten en true antes de proceder.



Cuando el módem y la conexión se haya conectado a la red GPRS, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de 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("Not connected");
      delay(1000);
    }
  }


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

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ído, comenzar a leer la petición. Leer a través de los bytes disponibles hasta que un carácter de nueva línea se ha recibido.



En este caso, en realidad no se hacer 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 (== '\n') sendResponse = true;
        }



Una vez que la solicitud ha sido leído, 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 a través de las entradas analógicas y envía 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 el 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 cada uno de la 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 por debajo.

/*
 GSM Web Server

 A simple web server that shows the value of the analog input pins.
 using a GSM shield.

 Circuit:
 * GSM shield attached
 * Analog inputs attached to pins A0 through A5 (optional)

 created 8 Mar 2012
 by Tom Igoe
 */


// libraries
#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// APN data
#define GPRS_APN       "GPRS_APN" // replace your GPRS APN
#define GPRS_LOGIN     "login"    // replace with your GPRS login
#define GPRS_PASSWORD  "password" // replace with your GPRS password


// initialize the library instance
GPRS gprs;
GSM gsmAccess;     // include a 'true' parameter for debug enabled
GSMServer server(80); // port 80 (http default)

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

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // connection state
  boolean notConnected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (notConnected) {
    if ((gsmAccess.begin(PINNUMBER) == GSM_READY) &
        (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD) == GPRS_READY)) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("Connected to GPRS network");

  // start server
  server.begin();

  //Get IP.
  IPAddress LocalIP = gprs.getIPAddress();
  Serial.println("Server IP address=");
  Serial.println(LocalIP);
}

void loop() {


  // listen for incoming clients
  GSMClient client = server.available();



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

        // if you've gotten to the end of the line (received a newline
        // character)
        if (sendResponse) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
          client.println("<html>");
          // output the value of each analog input pin
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(analogRead(analogChannel));
            client.println("<br />");
          }
          client.println("</html>");
          //necessary delay
          delay(1000);
          client.stop();
        }
      }
    }
  }
}

Make Voice Call

Este bosquejo se conecta una llamada de voz de su escudo y Arduino GSM o Genuino a un número de teléfono a distancia introducida a través del monitor de puerto serie. Tendrá que conectar un altavoz y un micrófono para escuchar el teléfono conectado y transmitir su voz.


hardware necesario



_Arduino vs Genuino placa Arduino + Telefónica GSM / GPRS Escudo

_Micrófono y altavoz conectado al blindaje GSM

_tarjeta SIM


Circuito

Código



En primer lugar, importar la biblioteca de GSM



# include <GSM.h>


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

#define PinNumber ""

Inicializar instancias de las clases que vas a utilizar. Vas a necesitar tanto el GSM y clase GSMVoiceCall.

gsmAccess GSM;
VCS GSMVoiceCall;
[Obtener código]
Crear algunas variables para almacenar el número de teléfono al que desea llamar:

RemoteNumber cadena = "";
Char CharBuffer [20];

En setup, abra una conexión en serie al ordenador. Vamos a usar esto para enviar un número de teléfono para el Arduino. Después de abrir la conexión, enviar un mensaje al monitor de serie que indica el dibujo se ha iniciado.

void setup () {

  Serial.begin (9600);
  Serial.println ( "Hacer Llamada de Voz");

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:

booleano notConnected = true;

Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. Al colocar esto dentro de un bucle while (), se puede comprobar continuamente el estado de la conexión. Cuando el módem hace conectar, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de verdadero o falso. Una vez conectado, el resto de la configuración se ejecutará.

while (notConnected)
  {
    if(gsmAccess.begin (PinNumber) == GSM_READY)
      notConnected = false;
    más
    {
      Serial.println ( "No conectado");
      retardo (1000);
    }
  }

Finalizar la configuración con un poco de información al monitor serie.

Serial.println ( "GSM inicializado.");
  Serial.println ( "Introducir número de teléfono para llamar.");
}

El bucle aceptará bytes entrantes desde el monitor de serie y conectar la llamada de voz.

En primer lugar, comprobar la memoria intermedia serie para ver si hay alguna información esperando a ser leído. Si lo hay, almacenarlo en una variable local:

void loop ()
{
  mientras que (Serial.available ()> 0)
  {
    Char inchar = Serial.read ();

Si el búfer contiene un carácter de nueva línea, comprobar para ver si el número introducido tiene menos de 20 dígitos de longitud (en teoría, nunca serás capaz de marcar un número con más dígitos que eso).

if (inchar == '\ n')
    {
      if (remoteNumber.length () <20)
      {

Imprimir el número al que está llamando al monitor de serie.

Serial.print ( "Llamando a:");
        Serial.println (remoteNumber);
        Serial.println ();

El número para llamar se ha almacenado en la cadena denominado remoteNumber. La función VoiceCall () requiere una matriz de caracteres. Copiar la cadena a la matriz denominada CharBuffer.

remoteNumber.toCharArray (CharBuffer, 20);

Para realizar la llamada, utilizar vcs.voiceCall (), pasándole el número al que desea llamar. VoiceCall () devuelve el estado de la llamada; un 1 significa que está conectado. Puede comprobar el estado de la conexión con getvoiceCallStatus ().

Para desconectar la llamada, enviar un carácter de nueva línea para desencadenar hangCall ().


if (vcs.voiceCall (CharBuffer))

        {

          Serial.println ( "llamada establecida Introduzca la línea hasta el final.");

          mientras que (Serial.read () = '\ n' && (vcs.getvoiceCallStatus () == HABLAR)!);

          vcs.hangCall ();

        }

Una vez que se ha completado la llamada, despejar la variable que almacena el número de teléfono:

Serial.println ( "Call Terminado");
        remoteNumber = "";
        Serial.println ( "Introducir número de teléfono para llamar.");
      }

Si el número que ha introducido en el monitor de serie es más de 20 dígitos, desactive la remoteNumber cadena y empezar de nuevo:

else
      {
        Serial.println ( "Eso es demasiado largo para un número de teléfono que estoy olvidando.");
        remoteNumber = "";
      }
    }

Al leer la información desde el monitor de serie, si el carácter entrante no es un retorno de carro o salto de línea, añadirlo a la cadena remoteNumber y cerrar el loop.

else
    {
      // Añadir el último carácter al mensaje que desea enviar:
      si (inchar! = '\ r')
        remoteNumber + = inchar;
    }
  }
}

Una vez que se carga el código, abrir el monitor serie. Una vez que aparezca el mensaje "Introducir número de teléfono para llamar", escriba un número de teléfono y pulse "retorno". Asegúrese de que el monitor serie está configurado para enviar solamente un carácter de nueva línea de retorno.

El esquema completo se encuentra por debajo.

/*
 Make Voice Call

 This sketch, for the Arduino GSM shield, puts a voice call to
 a remote phone number that you enter through the serial monitor.
 To make it work, open the serial monitor, and when you see the
 READY message, type a phone number. Make sure the serial monitor
 is set to send a just newline when you press return.

 Circuit:
 * GSM shield
 * Voice circuit.
 With no voice circuit the call will send nor receive any sound


 created Mar 2012
 by Javier Zorzano

 This example is in the public domain.
 */


// libraries
#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// initialize the library instance
GSM gsmAccess; // include a 'true' parameter for debug enabled
GSMVoiceCall vcs;

String remoteNumber = "";  // the number you will call
char charbuffer[20];

void setup() {

  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Make Voice Call");

  // connection state
  boolean notConnected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("GSM initialized.");
  Serial.println("Enter phone number to call.");

}

void loop() {

  // add any incoming characters to the String:
  while (Serial.available() > 0) {
    char inChar = Serial.read();
    // if it's a newline, that means you should make the call:
    if (inChar == '\n') {
      // make sure the phone number is not too long:
      if (remoteNumber.length() < 20) {
        // let the user know you're calling:
        Serial.print("Calling to : ");
        Serial.println(remoteNumber);
        Serial.println();

        // Call the remote number
        remoteNumber.toCharArray(charbuffer, 20);


        // Check if the receiving end has picked up the call
        if (vcs.voiceCall(charbuffer)) {
          Serial.println("Call Established. Enter line to end");
          // Wait for some input from the line
          while (Serial.read() != '\n' && (vcs.getvoiceCallStatus() == TALKING));
          // And hang up
          vcs.hangCall();
        }
        Serial.println("Call Finished");
        remoteNumber = "";
        Serial.println("Enter phone number to call.");
      } else {
        Serial.println("That's too long for a phone number. I'm forgetting it");
        remoteNumber = "";
      }
    } else {
      // add the latest character to the message to send:
      if (inChar != '\r') {
        remoteNumber += inChar;
      }
    }
  }
}


DESCARGA ¡¡ GRATIS !! —–> LIBROS DE
ARDUINO
 –>ENTRA AQUI PARA VER

Send SMS


Este bosquejo enviar un mensaje SMS desde una placa Arduino o Genuino equipado con un escudo GSM. Utilización del monitor de serie del software de Arduino (IDE), se le introduce el número para conectar con, y el mensaje de texto para enviar.

hardware necesario

-Arduino o Genuino
 -Arduino + Telefónica GSM / GPRS Escudo
-tarjeta SIM
Código

En primer lugar, importar la biblioteca de GSM

# include <GSM.h>

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

#define PinNumber ""

Inicializar instancias de las clases que vas a utilizar. Vas a necesitar tanto el GSM y clase GSM_SMS.

gsmAccess GSM;
sms GSM_SMS;

En configuración, abra una conexión en serie al ordenador. Después de abrir la conexión, envía un mensaje que indica el dibujo se ha iniciado.

void setup () {
  Serial.begin (9600);
  Serial.println ( "Mensajes SMS Sender");

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:

booleano notConnected = true;

Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. Al colocar esto dentro de un bucle while (), se puede comprobar continuamente el estado de la conexión. Cuando el módem hace conectar, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de verdadero o falso. Una vez conectado, el resto de la configuración se ejecutará.

while (notConnected)
  {
    si (gsmAccess.begin (PinNumber) == GSM_READY)
      notConnected = false;
    más
    {
      Serial.println ( "No conectado");
      retardo (1000);
    }
  }

Finalizar la configuración con un poco de información al monitor serie.

Serial.println ( "GSM inicializado.");
}

Crear una función llamada readSerial de tipo int. Vamos a usar esto para iterar a través de la entrada del monitor serie, almacenando el número al que desea enviar un SMS a, y el mensaje que va a enviar. Debe aceptar una matriz de caracteres como argumento.

int readSerial (resultado char [])
{

Crear una variable para contar a través de los elementos de la memoria intermedia serie, y comenzar un bucle while que se ejecutará continuamente.

int i = 0;
  mientras que (1)
  {

Mientras existe información disponible de serie, leer los datos en una variable llamada inchar.

while (Serial.available ()> 0)
    {
      Char inchar = Serial.read ();

Si el personaje se está leyendo es un salto de línea, terminar la matriz, borrar el búfer de serie y salir de la función.

if (inchar == '\ n')
      {
        Resultados [i] = '\ 0';
        Serial.flush ();
        return 0;
      }

Si el carácter de entrada es un carácter ASCII que no sea un retorno de carro o salto de línea, añadirlo a la matriz y el incremento del índice. Cierre de los ciclos while y la función.

if (inchar! = '\ r')
      {
        resultado [i] = inchar;
        i ++;
      }
    }
  }
}

En bucle, crear una matriz de caracteres llamado remoteNumber para mantener el número al que desea enviar un SMS a. Invocar la función readSerial que acaba de crear, y pasar remoteNumber como argumento. Cuando se ejecuta readSerial, rellenará remoteNumber con el número al que desea enviar el mensaje.

Serial.print ( "Introduzca un número de teléfono celular:");
  Char remoteNumber [20];
  readSerial (remoteNumber);
  Serial.println (remoteNumber);

Crear una nueva matriz de caracteres llamado TxtMsg. Esto mantendrá el contenido de su SMS. Pase al TxtMsg readSerial para rellenar la matriz.

Serial.print ( "Ahora, introduzca el contenido de SMS:");
  Char TxtMsg [200];
  readSerial (TxtMsg);

Llame sms.beginSMS () y pasarlo remoteNumber para iniciar el envío del mensaje, sms.print () para enviar el mensaje, y sms.endSMS () para completar el proceso. Imprimir algo de información de diagnóstico y cerrar el bucle. Su mensaje está en camino!

Serial.println ( "envío");
  Serial.println ();
  Serial.println ( "Mensaje:");
  Serial.println (TxtMsg);

  sms.beginSMS (remoteNumber);
  sms.print (TxtMsg);
  sms.endSMS ();
  Serial.println ( "\ nCOMPLETE \ n");
}

Una vez que se carga el código, abrir el monitor serie. Asegúrese de que el monitor serie está configurado para enviar solamente un carácter de nueva línea de retorno. Cuando se le pida que introduzca el número al que desea llamar, introducir los dígitos y pulse retorno. A continuación, se le pedirá que introduzca su mensaje. Una vez que haya escrito esto, pulsa el retorno de nuevo para enviarlo.

El esquema completo se encuentra por debajo.

/*
 SMS sender

 This sketch, for the Arduino GSM shield,sends an SMS message
 you enter in the serial monitor. Connect your Arduino with the
 GSM shield and SIM card, open the serial monitor, and wait for
 the "READY" message to appear in the monitor. Next, type a
 message to send and press "return". Make sure the serial
 monitor is set to send a newline when you press return.

 Circuit:
 * GSM shield
 * SIM card that can send SMS

 created 25 Feb 2012
 by Tom Igoe

 This example is in the public domain.

 http://www.arduino.cc/en/Tutorial/GSMExamplesSendSMS

 */


// Include the GSM library
#include <GSM.h>

#define PINNUMBER ""

// initialize the library instance
GSM gsmAccess;
GSM_SMS sms;

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("SMS Messages Sender");

  // connection state
  boolean notConnected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("GSM initialized");
}

void loop() {

  Serial.print("Enter a mobile number: ");
  char remoteNum[20];  // telephone number to send sms
  readSerial(remoteNum);
  Serial.println(remoteNum);

  // sms text
  Serial.print("Now, enter SMS content: ");
  char txtMsg[200];
  readSerial(txtMsg);
  Serial.println("SENDING");
  Serial.println();
  Serial.println("Message:");
  Serial.println(txtMsg);

  // send the message
  sms.beginSMS(remoteNum);
  sms.print(txtMsg);
  sms.endSMS();
  Serial.println("\nCOMPLETE!\n");
}

/*
  Read input serial
 */

int readSerial(char result[]) {
  int i = 0;
  while (1) {
    while (Serial.available() > 0) {
      char inChar = Serial.read();
      if (inChar == '\n') {
        result[i] = '\0';
        Serial.flush();
        return 0;
      }
      if (inChar != '\r') {
        result[i] = inChar;
        i++;
      }
    }
  }
}


Receive Voice Call

Este bosquejo recibe una llamada de voz a partir de una placa Arduino o Genuino equipado con un escudo GSM. Una vez que se recibe y se conecta la llamada, se muestra el número que está llamando, y cuelga. Tendrá que conectar un altavoz y un micrófono para escuchar la llamada conectada y transmitir su voz.

hardware necesario

Arduino vs Genuino placa Arduino + Telefónica GSM / GPRS Escudo
Micrófono y altavoz conectado al blindaje GSM
tarjeta SIM


Código



En primer lugar, importar la biblioteca de GSM



# include <GSM.h>


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

#define PinNumber ""

Inicializar instancias de las clases que vas a utilizar. Vas a necesitar tanto el GSM y clase GSMVoiceCall.

gsmAccess GSM;
VCS GSMVoiceCall;

Crear una matriz de caracteres para almacenar el número entrante:

Char numtel [20];

En configuración, abra una conexión en serie al ordenador. Después de abrir la conexión, envía un mensaje que indica el dibujo se ha iniciado.

void setup () {
  Serial.begin (9600);
  Serial.println ( "Recibir Llamada de Voz");

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:

booleano notConnected = true;

Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. Al colocar esto dentro de un bucle while (), se puede comprobar continuamente el estado de la conexión. Cuando el módem hace conectar, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de verdadero o falso. Una vez conectado, el resto de la configuración se ejecutará.

while (notConnected)
  {
    if(gsmAccess.begin (PinNumber) == GSM_READY)
      notConnected = false;
    else
    {
      Serial.println ( "No conectado");
      delay (1000);
    }
  }

Para garantizar que el módem está listo para aceptar llamadas entrantes, utilice el hangCall () Función

vcs.hangCall ();

Finalizar la configuración con un poco de información al monitor serie.

Serial.println ( "GSM inicializado.");
  Serial.println ( "En espera de llamada.");
}

En bucle, utilice una instrucción interruptor para controlar el flujo del programa. getvoiceCallStatus () devolverá su estado cuando se le llama.

void loop ()
{
  interruptor (vcs.getvoiceCallStatus ())
  {

Si getvoiceCallStatus () devuelve IDLE_CALL, no hay nada sucediendo.

case IDLE_CALL :

      break;

Si getvoiceCallStatus () devuelve RECEIVINGCALL, alguien le está llamando. Utilice retrieveCallingNumber () para almacenar el número de entrada a la matriz numtel que ha creado, e imprimirlo en el monitor serie.

Utilice answerCall () para iniciar la conexión de voz con la persona que llama.

case RECEIVINGCALL :

      Serial.println ( "Recibir una llamada");

      vcs.retrieveCallingNumber (numtel, 20);

      Serial.print ( "Número");
      Serial.println (numtel);

      vcs.answerCall ();
      break;

Una vez que haya respondido a la llamada, getvoiceCallStatus () devolverá a hablar. El boceto esperará un carácter de nueva línea para desencadenar hangCall () y terminar la conexión.

Cierre la sentencia switch.

HABLAR caso:

      Serial.println ( "Enter HABLA línea de interrumpir..");
      while (Serial.read ()! = '\ n')
        delay (100);
      vcs.hangCall ();
      Serial.println ( "bloqueo de llamada en espera..");
       break;
  }

Añadir un pequeño retraso antes de continuar con el bucle:

delay (1000);
}

Una vez que se carga el código, abrir el monitor serie. Asegúrese de que el monitor serie está configurado para enviar solamente un carácter de nueva línea de retorno.

El esquema completo se encuentra por debajo.
/*
 Receive Voice Call

 This sketch, for the Arduino GSM shield, receives voice calls,
 displays the calling number, waits a few seconds then hangs up.

 Circuit:
 * GSM shield
 * Voice circuit. Refer to to the GSM shield getting started guide
   at http://www.arduino.cc/en/Guide/ArduinoGSMShield#toc11
 * SIM card that can accept voice calls

 With no voice circuit the call will connect, but will not send or receive sound

 created Mar 2012
 by Javier Zorzano

 This example is in the public domain.

 http://www.arduino.cc/en/Tutorial/GSMExamplesReceiveVoiceCall

 */


// Include the GSM library
#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// initialize the library instance
GSM gsmAccess;
GSMVoiceCall vcs;

// Array to hold the number for the incoming call
char numtel[20];

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("Receive Voice Call");

  // connection state
  boolean notConnected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  // This makes sure the modem correctly reports incoming events
  vcs.hangCall();

  Serial.println("Waiting for a call");
}

void loop() {
  // Check the status of the voice call
  switch (vcs.getvoiceCallStatus()) {
    case IDLE_CALL: // Nothing is happening

      break;

    case RECEIVINGCALL: // Yes! Someone is calling us

      Serial.println("RECEIVING CALL");

      // Retrieve the calling number
      vcs.retrieveCallingNumber(numtel, 20);

      // Print the calling number
      Serial.print("Number:");
      Serial.println(numtel);

      // Answer the call, establish the call
      vcs.answerCall();
      break;

    case TALKING:  // In this case the call would be established

      Serial.println("TALKING. Press enter to hang up.");
      while (Serial.read() != '\n') {
        delay(100);
      }
      vcs.hangCall();
      Serial.println("Hanging up and waiting for the next call.");
      break;
  }
  delay(1000);
}


Receive SMS

Este bosquejo espera un mensaje SMS y lo imprime al monitor de serie. Utiliza la biblioteca de la GSM GSM escudo Arduino y una tarjeta SIM activa. Para hacerlo funcionar, la tarjeta SIM no necesita un plan de datos


Código

En primer lugar, importar la biblioteca de GSM

# include <GSM.h>

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

#define PinNumber ""

Inicializar instancias de las clases que vas a utilizar. Vas a necesitar tanto el GSM y clase GSM_SMS.

gsmAccess GSM;
sms GSM_SMS;

Crear una matriz de caracteres para contener el número que está enviando el mensaje:

Char remoteNumber [20];

En configuración, abra una conexión en serie al ordenador. Después de abrir la conexión, envía un mensaje que indica el dibujo se ha iniciado.

void setup () {
  Serial.begin (9600);
  Serial.println ( "Mensajes SMS del receptor»);

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:

booleano notConnected = true;

Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. Al colocar esto dentro de un bucle while (), se puede comprobar continuamente el estado de la conexión. Cuando el módem hace conectar, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de verdadero o falso. Una vez conectado, el resto de la configuración se ejecutará.

while (notConnected)
  {
    if (gsmAccess.begin (PinNumber) == GSM_READY)
      notConnected = false;
    else
    {
      Serial.println ( "No conectado");
      delay (1000);
    }
  }

Finalizar la configuración con un poco de información al monitor serie.

Serial.println ( "GSM inicializado.");
  Serial.println ( "A la espera de los mensajes");
}

Los mensajes SMS son recibidos por el módem. las tarjetas SIM tienen un cierto espacio de memoria para almacenar los SMS entrantes. El número de SMS de la tarjeta puede almacenar puede ser de tan sólo 10, o tantos como 200, dependiendo de la tarjeta SIM. Usted debe verificar con su proveedor para determinar el número de la tarjeta SIM puede guardar en la memoria.

En loop (), cree una variable de tipo char para retener temporalmente los caracteres de cualquier SMS recibido. Utilice sms.available () para comprobar la presencia de ningún otro mensaje en la tarjeta SIM:

void loop ()
{
  c carbón;
  if (sms.available ())
  
Si un SMS está disponible, recuperar el número del remitente a distancia llamando sms.remoteNumber (remoteNumber, 20). el argumento remoteNumber es la matriz de caracteres que declaró en el principio del boceto, puede ser no más de 20 caracteres. Enviar este número con el monitor serie.

Serial.println ( "Mensaje recibido de:");
    sms.remoteNumber (remoteNumber, 20);
    Serial.println (remoteNumber);

Es posible borrar los mensajes SMS llamando sms.flush (). Usando sms.peek () es posible identificar el número de índice de mensajes, lo que podría ser útil para la eliminación

El código de abajo no se eliminará ninguna de la SIM, pero se puede iterar a través de un bucle, o identificar un número de índice específico para eliminar, en lugar del maniquí utilizado por debajo de #

if (sms.peek () == '#')
    {
      Serial.println ( "SMS desechados");
      sms.flush ();
    }

Para leer un mensaje, utilice sms.read (). Aquí, podrás almacenar cada carácter del mensaje en la variable c e imprimirlo a cabo, ya que se lee.

while (c = sms.read ())
      Serial.print (c);

Indicar el mensaje está completo y retirarlo de la memoria con sms.flush ().

Serial.println ( "\ Nend DE MENSAJE");
    sms.flush ();
    Serial.println ( "Mensaje borrado");
  }

Añadir una breve demora y cerrar el loop.

delay(1000);
}

Una vez que se carga el código, abrir el monitor serie. Con un teléfono u otro servicio habilitado para SMS, enviar un SMS al número de su tarjeta SIM. Debería ver el mensaje de imprimir en la pantalla cuando se recibe.

El esquema completo se encuentra por debajo.

/*
 SMS receiver

 This sketch, for the Arduino GSM shield, waits for a SMS message
 and displays it through the Serial port.

 Circuit:
 * GSM shield attached to and Arduino
 * SIM card that can receive SMS messages

 created 25 Feb 2012
 by Javier Zorzano / TD

 This example is in the public domain.

 http://www.arduino.cc/en/Tutorial/GSMExamplesReceiveSMS

*/


// include the GSM library
#include <GSM.h>

// PIN Number for the SIM
#define PINNUMBER ""

// initialize the library instances
GSM gsmAccess;
GSM_SMS sms;

// Array to hold the number a SMS is retreived from
char senderNumber[20];

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.println("SMS Messages Receiver");

  // connection state
  boolean notConnected = true;

  // Start GSM connection
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("GSM initialized");
  Serial.println("Waiting for messages");
}

void loop() {
  char c;

  // If there are any SMSs available()
  if (sms.available()) {
    Serial.println("Message received from:");

    // Get remote number
    sms.remoteNumber(senderNumber, 20);
    Serial.println(senderNumber);

    // An example of message disposal
    // Any messages starting with # should be discarded
    if (sms.peek() == '#') {
      Serial.println("Discarded SMS");
      sms.flush();
    }

    // Read message bytes and print them
    while (= sms.read()) {
      Serial.print(c);
    }

    Serial.println("\nEND OF MESSAGE");

    // Delete message from modem memory
    sms.flush();
    Serial.println("MESSAGE DELETED");
  }

  delay(1000);

}

HERRAMIENTAS

Band Management

Este ejemplo es parte de las herramientas suministradas para gestionar el escudo GSM y muestra cómo utilizar la Biblioteca GSM para gestionar la banda GSM módem se conecta a.

Compruebe http://www.worldtimezone.com/gsm.html para obtener información general banda GSM. configuraciones regionales típicos son:

Europa, África, Oriente Medio: E-GSM (900) + DCS (1800)
EE.UU., Canadá, América del Sur: GSM (850) + PCS (1900)
México: PCS (1900)
Brasil: GSM (850) + E-GSM (900) + DCS (1800) + PCS (1900)

Code

 This sketch, for the Arduino GSM shield, checks the band  currently configured in the modem and allows you to change 
 it.
/*
 Band Management

 This sketch, for the Arduino GSM shield, checks the band
 currently configured in the modem and allows you to change
 it.

 Please check http://www.worldtimezone.com/gsm.html
 Usual configurations:
 Europe, Africa, Middle East: E-GSM(900)+DCS(1800)
 USA, Canada, South America: GSM(850)+PCS(1900)
 Mexico: PCS(1900)
 Brazil: GSM(850)+E-GSM(900)+DCS(1800)+PCS(1900)


 Circuit:
 * GSM shield

 created 12 June 2012
 by Javier Zorzano, Scott Fitzgerald

 This example is in the public domain.
 */


// libraries
#include <GSM.h>

// initialize the library instance
GSMBand band;

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  // Beginning the band manager restarts the modem
  Serial.println("Restarting modem...");
  band.begin();
  Serial.println("Modem restarted.");

};


void loop() {
  // Get current band
  String bandName = band.getBand(); // Get and print band name
  Serial.print("Current band:");
  Serial.println(bandName);
  Serial.println("Want to change the band you’re on?");
  String newBandName;
  newBandName = askUser();
  // Tell the user what we are about to do…
  Serial.print("\nConfiguring band ");
  Serial.println(newBandName);
  // Change the band
  boolean operationSuccess;
  operationSuccess = band.setBand(newBandName);
  // Tell the user if the operation was OK
  if (operationSuccess) {
    Serial.println("Success");
  } else {
    Serial.println("Error while changing band");
  }

  if (operationSuccess) {
    while (true);
  }
}

// This function offers the user different options
// through the Serial interface
// The user selects one
String askUser() {
  String newBand;
  Serial.println("Select band:");
  // Print the different options
  Serial.println("1 : E-GSM(900)");
  Serial.println("2 : DCS(1800)");
  Serial.println("3 : PCS(1900)");
  Serial.println("4 : E-GSM(900)+DCS(1800) ex: Europe");
  Serial.println("5 : GSM(850)+PCS(1900) Ex: USA, South Am.");
  Serial.println("6 : GSM(850)+E-GSM(900)+DCS(1800)+PCS(1900)");

  // Empty the incoming buffer
  while (Serial.available()) {
    Serial.read();
  }

  // Wait for an answer, just look at the first character
  while (!Serial.available());
  char c = Serial.read();
  if (== '1') {
    newBand = GSM_MODE_EGSM;
  } else if (== '2') {
    newBand = GSM_MODE_DCS;
  } else if (== '3') {
    newBand = GSM_MODE_PCS;
  } else if (== '4') {
    newBand = GSM_MODE_EGSM_DCS;
  } else if (== '5') {
    newBand = GSM_MODE_GSM850_PCS;
  } else if (== '6') {
    newBand = GSM_MODE_GSM850_EGSM_DCS_PCS;
  } else {
    newBand = "GSM_MODE_UNDEFINED";
  }
  return newBand;
}

GSM Scan Networks

En este ejemplo se imprime el número IMEI del módem, a continuación, comprueba si está conectado a un vehículo e imprime su fuerza de la señal. También explora para todas las redes cercanas.

Código

En primer lugar, importar la biblioteca de GSM

# include <GSM.h>

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

#define PinNumber ""

Inicializar instancias de las clases que vas a utilizar. Vas a necesitar las clases GSM, GSMScanner, y GSMModem.

gsmAccess GSM;
scannerNetworks GSMScanner;
GSMModem modemTest;

Crear una variable para contener el número de IMEI, y unos mensajes de estado para enviar al monitor de serie:

Cadena IMEI = "";

TextoError cadena = "error";

En configuración, abra una conexión en serie al ordenador. Después de abrir la conexión, enviar un mensaje al monitor de serie que indica el dibujo se ha iniciado. Call @ scannerNetworks.begin () @@ para restablecer el módem.

void setup () {
  Serial.begin (9600);
  Serial.println ( "redes GSM del escáner");
  scannerNetworks.begin ();

Crear una variable local para realizar un seguimiento del estado de la conexión. Vamos a usar esto para mantener el boceto de arranque hasta que la tarjeta SIM está conectado a la red:

booleano notConnected = true;

Conectarse a la red llamando gsmAccess.begin (). Se necesita PIN de la tarjeta SIM como argumento. Al colocar esto dentro de un bucle while (), se puede comprobar continuamente el estado de la conexión. Cuando el módem hace conectar, gsmAccess () devolverá GSM_READY. Use esto como una bandera para establecer la variable notConnected de verdadero o falso. Una vez conectado, el resto de la configuración se ejecutará.

while (notConnected)
  {
    si (gsmAccess.begin (PinNumber) == GSM_READY)
      notConnected = false;
    más
    {
      Serial.println ( "No conectado");
      retardo (1000);
    }
  }

Obtener el IMEI del módem con modemTest.getIMEI () e imprimirlo al monitor de serie.

Serial.print ( "IMEI del módem:");
  IMEI = modemTest.getIMEI ();
  IMEI.replace ( "\ n", "");
  si (IMEI! = NULL)
    Serial.println (IMEI);

En loop (), escanear e imprimir todas las redes disponibles. Esto puede tomar algo de tiempo

Serial.println ( ". Exploración de redes disponibles puede tardar algunos segundos.");
  Serial.println (scannerNetworks.readNetworks ());

Imprimir el portador conectado actual, y la fuerza de la señal. intensidad de la señal es en una escala de 0-31, donde 0 es el más bajo, y el 31 es el más alto. Cierra el bucle().

Serial.print ( "portador actual:");
  Serial.println (scannerNetworks.getCurrentCarrier ());

  Serial.print ( "Fuerza de la señal:");
  Serial.print (scannerNetworks.getSignalStrength ());
  Serial.println ( "[0-31]");

Una vez que se carga el código, abrir el monitor serie para ver el estado de la conexión.

El esquema completo se encuentra por debajo.

/*

 GSM Scan Networks

 This example prints out the IMEI number of the modem,
 then checks to see if it's connected to a carrier. If so,
 it prints the phone number associated with the card.
 Then it scans for nearby networks and prints out their signal strengths.

 Circuit:
 * GSM shield
 * SIM card

 Created 8 Mar 2012
 by Tom Igoe, implemented by Javier Carazo
 Modified 4 Feb 2013
 by Scott Fitzgerald

 http://www.arduino.cc/en/Tutorial/GSMToolsGsmScanNetworks

 This example code is part of the public domain
 */


// libraries
#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// initialize the library instance
GSM gsmAccess;     // include a 'true' parameter to enable debugging
GSMScanner scannerNetworks;
GSMModem modemTest;

// Save data variables
String IMEI = "";

// serial monitor result messages
String errortext = "ERROR";

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  Serial.println("GSM networks scanner");
  scannerNetworks.begin();

  // connection state
  boolean notConnected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (notConnected) {
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) {
      notConnected = false;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  // get modem parameters
  // IMEI, modem unique identifier
  Serial.print("Modem IMEI: ");
  IMEI = modemTest.getIMEI();
  IMEI.replace("\n", "");
  if (IMEI != NULL) {
    Serial.println(IMEI);
  }
}

void loop() {
  // scan for existing networks, displays a list of networks
  Serial.println("Scanning available networks. May take some seconds.");
  Serial.println(scannerNetworks.readNetworks());

  // currently connected carrier
  Serial.print("Current carrier: ");
  Serial.println(scannerNetworks.getCurrentCarrier());

  // returns strength and ber
  // signal strength in 0-31 scale. 31 means power > 51dBm
  // BER is the Bit Error Rate. 0-7 scale. 99=not detectable
  Serial.print("Signal Strength: ");
  Serial.print(scannerNetworks.getSignalStrength());
  Serial.println(" [0-31]");

}

GSM PIN Management

Este ejemplo es parte de las herramientas suministradas por el GSM escudo Arduino y le ayuda a cambiar o quitar el PIN de una tarjeta SIM.

Código

En primer lugar, importar la biblioteca de GSM

# include <GSM.h>

Inicializar una instancia de la clase GSMPin.

GSMPIN PINManager;

Crear sus variables, a partir de una cadena de celebrar la entrada del monitor serie. También hacer una bandera para el control de la f SIM ha sido autenticado con un PIN válido, y los mensajes para el monitor serie.

User_input cadena = "";

booleano auth = false;

Oktext cadena = "OK";
TextoError cadena = "error";

En configuración, abra una conexión en serie al ordenador. Después de abrir la conexión, enviar un mensaje al monitor de serie que indica el dibujo se ha iniciado. Llame PINManager.begin () para reiniciar el módem.

void setup () {
  Serial.begin (9600);
  Serial.println ( "Cambiar PIN ejemplo \ n");
  PINManager.begin ();

Compruebe si la tarjeta SIM está bloqueada con un PIN

while (auth!) {
    int = pin_query PINManager.isPIN ();
    si (== pin_query 1)
    {

Si está bloqueado, solicite el PIN a través del monitor de serie. Vamos a usar una función personalizada denominada readSerial () para analizar la información.

Serial.print ( "Introducir un código PIN:");
      user_input = readSerial ();

Si el PIN es válido, establecer el indicador de autenticación en true. Enviar un mensaje de estado al monitor de serie que indica el resultado. Si introduce el PIN de forma incorrecta, puede intentarlo de nuevo. Después de 3 intentos fallidos, el PIN se bloqueará, y necesitará el código PUK para desbloquearlo.

if (PINManager.checkPIN (user_input) == 0)
      {
        auth = true;
        PINManager.setPINUsed (true);
        Serial.println (oktext);
      }
      más
      {
        Serial.println ( "PIN incorrecto Recuerde que tiene 3 oportunidades..");
      }
    }

Si la tarjeta SIM está en modo de bloqueo PUK, solicite el código PUK y un nuevo PIN

else if (pin_query == -1)
    {
      Serial.println ( ". PIN bloqueado Introduzca el código PUK:");
      Cadena PUK = readSerial ();
      Serial.print ( "Ahora, introduzca un nuevo código PIN:");
      user_input = readSerial ();
      si (PINManager.checkPUK (PUK, user_input) == 0)
      {
        auth = true;
        PINManager.setPINUsed (true);
        Serial.println (oktext);
      }
      else
      {
        Serial.println ( ". Incorrecta o PUK nuevo PIN no válido Inténtelo de nuevo !.");
      }
    }

Si hay un error, y el número PIN y PUK bloqueado tanto, envía un mensaje de estado correspondiente:

else if (pin_query == -2)
    {
      Serial.println ( "PIN y PUK bloqueado Uso PIN2 / PUK2 en un teléfono móvil..");
      while (true);
    }

Si no hay un número PIN, establecer el indicador de autenticación a la verdadera

else
    {
      // SIM no requiere authetication
      Serial.println ( "No pasador necesario.");
      auth = true;
    }
  }

Compruebe el registro en la red GSM, e indicar si está conectado o no, y si está en itinerancia.

Serial.print ( "Comprobación de registro en la red GSM ...");
  if (PINManager.checkReg () == 0)
    Serial.println (oktext);
  else if (PINManager.checkReg () == 1)
    Serial.println ( "roaming" + oktext);
  else
  {
    Serial.println (textoError);
    while (true);
  }
}

Vas a crear una función personalizada para controlar la entrada en serie del monitor serie. Realiza una función denominada de tipo String.

Cadena readSerial ()
{

Aunque hay información disponible de serie, leerlo en una nueva cadena. Si se encuentra un carácter de nueva línea, volver al programa principal.

texto String = "";
  while (1)
  {
    while (Serial.available ()> 0)
    {
      Char inchar = Serial.read ();
      if (inchar == '\ n')
      {
        Texto del retorno;
      }
      if (inchar! = '\ r')
        texto + = inchar;
    }
  }
}

loop () actúa como una herramienta de gestión de PIN, lo que permite convertir el PIN encendido o apagado, y la cambie.

void loop ()
{

  Serial.println ( "Elija una opción:. \ N 1 - On / Off PIN");
  if(PINManager.getPINUsed ())
    Serial.println ( "2 - Cambiar PIN.");
  Cadena user_op = readSerial ();
  if (user_op == "1")
  {
    Serial.println ( "Introduzca su código PIN:");
    user_input = readSerial ();

    PINManager.switchPIN (user_input);
  }
  else if (user_op == "2" y PINManager.getPINUsed ())
  {
    Serial.println ( "Introduzca su código PIN actual:");
    Cadena oldPIN = readSerial ();
    Serial.println ( "Ahora, introduzca su código PIN nuevo:");
    Cadena NEWPIN = readSerial ();

    PINManager.changePIN (oldPIN, NEWPIN);
  }
  else
  {
    Serial.println ( ". Inténtelo de nuevo la opción incorrecta !.");
  }
  delay (1000);
}

Una vez que se carga el código, abrir el monitor serie para trabajar con el PIN.

El esquema completo se encuentra por debajo.

/*
 Band Management

 This sketch, for the Arduino GSM shield, checks the band
 currently configured in the modem and allows you to change
 it.

 Please check http://www.worldtimezone.com/gsm.html
 Usual configurations:
 Europe, Africa, Middle East: E-GSM(900)+DCS(1800)
 USA, Canada, South America: GSM(850)+PCS(1900)
 Mexico: PCS(1900)
 Brazil: GSM(850)+E-GSM(900)+DCS(1800)+PCS(1900)


 Circuit:
 * GSM shield

 created 12 June 2012
 by Javier Zorzano, Scott Fitzgerald

 This example is in the public domain.
 */


// libraries
#include <GSM.h>

// initialize the library instance
GSMBand band;

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  // Beginning the band manager restarts the modem
  Serial.println("Restarting modem...");
  band.begin();
  Serial.println("Modem restarted.");

};


void loop() {
  // Get current band
  String bandName = band.getBand(); // Get and print band name
  Serial.print("Current band:");
  Serial.println(bandName);
  Serial.println("Want to change the band you’re on?");
  String newBandName;
  newBandName = askUser();
  // Tell the user what we are about to do…
  Serial.print("\nConfiguring band ");
  Serial.println(newBandName);
  // Change the band
  boolean operationSuccess;
  operationSuccess = band.setBand(newBandName);
  // Tell the user if the operation was OK
  if (operationSuccess) {
    Serial.println("Success");
  } else {
    Serial.println("Error while changing band");
  }

  if (operationSuccess) {
    while (true);
  }
}

// This function offers the user different options
// through the Serial interface
// The user selects one
String askUser() {
  String newBand;
  Serial.println("Select band:");
  // Print the different options
  Serial.println("1 : E-GSM(900)");
  Serial.println("2 : DCS(1800)");
  Serial.println("3 : PCS(1900)");
  Serial.println("4 : E-GSM(900)+DCS(1800) ex: Europe");
  Serial.println("5 : GSM(850)+PCS(1900) Ex: USA, South Am.");
  Serial.println("6 : GSM(850)+E-GSM(900)+DCS(1800)+PCS(1900)");

  // Empty the incoming buffer
  while (Serial.available()) {
    Serial.read();
  }

  // Wait for an answer, just look at the first character
  while (!Serial.available());
  char c = Serial.read();
  if (== '1') {
    newBand = GSM_MODE_EGSM;
  } else if (== '2') {
    newBand = GSM_MODE_DCS;
  } else if (== '3') {
    newBand = GSM_MODE_PCS;
  } else if (== '4') {
    newBand = GSM_MODE_EGSM_DCS;
  } else if (== '5') {
    newBand = GSM_MODE_GSM850_PCS;
  } else if (== '6') {
    newBand = GSM_MODE_GSM850_EGSM_DCS_PCS;
  } else {
    newBand = "GSM_MODE_UNDEFINED";
  }
  return newBand;
}


GSM Test GPRS


Este bosquejo prueba la conexión de datos GPRS en el escudo GSM. Se trata de conectarse a arduino.cc.

Para utilizar una conexión de datos con el escudo GSM, tendrá Nombre de punto de acceso de su proveedor (APN), inicio de sesión y contraseña. Para obtener esta información, póngase en contacto con el proveedor de red para la información más actualizada. Esta página no tiene alguna información acerca de los diversos ajustes de operador, pero puede no estar actualizada.

Código

En primer lugar, importar la biblioteca de GSM

# include <GSM.h>

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

#define PinNumber ""

Inicializar instancias de las clases que vas a utilizar. Vas a necesitar las clases GSM, GPRS, y GSMClient.

GSMClient cliente;
gprsAccess GPRS;
gsmAccess GSM;

Crear algunos mensajes de estado para enviar al monitor de serie:

Oktext cadena = "OK";
errortext cadena = "error";

Crear algunas variables para contener el servidor, la ruta y proxy que desea conectarse.

Char url [] = "arduino.cc";
ruta char [] = "/";
charlas urlproxy [] = "http://arduino.cc";

Crear una variable para contener una respuesta desde el servidor, y una bandera para indicar f te duraran a utilizar un proxy o no.

 String response  = "";

USE_PROXY = false;

En configuración, abra una conexión en serie al ordenador.

void setup () {
  Serial.begin (9600);
}

Vas a crear una función personalizada para controlar la entrada en serie del monitor serie. hacer una función llamada que acepta una matriz de caracteres como argumento.

int readSerial (result char [])
{

hacer una variable para actuar como un contador. Aunque hay información disponible de serie, leerlo en la matriz de caracteres. Si se encuentra un carácter de nueva línea, terminar la matriz y volver al programa principal.

int i = 0;
  while(1)
  {
    while (Serial.available ()> 0)
    {
      Char inchar = Serial.read ();
      if (inchar == '\ n')
      {
        Result [i] = '\ 0';
        return 0;
      }
      if(inchar! = '\ r')
      {
        result [i] = inchar;
        i ++;
      }
    }
  }
}

En loop (), establecer el indicador proxy para falsa

void loop ()
{
  USE_PROXY = false;

Iniciar la conexión a la red GSM pasando el número de PIN (si es aplicable) para gsmAccess.begin ().

Serial.print ( "Conexión de red GSM ...");
  if (gsmAccess.begin (PinNumber)! = GSM_READY)
  {
    Serial.println (textoError);
    while (true);
  }
  Serial.println (oktext);

Crear una matriz de caracteres para mantener la APN. Utilice la función readSerial () que ha creado para obtener los bytes del monitor serie

Char APN [50];
  Serial.print ( "Introduzca su APN:");
  readSerial (APN);
  Serial.println (APN);

Crear una matriz de caracteres para celebrar el inicio de sesión de APN. Utilice la función readSerial () que ha creado para obtener los bytes del monitor serie

Char entrada [50];
  Serial.print ( "Ahora, introduzca su entrada:");
  readSerial (login);
  Serial.println (login);

Crear una matriz de caracteres para mantener la contraseña de APN. Utilice la función readSerial () que ha creado para obtener los bytes del monitor serie

Char contraseña [20];
  Serial.print ( "Por último, introduzca su contraseña:");
  readSerial (contraseña);

Conectarse a la red GPRS utilizando gprs.attachGPRS (). Esto requiere el APN, el acceso y la contraseña que acaba de introducir.

Cuando el módem se ha conectado a la red GPRS, gsmAccess () devolverá GSM_READY.

Serial.println ( "Conexión a GPRS con su APN ...");
  (si gprsAccess.attachGPRS (APN, usuario, contraseña)! = GPRS_READY)
  {
    Serial.println (textoError);
  }
  else{

    Serial.println (oktext);

Crear una matriz de caracteres para mantener la información de proxies que pueda necesitar. Utilice la función readSerial () que ha creado para obtener los bytes del monitor serie.

carbón de proxy [100];
    Serial.print ( "Si tu operador utiliza un proxy, entrar en él, si no presione intro:");
    readSerial (apoderado);
    Serial.println (apoderado);

Si se indica un proxy, pregunte por el número de puerto y establecer el indicador proxy para cierto

int pport;
    if (Proxy [0]! = '\ 0') {
      // Leer puerto proxy introducido por el usuario
      Char proxyport [10];
      Serial.print ( "Introduzca el puerto del servidor proxy:");
      readSerial (proxyport);
      // Puerto de proxy elenco introdujo a un entero
      pport = (int) proxyport;
      USE_PROXY = true;
      Serial.println (proxyport);
    }

Crear una variable para indicar si está conectado al servidor o no. Con client.connect (), establecer una conexión con el servidor. Cómo realizar la conexión dependerá de si está utilizando un proxy o no.

Serial.print ( "Conexión y enviar la solicitud GET para arduino.cc ...");
    int res_connect;

    if (USE_PROXY)
      res_connect = client.connect (proxy, pport);
    else
      res_connect = client.connect (url, 80);

si se ha conectado, hacer una solicitud a través de HTTP GET client.print ().

if(res_connect)
    {
      client.print ( "GET");

      if (USE_PROXY)
        client.print (urlproxy);
      else
        client.print (ruta);

      client.println ( "HTTP / 1.0");
      client.println ();
      Serial.println (oktext);
    }

Si se realiza ninguna conexión, imprima un error

else
    {
      // Si no se obtiene una conexión con el servidor
      Serial.println (textoError);
    }

Compruebe si el servidor ha devuelto ningún byte usando client.available (). Si los hay, leerlos en la cadena de respuesta, y luego echarlos en una matriz de caracteres. Compruebe la matriz para la subcadena "200 OK", que indica una respuesta válida desde el arduino.cc.

Serial.print ( "Recepción de la respuesta ...");

     Boolean test = true;
    while (test)
    {
      if (client.available ())
      {
        Char c = client.read ();
        response + = c;

        responsechar char [response.length () + 1];
        response.toCharArray (responsechar, response.length () + 1);

       if(strstr (responsechar, "200 OK")! = NULL) {
          Serial.println (oktext);
          Serial.println ( "ensayo!");
          test = false;
        }
      }

Si el servidor se ha desconectado, detener el cliente y en lazo cerrado ()

if (! client.connected ())
      {
        Serial.println ();
        Serial.println ( "desconectar".);
        client.stop ();
        test = false;
      }
    }
  }
}

Una vez que se carga el código, abrir el monitor serie para ver el estado de la conexión.

El esquema completo se encuentra por debajo.

/*

 This sketch test the GSM shield's ability to connect to a
 GPERS network. It asks for APN information through the
 serial monitor and tries to connect to arduino.cc.

 Circuit:
 * GSM shield attached
 * SIM card with data plan

 Created 18 Jun 2012
 by David del Peral

 This example code is part of the public domain

 http://www.arduino.cc/en/Tutorial/GSMToolsTestGPRS

 */


// libraries
#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// initialize the library instance
GSM gsmAccess;        // GSM access: include a 'true' parameter for debug enabled
GPRS gprsAccess;  // GPRS access
GSMClient client;  // Client service for TCP connection

// messages for serial monitor response
String oktext = "OK";
String errortext = "ERROR";

// URL and path (for example: arduino.cc)
char url[] = "arduino.cc";
char urlproxy[] = "http://www.arduino.cc";
char path[] = "/";

// variable for save response obtained
String response = "";

// use a proxy
boolean use_proxy = false;

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
}

void loop() {
  use_proxy = false;

  // start GSM shield
  // if your SIM has PIN, pass it as a parameter of begin() in quotes
  Serial.print("Connecting GSM network...");
  if (gsmAccess.begin(PINNUMBER) != GSM_READY) {
    Serial.println(errortext);
    while (true);
  }
  Serial.println(oktext);

  // read APN introduced by user
  char apn[50];
  Serial.print("Enter your APN: ");
  readSerial(apn);
  Serial.println(apn);

  // Read APN login introduced by user
  char login[50];
  Serial.print("Now, enter your login: ");
  readSerial(login);
  Serial.println(login);

  // read APN password introduced by user
  char password[20];
  Serial.print("Finally, enter your password: ");
  readSerial(password);

  // attach GPRS
  Serial.println("Attaching to GPRS with your APN...");
  if (gprsAccess.attachGPRS(apn, login, password) != GPRS_READY) {
    Serial.println(errortext);
  } else {

    Serial.println(oktext);

    // read proxy introduced by user
    char proxy[100];
    Serial.print("If your carrier uses a proxy, enter it, if not press enter: ");
    readSerial(proxy);
    Serial.println(proxy);

    // if user introduced a proxy, asks him for proxy port
    int pport;
    if (proxy[0] != '\0') {
      // read proxy port introduced by user
      char proxyport[10];
      Serial.print("Enter the proxy port: ");
      readSerial(proxyport);
      // cast proxy port introduced to integer
      pport = (int) proxyport;
      use_proxy = true;
      Serial.println(proxyport);
    }

    // connection with arduino.cc and realize HTTP request
    Serial.print("Connecting and sending GET request to arduino.cc...");
    int res_connect;

    // if use a proxy, connect with it
    if (use_proxy) {
      res_connect = client.connect(proxy, pport);
    } else {
      res_connect = client.connect(url, 80);
    }

    if (res_connect) {
      // make a HTTP 1.0 GET request (client sends the request)
      client.print("GET ");

      // if use a proxy, the path is arduino.cc URL
      if (use_proxy) {
        client.print(urlproxy);
      } else {
        client.print(path);
      }

      client.println(" HTTP/1.0");
      client.println();
      Serial.println(oktext);
    } else {
      // if you didn't get a connection to the server
      Serial.println(errortext);
    }
    Serial.print("Receiving response...");

    boolean test = true;
    while (test) {
      // if there are incoming bytes available
      // from the server, read and check them
      if (client.available()) {
        char c = client.read();
        response += c;

        // cast response obtained from string to char array
        char responsechar[response.length() + 1];
        response.toCharArray(responsechar, response.length() + 1);

        // if response includes a "200 OK" substring
        if (strstr(responsechar, "200 OK") != NULL) {
          Serial.println(oktext);
          Serial.println("TEST COMPLETE!");
          test = false;
        }
      }

      // if the server's disconnected, stop the client:
      if (!client.connected()) {
        Serial.println();
        Serial.println("disconnecting.");
        client.stop();
        test = false;
      }
    }
  }
}

/*
  Read input serial
 */

int readSerial(char result[]) {
  int i = 0;
  while (1) {
    while (Serial.available() > 0) {
      char inChar = Serial.read();
      if (inChar == '\n') {
        result[i] = '\0';
        return 0;
      }
      if (inChar != '\r') {
        result[i] = inChar;
        i++;
      }
    }
  }
}

GSM Test Modem


Este bosquejo pone a prueba el módem GSM en el escudo para ver si está funcionando correctamente. Usted no necesita una tarjeta SIM para este ejemplo.



Código

En primer lugar, importar la biblioteca de GSM

# include <GSM.h>

Crear una instancia de la clase GSMModem:

GSMModem módem;

Crear una variable para contener el número IMEI del módem

String IMEI = "";

En configuración, abra una conexión en serie al ordenador. Después de abrir la conexión, envía un mensaje que indica el dibujo se ha iniciado.

void setup () {
  Serial.begin (9600);
  Serial.print ( "prueba de módem partir ...");

Llame modem.begin () para iniciar el módem. Enviar un mensaje de estado en función del resultado, y la configuración final ().

if (modem.begin ())
    Serial.println ( "modem.begin () logrado");
 else
    Serial.println ( "ERROR, no hay respuesta del módem.");
}

Dentro del bucle, utilice modem.getIMEI () para devolver el número IMEI del módem. Este número es único para su escudo GSM.

void loop ()
{
  // Obtener el IMEI del módem
  Serial.print ( "Comprobación de IMEI ...");
  IMEI = modem.getIMEI ();

Si hay una respuesta válida del getIMEI (), imprimirlo en el monitor de serie y restablecer el módem con modem.begin ().

if(IMEI! = NULL)
  {
    // Espectáculo IMEI en monitor serie
    Serial.println ( "IMEI del módem:" + IMEI);
    // Restablecer el módem para comprobar el arranque:
    Serial.print ( "Reseting módem ...");
    modem.begin ();

Una vez que restablecer, comprobar el IMEI de nuevo. Si se trata de una declaración válida de nuevo, el módem está funcionando como se esperaba.

if (modem.getIMEI ()! = NULL)
    {
      Serial.println ( "módem está correctamente functoning");
    }

Si, después de restablecer el módem, no hay una declaración válida de getIMEI (), informar de un error

else
    {
      Serial.println ( "Error: getIMEI () falló después modem.begin ()");
    }

Si nunca ha recibido un número IMEI después de comenzar el boceto, informarlo, y finalizar el programa.

}
  else
  {
    Serial.println ( "Error: No se pudo obtener el IMEI");
  }
  // hacer nada:
  while (true);
}

Una vez que se carga el código, abrir el monitor serie. Debería ver el código HTML de http://arduino.cc imprimir en pantalla cuando se recibe.

El esquema completo se encuentra por debajo.

/*

 This example tests to see if the modem of the
 GSM shield is working correctly. You do not need
 a SIM card for this example.

 Circuit:
 * GSM shield attached

 Created 12 Jun 2012
 by David del Peral
 modified 21 Nov 2012
 by Tom Igoe

 http://www.arduino.cc/en/Tutorial/GSMToolsTestModem

 This sample code is part of the public domain

 */


// libraries
#include <GSM.h>

// modem verification object
GSMModem modem;

// IMEI variable
String IMEI = "";

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  // start modem test (reset and check response)
  Serial.print("Starting modem test...");
  if (modem.begin()) {
    Serial.println("modem.begin() succeeded");
  } else {
    Serial.println("ERROR, no modem answer.");
  }
}

void loop() {
  // get modem IMEI
  Serial.print("Checking IMEI...");
  IMEI = modem.getIMEI();

  // check IMEI response
  if (IMEI != NULL) {
    // show IMEI in serial monitor
    Serial.println("Modem's IMEI: " + IMEI);
    // reset modem to check booting:
    Serial.print("Resetting modem...");
    modem.begin();
    // get and check IMEI one more time
    if (modem.getIMEI() != NULL) {
      Serial.println("Modem is functoning properly");
    } else {
      Serial.println("Error: getIMEI() failed after modem.begin()");
    }
  } else {
    Serial.println("Error: Could not get IMEI");
  }
  // do nothing:
  while (true);
}


GSM Test Web Server


Este bosquejo crea un servidor web para aceptar conexiones entrantes en el escudo GSM. Algunos proveedores de la red sólo permiten peticiones desde dentro de su propia red. Usted tendrá que consultar con su proveedor de red para asegurarse de que su tarjeta SIM aceptará peticiones HTTP entrantes.

Code

The complete sketch is below.
/*
  Basic Web Server

 A simple web server that replies with nothing, but prints the client's request
 and the server IP address.

 Circuit:
 * GSM shield attached

 created
 by David Cuartielles
 modified 21 Nov 2012
 by Tom Igoe

 http://www.arduino.cc/en/Tutorial/GSMToolsTestWebServer

 This example code is part of the public domain
 */

#include <GSM.h>

// PIN Number
#define PINNUMBER ""

// APN data
#define GPRS_APN       "GPRS_APN" // replace your GPRS APN
#define GPRS_LOGIN     "login"    // replace with your GPRS login
#define GPRS_PASSWORD  "password" // replace with your GPRS password


// initialize the library instance
GPRS gprs;
GSM gsmAccess;     // include a 'true' parameter for debug enabled
GSMServer server(80); // port 80 (http default)

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

void setup() {
  // initialize serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  Serial.println("starting,..");
  // connection state
  boolean connected = true;

  // Start GSM shield
  // If your SIM has PIN, pass it as a parameter of begin() in quotes
  while (!connected) {
    if ((gsmAccess.begin(PINNUMBER) == GSM_READY) &
        (gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD) == GPRS_READY)) {
      connected = true;
    } else {
      Serial.println("Not connected");
      delay(1000);
    }
  }

  Serial.println("Connected to GPRS network");

  // start server
  server.begin();

  //Get IP.
  IPAddress LocalIP = gprs.getIPAddress();
  Serial.println("Server IP address=");
  Serial.println(LocalIP);
}

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

  if (client) {
    if (client.available()) {
      Serial.write(client.read());
    }
  }

}

DESCARGA ¡¡ GRATIS !! —–> LIBROS DE
ELECTRONICA
 –>ENTRA AQUI PARA VER


DESCARGA SOFTWARE PARA SIMULAR CIRCUITOS ELECTRONICOS HACIENDO CLICK AQUI.




0 comentarios:

Publicar un comentario