http://www.cooking-hacks.com/media/cooking/images/documentation/tutorial_kit_4g/arduPi_api_4G_v1_3.zip && unzip -u arduPi_api_4G_v1_3.zip && cd cooking/examples/4G && chmod +x cook.sh && cd ../../..  
		

/*
 *  4G module
 *
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Yuri Carmona & Ruben Martin
 */ 


/*********************************************************
 *  IF YOUR ARDUINO CODE HAS OTHER FUNCTIONS APART FROM  *
 *  setup() AND loop() YOU MUST DECLARE THEM HERE        *
 * *******************************************************/

/**************************
 * YOUR ARDUINO CODE HERE *
 * ************************/

void setup()
{
}

void loop(void)
{    
}

int main (){
	setup();
	while(1){
		loop();
	}
	return (0);
}                 

//////////////////////////////////////////////
                

{
	_4G.ON();
}
            

{
   _4G.OFF();
}
            

{
   _4G.enterPIN(“1234”);
}
            

{
   _4G.enterPIN(“1234”,”1111”);
}
            

{
   char* imei[21];
   _4G.getInfo(4,imei); //get IMEI number
   char* imsi[21];
   _4G.getInfo(5,imsi); //get IMSI number
   char* iccid[21];
   _4G.getInfo(6,iccid); //get ICCID number
}
            

{
   _4G.checkConnection(60);
}
            

{
   _4G.checkDataConnection(60);
}
            

{
   _4G.set_APN(“apn”,”apn_login”,”apn_password”);
}
            

{
   _4G.show_APN();
}
            

{
   _4G.configureSMS();
}
            

{
	   char  phone_number[] = “*********”;
	   char  text_message[] = “This_is_a_text_message”;
	   _4G.sendSMS(phone_number, text_message);
}
            

{
	   uint8_t  index = 5;
	   _4G.readSMS(index);
}
            

{
	   _4G.readNewSMS(30000);
}
            

{
	   uint8_t  index = 2;
	   _4G.deleteSMS(index);
}
            

{
	   char  host[] = "test.libelium.com";
	   uint16_t  port = 80;
	   char  resource[] = "/test-get-post.php?varA=1&varB=2&varC=3&varD=4";
	   
	   _4G.http(Wasp4G::HTTP_GET, host, port, resource);
}
            

{
	   char  host[] = "test.libelium.com";
	   uint16_t  port = 80;
	   char  resource[] = "/test-get-post.php";
	   char  data[] = "varA=1&varB=2&varC=3&varD=4&varE=5";
	  
	   _4G.http(Wasp4G::HTTP_POST, host, port, resource, data);
}
            

{
	   char ftp_server[] = "pruebas.libelium.com";
	   uint16_t ftp_port = 21;
	   char ftp_user[]   = "t3g@libelium.com";
	   char ftp_pass[]   = "ftp1234";

	   _4G.ftpOpenSession(ftp_server, ftp_port, ftp_user, ftp_pass);
}
            

{
	   char sd_file[]     = "FILE1.TXT";
	   char server_file[] = "FILE2.TXT";

	   _4G.ftpUpload(server_file, sd_file);
}
            

{
	   char sd_file[]     = "/FOLDER1/FILE1.TXT";
	   char server_file[] = "/FOLDER2/FILE2.TXT";

	   _4G.ftpUpload(server_file, sd_file);
}
            

{
	   char sd_file[]     = "FILE1.TXT";
	   char server_file[] = "FILE2.TXT";

	   _4G.ftpDownload(server_file, sd_file);
}
            

{
	   char sd_file[]     = "/FOLDER1/FILE1.TXT";
	   char server_file[] = "/FOLDER2/FILE2.TXT";

	   _4G.ftpDownload(server_file, sd_file);
}
            

{
	   _4G.ftpDelete(“FILE_FTP.TXT”);
}
            

{
	   _4G.ftpGetWorkingDirectory();
}
            

{
	   _4G.ftpChangeWorkingDirectory(“NEWDIR”);
}
            

{
   _4G.ftpCloseSession();
}
            

	struct SocketInfo_t
	{
	   uint8_t  	id;
	   uint16_t 	sent;
	   uint16_t 	received;
	   uint16_t 	size;
	   uint16_t 	ack;
	};
            

{
	   uint8_t socketId = Wasp4G::SOCKET_1;

	   _4G.getSocketInfo(socketId);
}
            

	struct SocketStatus_t
	{
	   uint8_t 	id;
	   uint8_t 	state;
	   char 	localIp[16];
	   uint16_t 	localPort;
	   char 	remoteIp[16];
	   uint16_t 	remotePort;
	};
            

	{
	   uint8_t socketId = Wasp4G::SOCKET_1;

	   _4G.getSocketStatus(socketId);
	}
            

	{
	   uint8_t socketId = Wasp4G::SOCKET_1;
	   char host[] = "xxx.xxx.xxx.xxx";
	   uint16_t remote_port = 15010;

	   _4G.openSocketClient(socketId, Wasp4G::TCP, host, remote_port);
	}
            

	{
	   uint8_t socketId = Wasp4G::SOCKET_2;
	   char host[] = "xxx.xxx.xxx.xxx";
	   uint16_t remote_port = 15010;
	   uint16_t local_port  = 4000;

	   _4G.openSocketClient(socketId, Wasp4G::UDP, host, remote_port, local_port);
	}
            

	{
	   uint8_t  socketId   = Wasp4G::SOCKET_1;
	   uint16_t local_port = 5000;
	   uint8_t  keep_alive = 240;

	   _4G.openSocketServer(socketId, Wasp4G::TCP, local_port, keep_alive);
	}
            

	{
	   uint8_t  socketId   = Wasp4G::SOCKET_2;
	   uint16_t local_port = 5000;

	   _4G.openSocketServer(socketId, Wasp4G::UDP, local_port);
	}
            

{
	   _4G.send(Wasp4G::SOCKET_1, “This_is_the_data_payload”);
}
            

{
	   uint8_t  data[] = {0x31, 0x32, 0x33, 0x34, 0x35}
	   _4G.send(Wasp4G::SOCKET_1, data, 6);
}
            

{
	   _4G.receive(Wasp4G::SOCKET_1);
}
            

{
	   _4G.receive(Wasp4G::SOCKET_1, 30000);
}
            

{
	   _4G.emailReset();
}
            

{
	   _4G.emailSetServerSMTP("smtp.mydomain.com");
}
            

{
	   _4G.emailConfigureSMTP(Wasp4G::EMAIL_NONSSL, 25);
}
            

{
	   char address[]  = “me@email.box.com”;
	   char user[]     = “me@email.box.com”;
	   char password[] = “myPassword”;

	   _4G.emailSetSender(address, user, password);
}
            

{
	   _4G.emailSave();
}
            

{
	   char address[] = "receiver@email.box.com";
	   char subject[] = "Subject of email";
	   char message[] = "This is an e-mail message from Waspmote";

	   _4G.emailSend(address, subject, message);
}
            

/*
    --------------- 4G_14 - GPS Autonomous mode  ---------------

    Explanation: This example shows how to use de GPS in autonomous mode
    Notes: 
     - To work poperly, GPS module needs a 2A(at least) power supply.
     - GPS antennae needs direct skyview to fix satellites; work outdoor.

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
*/

#include "arduino4G.h"

// define variables
uint8_t error;
uint8_t gps_status;
bool gps_fix;

float latitude;
float longitude;

void setup()
{
  Serial.println("Start program");

  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  // check answer
  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2. Start GPS feature
    ////////////////////////////////////////////////

    gps_status = _4G.startGPS();

    // check answer
    if (gps_status == 0)
    {
      Serial.println(F("2. Starting GPS in autonomous mode... done!"));
    }
    else
    {
      Serial.print(F("2. Error calling the 'startGPS' function. Code: "));
      Serial.println(gps_status, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("1. 4G module not started"));
    Serial.print(F("Error code: "));
    Serial.println(error, DEC);
    Serial.println(F("The code stops here."));
    while (1);
  }
}


void loop()
{
  ////////////////////////////////////////////////
  // 3. Wait for satellite signals and get values
  ////////////////////////////////////////////////
  if (gps_status == 0)
  {
    error = _4G.waitForSignal(20000);
    if (error == 0)
    {
      Serial.println(F("----------------------------"));
      Serial.print(F("Ltitude: "));
      Serial.print(_4G._latitude);
      Serial.print(F(","));
      Serial.println(_4G._latitudeNS);
      Serial.print(F("Longitude: "));
      Serial.print(_4G._longitude);
      Serial.print(F(","));
      Serial.println(_4G._longitudeEW);
      Serial.print(F("UTC_time: "));
      Serial.println(_4G._time);
      Serial.print(F("day: "));
      Serial.println(_4G._date);
      Serial.print(F("Number of stellites: "));
      Serial.println(_4G._numSatellites, DEC);
      Serial.print(F("HDOP: "));
      Serial.println(_4G._hdop);
      Serial.println(F("----------------------------"));

      // get degrees
      latitude  = _4G.convert2Degrees(_4G._latitude, _4G._latitudeNS);
      longitude = _4G.convert2Degrees(_4G._longitude, _4G._longitudeEW);
      
      Serial.println("Conversion to degrees:");
      Serial.print(F("Ltitude: "));
      Serial.println(latitude);
      Serial.print(F("Longitude: "));
      Serial.println(longitude);  
      Serial.println();
      delay(10000);
    }
    else
    {
      Serial.println("no stellites fixed");
    }
  }
  else
  {
    Serial.println(F("Restarting the GPS engine"));
    _4G.stopGPS();
    delay(1000);

    gps_status = _4G.startGPS();
  }
}
        

/*  
 *  --------------- 4G_14 - GPS Autonomous mode  ---------------
 *
 *  Explanation: This example shows how to use de GPS in autonomous mode
 *
 *  Notes: 
 *   - To work poperly, GPS module needs a 2A(at least) power supply.
 *   - GPS antennae needs direct skyview to fix satellites; work outdoor.
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

// define variables
uint8_t error;
uint8_t gps_status;
bool gps_fix;

float latitude;
float longitude;


void setup()
{
  printf("Start program\n");


  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  // check answer
  if (error == 0)
  {
    printf("1. 4G module ready...\n");


    ////////////////////////////////////////////////
    // 2. Start GPS feature
    ////////////////////////////////////////////////

    gps_status = _4G.startGPS();

    // check answer
    if (gps_status == 0)
    {
      printf("2. Starting GPS in autonomous mode... done!\n");
    }
    else
    {
      printf("2. Error calling the 'startGPS' function. Code: %d\n", gps_status);
    }

  }
  else
  {
    // Problem with the communication with the 4G module
    printf("1. 4G module not started\n");
    printf("Error code: %d\n", error);
    printf("The code stops here.\n");
    while (1);
  }
}



void loop()
{
  ////////////////////////////////////////////////
  // 3. Wait for satellite signals and get values
  ////////////////////////////////////////////////
  if (gps_status == 0)
  {
    error = _4G.waitForSignal(20000);
    if (error == 0)
    {
      printf("----------------------------\n");
      printf("Latitude: %s, LatitudeNS: %c, Longitude: %s, LongitudeEW: %c, "\
             "UTC_time:%s, date:%s, Number of satellites: %u, HDOP: %f\n",
              _4G._latitude, 
              _4G._latitudeNS, 
              _4G._longitude, 
              _4G._longitudeEW, 
              _4G._time, 
              _4G._date, 
              _4G._numSatellites, 
              _4G._hdop);
      printf("----------------------------\n");

      // get degrees
      latitude  = _4G.convert2Degrees(_4G._latitude, _4G._latitudeNS);
      longitude = _4G.convert2Degrees(_4G._longitude, _4G._longitudeEW);
      
      printf("Conversion to degrees:\n");
      printf("Latitude: %f\n", latitude);
      printf("Longitude: %f\n\n", longitude);
      delay(10000);
    }
    else
    {
      printf("no satellites fixed\n");
    }
  }
  else
  {
    printf("Restarting the GPS engine\n");
    _4G.stopGPS();

    delay(1000);

    gps_status = _4G.startGPS();
  }

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*
    --------------- 4G_18 - A-GPS (MS-Based GPS)  ---------------

    Explanation: This example shows how to use de A-GPS in MS-Based mode

    Note 1: in Arduino UNO the same UART is used for user debug interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Note 2: to run this example properly you must increase the reception 
    serial buffer to 128 bytes. 
    -> go to: <arduino_dir>/hardware/arduino/avr/cores/arduino
    -> edit:  HardwareSerial.h 

     If you are using Arduino Uno:
    -> merge: #define SERIAL_RX_BUFFER_SIZE 128

     If you are using Arduino Mega:
    -> merge: #define SERIAL_TX_BUFFER_SIZE 128
    -> merge: #define SERIAL_RX_BUFFER_SIZE 128

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.1
    Design:            David Gascon
    Implementation:    Alejandro Gallego, Yuri Carmona, Luis Miguel Marti
    Port to Arduino:   Ruben Martin
*/

#include "arduino4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// define variables
uint8_t error;
uint8_t gps_status;
float gps_latitude;
float gps_longitude;
uint32_t previous;
bool gps_autonomous_needed = true;


void setup()
{
  //////////////////////////////////////////////////
  // Set operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);

  //////////////////////////////////////////////////
  // Show APN settings via Serial port
  //////////////////////////////////////////////////
  _4G.show_APN();

  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  // check answer
  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2. Start GPS feature
    ////////////////////////////////////////////////

    // get current time
    previous = millis();

    gps_status = _4G.gpsStart(arduino4G::GPS_MS_BASED);

    // check answer
    if (gps_status == 0)
    {
      Serial.print(F("2. GPS started in MS-BASED. Time(secs) = "));
      Serial.println((millis()-previous)/1000);
    }
    else
    {
      Serial.print(F("2. Error calling the 'gpsStart' function. Code: "));
      Serial.println(gps_status, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("1. 4G module not started"));
    Serial.print(F("Error code: "));
    Serial.println(error, DEC);
    Serial.println(F("The code stops here."));
    while (1);
  }
}


void loop()
{
  ////////////////////////////////////////////////
  // Wait for satellite signals and get values
  ////////////////////////////////////////////////
  if (gps_status == 0)
  {
    error = _4G.waitForSignal(20000);

    if (error == 0)
    {
      Serial.print(F("3. GPS signal received. Time(secs) = "));
      Serial.println((millis()-previous)/1000);

      Serial.println(F("Acquired position:"));
      Serial.println(F("----------------------------"));
      Serial.print(F("Ltitude: "));
      Serial.print(_4G._latitude);
      Serial.print(F(","));
      Serial.println(_4G._latitudeNS);
      Serial.print(F("Longitude: "));
      Serial.print(_4G._longitude);
      Serial.print(F(","));
      Serial.println(_4G._longitudeEW);
      Serial.print(F("UTC_time: "));
      Serial.println(_4G._time);
      Serial.print(F("UTC_dte: "));
      Serial.println(_4G._date);
      Serial.print(F("Number of stellites: "));
      Serial.println(_4G._numSatellites, DEC);
      Serial.print(F("HDOP: "));
      Serial.println(_4G._hdop);
      Serial.println(F("----------------------------"));

      // get degrees
      gps_latitude  = _4G.convert2Degrees(_4G._latitude, _4G._latitudeNS);
      gps_longitude = _4G.convert2Degrees(_4G._longitude, _4G._longitudeEW);

      Serial.println("Conversion to degrees:");
      Serial.print(F("Ltitude: "));
      Serial.println(gps_latitude, 6);
      Serial.print(F("Longitude: "));
      Serial.println(gps_longitude, 6);
      Serial.println();


      ////////////////////////////////////////////////
      // Change to AUTONOMOUS mode if needed
      ////////////////////////////////////////////////

      if (gps_autonomous_needed == true)
      {
        _4G.gpsStop();

        gps_status = _4G.gpsStart(arduino4G::GPS_AUTONOMOUS);

        // check answer
        if (gps_status == 0)
        {
          Serial.println(F("GPS started in AUTONOMOUS mode"));

          // update variable
          gps_autonomous_needed = false;
        }
        else
        {
          Serial.print(F("Error calling the 'gpsStart' function. Code: "));
          Serial.println(gps_status, DEC);
        }
      }
      delay(10000);
    }
    else
    {
      Serial.print("no stellites fixed. Error: ");
      Serial.println(error, DEC);
    }
  }
  else
  {
    ////////////////////////////////////////////////
    // Restart GPS feature
    ////////////////////////////////////////////////

    Serial.println(F("Restarting the GPS engine"));

    // stop GPS
    _4G.gpsStop();
    delay(1000);

    // start GPS
    gps_status = _4G.gpsStart(arduino4G::GPS_MS_BASED);

    // check answer
    if (gps_status == 0)
    {
      Serial.print(F("GPS started in MS-BASED. Time(ms) = "));
      Serial.println(millis() - previous);
    }
    else
    {
      Serial.print(F("Error calling the 'gpsStart' function. Code: "));
      Serial.println(gps_status, DEC);
    }
  }
}
        

/*
 *  --------------- 4G_18 - A-GPS (MS-Based GPS)  ---------------
 *
 *  Explanation: This example shows how to use de A-GPS in MS-Based mode
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:           1.1
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *  Port to Raspberry: Ruben Martin
 */

#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "m2m.tele2.com";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// define variables
uint8_t error;
uint8_t gps_status;
float gps_latitude;
float gps_longitude;
uint32_t previous;
bool gps_autonomous_needed = true;


void setup()
{
  printf("Start program\n");

  //////////////////////////////////////////////////
  // Set operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);

  //////////////////////////////////////////////////
  // Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();

  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  // check answer
  if (error == 0)
  {
    printf("1. 4G module ready...\n");

    ////////////////////////////////////////////////
    // 2. Start GPS feature
    ////////////////////////////////////////////////

    // get current time
    previous = millis();

    gps_status = _4G.gpsStart(arduPi4G::GPS_MS_BASED);

    // check answer
    if (gps_status == 0)
    {
      printf("2. GPS started in MS-BASED. Time(secs) = %d\n", (millis()-previous)/1000);
    }
    else
    {
      printf("2. Error calling the 'gpsStart' function. Code: %d\n", gps_status);
    }
  }
  else
  {

    // Problem with the communication with the 4G module
    printf("1. 4G module not started\n");
    printf("Error code: %d\n", error);
    printf("The code stops here.\n");
    while (1);
  }
}


void loop()
{

  ////////////////////////////////////////////////
  // Wait for satellite signals and get values
  ////////////////////////////////////////////////
  if (gps_status == 0)
  {
    error = _4G.waitForSignal(20000);

    if (error == 0)
    {
      printf("3. GPS signal received. Time(secs) = %d\n", (millis()-previous)/1000);

      printf("Acquired position:\n");
      printf("----------------------------\n");
      printf("Latitude: %s, LatitudeNS: %c, Longitude: %s, LongitudeEW: %c, "\
             "UTC_time:%s, date:%s, Number of satellites: %u, HDOP: %f\n",
              _4G._latitude, 
              _4G._latitudeNS, 
              _4G._longitude, 
              _4G._longitudeEW, 
              _4G._time, 
              _4G._date, 
              _4G._numSatellites, 
              _4G._hdop);
      printf("----------------------------\n");

      // get degrees
      gps_latitude  = _4G.convert2Degrees(_4G._latitude, _4G._latitudeNS);
      gps_longitude = _4G.convert2Degrees(_4G._longitude, _4G._longitudeEW);
      
      printf("Conversion to degrees:\n");
      printf("Latitude: %f\n", gps_latitude);
      printf("Longitude: %f\n\n", gps_longitude);

      ////////////////////////////////////////////////
      // Change to AUTONOMOUS mode if needed
      ////////////////////////////////////////////////
      if (gps_autonomous_needed == true)
      {
        _4G.gpsStop();

        gps_status = _4G.gpsStart(arduPi4G::GPS_AUTONOMOUS);

        // check answer
        if (gps_status == 0)
        {
          printf("GPS started in AUTONOMOUS mode\n");

          // update variable
          gps_autonomous_needed = false;
        }
        else
        {
          printf("Error calling the 'gpsStart' function. Code: %d\n", gps_status);
        }
      }

      delay(10000);
    }
    else
    {
      printf("no satellites fixed. Error: %d\n", error);
    }
  }
  else
  {
    ////////////////////////////////////////////////
    // Restart GPS feature
    ////////////////////////////////////////////////
    printf("Restarting the GPS engine\n");

    // stop GPS
    _4G.gpsStop();
    delay(1000);

    // start GPS
    gps_status = _4G.gpsStart(arduPi4G::GPS_MS_BASED);

    // check answer
    if (gps_status == 0)
    {
      printf("GPS started in MS-BASED. Time(ms) = %d\n", millis() - previous);
    }
    else
    {
      printf("Error calling the 'gpsStart' function. Code: %d\n", gps_status);
    }
  }
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*  
 *  --------------- 4G_04 - Sending SMS   --------------- 
 *  
 *  Explanation: This example shows how to set up the module to use
 *  SMS and send text messages
 *  
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L. 
 *  http://www.libelium.com 
 *  
 *  This program is free software: you can redistribute it and/or modify 
 *  it under the terms of the GNU General Public License as published by 
 *  the Free Software Foundation, either version 3 of the License, or 
 *  (at your option) any later version. 
 *  
 *  This program is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 *  GNU General Public License for more details. 
 *  
 *  You should have received a copy of the GNU General Public License 
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>. 
 *  
 *  Version:           1.0
 *  Design:            David Gascón 
 *  Implementation:    Alejandro Gállego & Rubén Martín
 */
/*  
    ---------------------- 4G_04 - Sending SMS ---------------------- 
   
    Explanation: This example shows how to set up the module to use
    SMS and send text messages

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>. 

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
 */

#include "arduino4G.h"

//////////////////////////////////////////////////
char phone_number[] = "+34666777888";
char sms_body[] = "Hello from CookingHacks!!!";
//////////////////////////////////////////////////

uint8_t error;
uint8_t counter;

void setup()
{
}

void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2. Waiting for Connection
    ////////////////////////////////////////////////

    // Waiting for network registration
    counter = 7;
    error = _4G.checkConnection(60);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.checkConnection(60);
        counter--;      
    }

    if (error == 0)
    {
      Serial.println(F("2.1. Connected to network"));
    }
    else
    {
      Serial.print(F("2.1. Error connecting to network. Code: "));
      Serial.println(error, DEC);
    } 

    ////////////////////////////////////////////////
    // 3. Configure SMS options
    ////////////////////////////////////////////////
    error = _4G.configureSMS();

    if (error == 0)
    {
      Serial.println(F("3.1. 4G module configured to use SMS"));		
    }
    else
    {
      Serial.print(F("3.1. Error calling 'configureSMS' function. Code: "));
      Serial.println(error, DEC);
    } 


    ////////////////////////////////////////////////
    // 4. Send SMS
    ////////////////////////////////////////////////
    Serial.println(F("4.2. Sending SMS..."));
    error = _4G.sendSMS( phone_number, sms_body);

    if (error == 0)
    {
      Serial.println(F(" done"));	
    }
    else
    {
      Serial.print(F("error. Code: "));
      Serial.println(error, DEC);
    }    
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.print(F("1. 4G module not started. Error code: "));
    Serial.println(error, DEC);
  }


  ////////////////////////////////////////////////
  // 5. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("5. Switch OFF 4G module"));
  _4G.OFF();


  ////////////////////////////////////////////////
  // 6. Sleep
  ////////////////////////////////////////////////
  delay(60000);
}
        

/*  
 *  --------------- 4G_04 - Sending SMS   --------------- 
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

//////////////////////////////////////////////////
char phone_number[] = ""; //example.- "+34666555444"
char sms_body[] = "Hello from CookingHacks!!!";
//////////////////////////////////////////////////

uint8_t error;
uint8_t counter;

void setup()
{
}


void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");

    ////////////////////////////////////////////////
    // 2. Waiting for Connection
    ////////////////////////////////////////////////

    // Waiting for network registration
    counter = 3;
    error = _4G.checkConnection(60);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.checkConnection(60);
        counter--;      
    }

    if (error == 0)
    {
        printf("2.1. Connected to network\n");
    }
    else
    {
        printf("2.1. Error connecting to network. Code: %d\n",error);
    } 

    ////////////////////////////////////////////////
    // 2. Configure SMS options
    ////////////////////////////////////////////////
    error = _4G.configureSMS();

    if (error == 0)
    {
      printf("2.1. 4G module configured to use SMS\n");		
    }
    else
    {
      printf("2.1. Error calling 'configureSMS' function. Code: %d\n", error);
    } 


    ////////////////////////////////////////////////
    // 3. Send SMS
    ////////////////////////////////////////////////
    printf("2.2. Sending SMS...\n");
    error = _4G.sendSMS( phone_number, sms_body);

    if (error == 0)
    {
      printf("done\n");	
    }
    else
    {
      printf("error. Code: %d\n", error);
    }    
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("1. 4G module not started. Error code: %d\n", error);
  }


  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("3. Switch OFF 4G module\n");
  _4G.OFF();


  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("4. Enter deep sleep...\n");

  delay(10000);
  
  printf("5. Wake up!!\n\n");

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////


        

/*  
    ----------------------- 4G_03 - Receiving SMS  -------------------- 
    
    Explanation: This example shows how to set up the module to use
    SMS and receive text messages

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
 */

#include "arduino4G.h"


// define variables
uint8_t error;
char sms_received[50];


void setup()
{    
  
  Serial.println(F("Start program"));
  
  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));


    ////////////////////////////////////////////////
    // 2. Set PIN code
    ////////////////////////////////////////////////  
    error = _4G.enterPIN("");

    if (error == 1) 
    {
      Serial.println(F("2. PIN code accepted"));
    }
    else
    {
      Serial.println(F("2. PIN code incorrect"));
    }


    ////////////////////////////////////////////////
    // 2.2. Configure SMS options
    ////////////////////////////////////////////////
    error = _4G.configureSMS();

    if (error == 0)
    {
      Serial.println(F("3. 4G module configured to use SMS"));
    }
    else
    {
      Serial.print(F("3. Error calling 'configureSMS' function. Code: "));
      Serial.println(error, DEC);
    } 


    ////////////////////////////////////////////////
    // 2.3. Configure SMS options
    ////////////////////////////////////////////////
    error = _4G.checkConnection(60);

    if (error == 0)
    {
      Serial.println(F("4. Module connected to network"));   		
    }
    else
    {
      Serial.print(F("4. Module not connected. Connection:"));
      Serial.println(error, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("4G module not started"));
    Serial.print(F("Error code: "));
    Serial.println(error, DEC);
    Serial.println(F("The code stops here."));
    while(1);
  }
  
  Serial.println();
  Serial.println();

}

void loop()
{
  ////////////////////////////////////////////////
  // Check connection to network
  ////////////////////////////////////////////////
  error = _4G.checkConnection(60);

  if (error == 0)
  {
    Serial.println(F("Wait for incoming SMS..."));

    //////////////////////////////////////////////
    // Manage incoming data
    //////////////////////////////////////////////
    error = _4G.manageIncomingData(60000);

    if ((error == 0) && (_4G._incomingType == LE910_INCOMING_SMS))
    {     
      Serial.print(F("SMS index: "));
      Serial.println(_4G._smsIndex, DEC);

      // clear buffer
      memset(sms_received, '\0', sizeof(sms_received));
      
      // Read incoming SMS
      error = _4G.readSMS(_4G._smsIndex, sms_received);

      if (error == 0)
      {
        Serial.print(F("SMS body: "));
        Serial.println(sms_received);
      }
      else
      {
        Serial.print(F("Error reading the sms. Code: "));
        Serial.println(error, DEC);
      }
    }
  }
  else
  {
    Serial.print(F("Waiting connection. Connection:"));
    Serial.println(error, DEC);
  }
}
        

/*  
 *  --------------- 4G_03 - Receiving SMS  --------------- 
 *  
 *  Explanation: This example shows how to set up the module to use
 *  SMS and receive text messages
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

// define variables
uint8_t error;
char sms_received[150];


void setup()
{    
  
  printf("Start program\n");
  
  //////////////////////////////////////////////////
  // 1. Switch on the 4G module
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");


    ////////////////////////////////////////////////
    // 2. Set PIN code
    ////////////////////////////////////////////////  
    error = _4G.enterPIN((char *)"");

    if (error == 1) 
    {
      printf("2. PIN code accepted\n");
    }
    else
    {
      printf("2. PIN code incorrect\n");
    }


    ////////////////////////////////////////////////
    // 2.2. Configure SMS options
    ////////////////////////////////////////////////
    error = _4G.checkConnection(60);

    if (error == 0)
    {
      printf("2. Module connected to network\n");
    }
    else
    {
      printf("2. Module not connected. Connection status: %d\n", error);
    }

    ////////////////////////////////////////////////
    // 2.3. Configure SMS options
    ////////////////////////////////////////////////
    error = _4G.configureSMS();

    if (error == 0)
    {
      printf("4. 4G module configured to use SMS\n");
    }
    else
    {
      printf("4. Error calling 'configureSMS' function. Code: %d\n", error);
    } 

  }
  else
  {
    // Problem with the communication with the 4G module
    printf("4G module not started\n");
    printf("Error code: %d\n", error);
    printf("The code stops here.\n");
    while(1);
  }
 
}

void loop()
{
  ////////////////////////////////////////////////
  // Check connection to network
  ////////////////////////////////////////////////
  error = _4G.checkConnection(60);

  if (error == 0)
  {
    printf("Wait for incoming SMS...\n");

    //////////////////////////////////////////////
    // Manage incoming data
    //////////////////////////////////////////////
    error = _4G.manageIncomingData(60000);

    if ((error == 0) && (_4G._incomingType == LE910_INCOMING_SMS))
    {     
      printf("SMS index: %d\n", error);

      // clear buffer
      memset(sms_received, '\0', sizeof(sms_received));
      
      // Read incoming SMS
      error = _4G.readSMS(_4G._smsIndex, sms_received);

      if (error == 0)
      {
        printf("SMS body: \n%s\n",sms_received);
      }
      else
      {
        printf("Error reading the sms. Code: %d\n", error);
      }
    }
  }
  else
  {
    printf("Waiting connection. Connection status: %d\n", error);
  }

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*
    --- 4G_09 - Uploading files to a FTP server  ---

    Explanation: This example shows how to upload a file to a FTP server
    from Arduino.

    Important: in Arduino the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
*/

#include <arduino4G.h>
#include <PI.h>
#include <SD.h>

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char ftp_server[] = "";
uint16_t ftp_port = 21;
char ftp_user[] = "";
char ftp_pass[] = "";
///////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// Define filenames for SD card and FTP server: (FAT16 NAMES:"AAAAAAAA.EEE")
///////////////////////////////////////////////////////////////////////
char SD_FILE[]     = "SENT.TXT";
char SERVER_FILE[] = "COOKING.TXT";
///////////////////////////////////////////////////////////////////////

// SD settings
///////////////////////////////////////
# define SD_CS (4)
///////////////////////////////////////

// define variables
int error;
uint32_t previous;
uint8_t sd_answer;
File myFile;

void setup()
{
  error = _4G.ON();
  
  Serial.println(F("Start program"));

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);

  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();

  //////////////////////////////////////////////////
  // 1. Create a new file to upload
  //////////////////////////////////////////////////

  ///////////////////////////////////
  // 1.1. Init SD card
  ///////////////////////////////////
  Serial.println("Initializing SD card...");

  sd_answer = SD.begin(SD_CS);
  if (sd_answer != 0) 
  {
    Serial.println("1. SD init OK");
  }
  else
  {
    Serial.println("1. SD init ERROR");
  }
  
  ///////////////////////////////////
  // 1.2. Delete file if exists
  ///////////////////////////////////

  sd_answer = SD.exists(SD_FILE);
  if (sd_answer == 1)
  {
    SD.remove(SD_FILE);
    Serial.println(F("2. File deleted"));
  }
  else
  {
    Serial.println(F("2. File NOT deleted"));
  }

  ///////////////////////////////////
  // 1.3. Create file
  ///////////////////////////////////
  myFile = SD.open(SD_FILE, FILE_WRITE);

  sd_answer = SD.exists(SD_FILE);
  if (sd_answer == 1)
  {
    Serial.println(F("3. New file"));
  }
  else
  {
    Serial.println(F("3. NO new file"));
  }

  ///////////////////////////////////
  // 1.4. Append contents
  ///////////////////////////////////
  Serial.println(F("4. Appending text..."));
  for (int i = 0; i < 10; i++)
  {
    if (SD_FILE)
    {
      myFile.println("This is a new message from Cooking-Hacks");
    }
  }

  ///////////////////////////////////
  //1.5. Close SD
  ///////////////////////////////////
  myFile.close();
  Serial.println(F("5. SD off"));
  Serial.println(F("Setup done\n\n"));

}


void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2.1. FTP open session
    ////////////////////////////////////////////////

    error = _4G.ftpOpenSession(ftp_server, ftp_port, ftp_user, ftp_pass);

    // check answer
    if (error == 0)
    {
      Serial.println(F("2.1. FTP open session OK"));

      previous = millis();

      //////////////////////////////////////////////
      // 2.2. FTP upload
      //////////////////////////////////////////////
      
      error = _4G.ftpUpload(SERVER_FILE, SD_FILE);

      if (error == 0)
      {

        Serial.print(F("2.2. Uploading SD file to FTP server done! "));
        Serial.print(F("Upload time: "));
        Serial.print((millis() - previous) / 1000, DEC);
        Serial.println(F(" s"));
      }
      else
      {
        Serial.print(F("2.2. Error calling 'ftpUpload' function. Error: "));
        Serial.println(error, DEC);
      }
      

      //////////////////////////////////////////////
      // 2.3. FTP close session
      //////////////////////////////////////////////

      error = _4G.ftpCloseSession();

      if (error == 0)
      {
        Serial.println(F("2.3. FTP close session OK"));
      }
      else
      {
        Serial.print(F("2.3. Error calling 'ftpCloseSession' function. error: "));
        Serial.println(error, DEC);
        Serial.print(F("CMEE error: "));
        Serial.println(_4G._errorCode, DEC);        
      }
    }
    else
    {
      Serial.print(F( "2.1. FTP connection error: "));
      Serial.println(error, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("1. 4G module not started"));
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("3. Switch OFF 4G module"));
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
    delay(60000);
}
        

/*
 *  --- 4G_09 - Uploading files to a FTP server  ---
 *
 *  Explanation: This example shows how to upload a file to a FTP server
 *  from Waspmote
 *  
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */
#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char ftp_server[] = "";
uint16_t ftp_port = 21;
char ftp_user[] = "";
char ftp_pass[] = "";
///////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// Define filenames for Raspberry SD card and FTP server:
//  - If the file is in the root directory: "FILE.TXT" or "/FILE.TXT"
//  - If the file is inside a folder: "/FOLDER/FILE.TXT"
///////////////////////////////////////////////////////////////////////
char SD_FILE[]     = "./FTP_FILES/SENT.TXT";
char SERVER_FILE[] = "COOKING.TXT";
///////////////////////////////////////////////////////////////////////

// define variables
int error;
uint32_t previous;
uint8_t sd_answer;

void setup()
{
  printf("Start program\n");

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}


void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");

    ////////////////////////////////////////////////
    // 2.1. FTP open session
    ////////////////////////////////////////////////

    error = _4G.ftpOpenSession(ftp_server, ftp_port, ftp_user, ftp_pass);

    // check answer
    if (error == 0)
    {
      printf("2.1. FTP open session OK\n");

      previous = millis();

      //////////////////////////////////////////////
      // 2.2. FTP upload
      //////////////////////////////////////////////
      
      error = _4G.ftpUpload(SERVER_FILE, SD_FILE);

      if (error == 0)
      {

        printf("2.2. Uploading SD file to FTP server done! \n");
        printf("Upload time: %d s\n",(millis() - previous) / 1000);
      }
      else
      {
        printf("2.2. Error calling 'ftpUpload' function. Error: %d\n", error);
      }
      

      //////////////////////////////////////////////
      // 2.3. FTP close session
      //////////////////////////////////////////////

      error = _4G.ftpCloseSession();

      if (error == 0)
      {
        printf("2.3. FTP close session OK\n");
      }
      else
      {
        printf("2.3. Error calling 'ftpCloseSession' function. error: %d\n", error);
        printf("CMEE error: %d\n", _4G._errorCode);
      }
    }
    else
    {
      printf( "2.1. FTP connection error: %d\n", error);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("1. 4G module not started\n");
  }


  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("3. Switch OFF 4G module\n");
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("4. Enter deep sleep...\n");

  delay(10000);

  printf("5. Wake up!!\n\n");

}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*
    --- 4G_10 - Downloading files to a FTP server  ---

    Explanation: This example shows how to download a file from a FTP
    server to Arduino SD card

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
*/

#include <arduino4G.h>
#include <SPI.h>
#include <SD.h>

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char ftp_server[] = "";
uint16_t ftp_port = 21;
char ftp_user[] = "";
char ftp_pass[] = "";
///////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// Define filenames for SD card and FTP server: (FAT16 NAMES:"AAAAAAAA.EEE")
///////////////////////////////////////////////////////////////////////
char SD_FILE[] = "RECEIVED.TXT";
char SERVER_FILE[] = "COOKING.TXT";
///////////////////////////////////////////////////////////////////////

// SD settings
///////////////////////////////////////
# define SD_CS (4)
///////////////////////////////////////

// define variables
int error;
uint32_t previous;


void setup()
{
  error = _4G.ON();

  Serial.println(F("Start program"));

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);

  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}

void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2.1. FTP open session
    ////////////////////////////////////////////////

    error = _4G.ftpOpenSession(ftp_server, ftp_port, ftp_user, ftp_pass);

    if (error == 0)
    {
      Serial.println(F("2.1. FTP open session OK"));

      previous = millis();

      //////////////////////////////////////////////
      // 2.2. FTP download
      //////////////////////////////////////////////
      error = _4G.ftpDownload(SD_FILE, SERVER_FILE);

      if (error == 0)
      {

        Serial.print(F("2.2. Download SD file from FTP server done! "));
        Serial.print(F("Download time: "));
        Serial.print((millis() - previous) / 1000, DEC);
        Serial.println(F(" s"));
      }
      else
      {
        Serial.print(F("2.2. Error calling 'ftpDownload' function. Error: "));
        Serial.println(error, DEC);
      }

      //////////////////////////////////////////////
      // 2.3. FTP close session
      //////////////////////////////////////////////

      error = _4G.ftpCloseSession();

      if (error == 0)
      {
        Serial.println(F("2.3. FTP close session OK"));
      }
      else
      {
        Serial.print(F("2.3. Error calling 'ftpCloseSession' function. error: "));
        Serial.println(error, DEC);
      }
    }
    else
    {
      Serial.print(F( "FTP connection error: "));
      Serial.println(error, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("4G module not started"));
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("3. Switch OFF 4G module"));
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  delay(60000);
}

        

/*
 *  --- 4G_10 - Downloading files to a FTP server  ---
 *
 *  Explanation: This example shows how to download a file from a FTP
 *  server to Waspmote SD card
 *
 *  Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */
#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char ftp_server[] = "";
uint16_t ftp_port = 21;
char ftp_user[] = "";
char ftp_pass[] = "";
///////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// Define filenames for Raspberry SD card and FTP server:
//  - If the file is in the root directory: "FILE.TXT" or "/FILE.TXT"
//  - If the file is inside a folder: "/FOLDER/FILE.TXT"
///////////////////////////////////////////////////////////////////////
char SD_FILE[] = "./FTP_FILES/RECEIVED.TXT";
char SERVER_FILE[] = "COOKING.TXT";
///////////////////////////////////////////////////////////////////////

int error;
uint32_t previous;


void setup()
{
  printf("Start program\n");

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}

void loop()
{

  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");


    ////////////////////////////////////////////////
    // Enter PIN code
    ////////////////////////////////////////////////    
    printf("Enter PIN code...\n");
   
    if (_4G.enterPIN((char *)"") == 1)
    {
      printf("PIN code accepted\n");
    }
    else
    {
      printf("PIN code incorrect\n");
    }
    
    ////////////////////////////////////////////////
    // 2.1. FTP open session
    ////////////////////////////////////////////////

    error = _4G.ftpOpenSession(ftp_server, ftp_port, ftp_user, ftp_pass);

    if (error == 0)
    {
      printf("2.1. FTP open session OK\n");

      previous = millis();


      //////////////////////////////////////////////
      // 2.2. FTP download
      //////////////////////////////////////////////
      error = _4G.ftpDownload(SD_FILE, SERVER_FILE);

      if (error == 0)
      {

        printf("2.2. Download SD file from FTP server done! ");
        printf("Download time: %d s\n", (millis() - previous) / 1000);
      }
      else
      {
        printf("2.2. Error calling 'ftpDownload' function. Error: %d\n", error);
      }


      //////////////////////////////////////////////
      // 2.3. FTP close session
      //////////////////////////////////////////////

      error = _4G.ftpCloseSession();

      if (error == 0)
      {
        printf("2.3. FTP close session OK\n");
      }
      else
      {
        printf("2.3. Error calling 'ftpCloseSession' function. error: %d\n", error);
      }
    }
    else
    {
      printf( "FTP connection error: %d\n", error);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("4G module not started\n");
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("3. Switch OFF 4G module\n");
  _4G.OFF();


  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("4. Enter deep sleep...\n");

  delay(10000);

  printf("5. Wake up!!\n\n");

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*
    --- 4G_12 - UDP client  ---

    Explanation: This example shows how to open a UDP client socket
    to the specified server address and port. Besides, the functions
    for sending/receiving data are used.

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
*/

#include "arduino4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
uint16_t remote_port = 0;
uint16_t local_port  = 0;
///////////////////////////////////////

// FRAME
///////////////////////////////////////
char frame[] = "Node01:20h30m41s:dato2";
///////////////////////////////////////

// define Socket ID (from 'SOCKET_1' to 'SOCKET_6')
///////////////////////////////////////
uint8_t socketId = arduino4G::SOCKET_1;
///////////////////////////////////////

// define variables
uint8_t  error;
uint32_t previous;
uint8_t  socketIndex;

void setup()
{
  error = _4G.ON();

  if (error == 0)
    Serial.println(F("module ON..."));
  else
    Serial.println(F("module OFF"));

  Serial.println(F("Start program"));

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}

void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2. TCP socket
    ////////////////////////////////////////////////

    error = _4G.openSocket(socketId, UDP_CLIENT, host, remote_port, local_port);

    if (error == 0)
    {
      Serial.println(F("2.1. Opening a socket... done!"));

      Serial.print(F("IP address:"));
      Serial.println(_4G._ip);

      //////////////////////////////////////////////
      // 2.2. Send data
      //////////////////////////////////////////////

      error = _4G.send(socketId, "This is a UDP frame from Cooking Hacks!\n");

      if (error == 0)
      {
        Serial.println(F("2.2. Sending a string... done!"));
      }
      else
      {
        Serial.print(F("2.2. Error sending. Code: "));
        Serial.println(error, DEC);
      }


      //////////////////////////////////////////////
      // 2.3. Create a frame and send it through the connection
      //////////////////////////////////////////////

      error = _4G.send(socketId, (uint8_t *)frame, sizeof(frame));
      if (error == 0)
      {
        Serial.println(F("2.3. Sending a frame... done!"));
      }
      else
      {
        Serial.print(F("2.3. Error sending a frame. Code: "));
        Serial.println(error, DEC);
      }

    }
    else
    {
      Serial.print(F("2.1. Error opening socket. Error code: "));
      Serial.println(error, DEC);
    }

    //////////////////////////////////////////////
    // 2.5. Close socket
    //////////////////////////////////////////////
    error = _4G.closeSocket(socketId);

    if (error == 0)
    {
      Serial.println(F("2.5. Socket closed OK"));
    }
    else
    {
      Serial.print(F("2.5. Error closing socket. Error code: "));
      Serial.println(error, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("1. 4G module not started"));
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("3. Switch OFF 4G module"));
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  
  delay(60000);
}
        

/*
 *  ------------------------ 4G_12 - UDP client  --------------------------
 *
 *  Explanation: This example shows how to open a UDP client socket
 *  to the specified server address and port. Besides, the functions
 *  for sending/receiving data are used.
 *
 *
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
uint16_t remote_port = 15011;
uint16_t local_port  = 4000;
///////////////////////////////////////

// FRAME
///////////////////////////////////////
char frame[] = "Node02-2016/10/6-Value:30";
///////////////////////////////////////

// define Socket ID (from 'SOCKET_1' to 'SOCKET_6')
///////////////////////////////////////
uint8_t socketId = arduPi4G::SOCKET_1;
///////////////////////////////////////


// define variables
uint8_t  error;
uint32_t previous;
uint8_t  socketIndex;


void setup()
{
  printf("Start program\n");

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();

}

void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");


    ////////////////////////////////////////////////
    // 2. TCP socket
    ////////////////////////////////////////////////

    error = _4G.openSocket(socketId, UDP_CLIENT, host, remote_port, local_port);

    if (error == 0)
    {
      printf("2.1. Opening a socket... done!\n");

      printf("IP address: %s\n", _4G._ip);

      //////////////////////////////////////////////
      // 2.2. Send data
      //////////////////////////////////////////////

      error = _4G.send(socketId, (char*)"This is a test message from Cooking Hacks!\n\n");

      if (error == 0)
      {
        printf("2.2. Sending a string... done!\n");
      }
      else
      {
        printf("2.2. Error sending data. Code: %d\n", error);
      }


      //////////////////////////////////////////////
      // 2.3. Create a frame and send it through the connection
      //////////////////////////////////////////////

      error = _4G.send(socketId, (uint8_t*)frame, sizeof(frame));
      if (error == 0)
      {
        printf("2.3. Sending a frame... done!\n");
      }
      else
      {
        printf("2.3. Error sending a frame. Code: %d\n", error);
      }

    }
    else
    {
      printf("2.1. Error opening socket. Error code: %d\n", error);
    }

    //////////////////////////////////////////////
    // 2.5. Close socket
    //////////////////////////////////////////////
    error = _4G.closeSocket(socketId);

    if (error == 0)
    {
      printf("2.5. Socket closed OK\n");
    }
    else
    {
      printf("2.5. Error closing socket. Error code: %d\n", error);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("1. 4G module not started\n");
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("3. Switch OFF 4G module\n");
  _4G.OFF();


  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("4. Enter deep sleep...\n");

  delay(10000);  

  printf("5. Wake up!!\n\n");

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*
    ------------------------ 4G_11 - TCP client  --------------------------

    Copyright (C) Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
*/

#include "arduino4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
uint16_t remote_port = 0;
uint16_t local_port  = 0;
///////////////////////////////////////

// FRAME
///////////////////////////////////////
char frame[] = "Node01-2016/10/6-Value_1\n";
///////////////////////////////////////

// define Socket ID (from 'SOCKET_1' to 'SOCKET_6')
///////////////////////////////////////
uint8_t socketId = arduino4G::SOCKET_1;
///////////////////////////////////////

// define variables
uint8_t  error;
uint32_t previous;
uint8_t  socketIndex;

void setup()
{
  error = _4G.ON();
  if (error == 0)
    Serial.println(F("module ON..."));
  else
    Serial.println(F("module OFF"));

  Serial.println(F("Start program"));

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}

void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2. TCP socket
    ////////////////////////////////////////////////

    error = _4G.openSocket(socketId, TCP_CLIENT, host, remote_port, local_port);

    if (error == 0)
    {
      Serial.println(F("2.1. Opening a socket... done!"));

      Serial.print(F("IP address:"));
      Serial.println(_4G._ip);


      //////////////////////////////////////////////
      // 2.2. Send data
      //////////////////////////////////////////////

      error = _4G.send(socketId, "This is a test frame from Cooking Hacks!\n");

      if (error == 0)
      {
        Serial.println(F("2.2. Sending a string... done!"));
      }
      else
      {
        Serial.print(F("2.2. Error sending. Code: "));
        Serial.println(error, DEC);
      }


      //////////////////////////////////////////////
      // 2.3. Send a frame and send it through the connection
      //////////////////////////////////////////////

      error = _4G.send(socketId, (uint8_t *)frame, sizeof(frame));
      if (error == 0)
      {
        Serial.println(F("2.3. Sending a frame... done!"));
      }
      else
      {
        Serial.print(F("2.3. Error sending a frame. Code: "));
        Serial.println(error, DEC);
      }


      //////////////////////////////////////////////
      // 2.4. Receive data
      //////////////////////////////////////////////

      // Wait for incoming data from the socket (if the other side responds)
      Serial.print(F("2.4. Waiting to receive..."));

      error = _4G.receive(socketId, 60000);

      if (error == 0)
      {
        if (_4G.socketInfo[socketId].size > 0)
        {
          Serial.println(F("\n-----------------------------------"));
          Serial.print(F("Received:"));
          Serial.println((const char *)_4G._buffer);
          Serial.println(F("-----------------------------------"));
        }
        else
        {
          Serial.println(F("Nothing received"));
        }
      }
      else
      {
        Serial.println(F("Nothing received."));
        Serial.println(error, DEC);
      }
    }
    else
    {
      Serial.print(F("2.1. Error opening socket. Error code: "));
      Serial.println(error, DEC);
    }

    //////////////////////////////////////////////
    // 2.5. Close socket
    //////////////////////////////////////////////
    error = _4G.closeSocket(socketId);

    if (error == 0)
    {
      Serial.println(F("2.5. Socket closed OK"));
    }
    else
    {
      Serial.print(F("2.5. Error closing socket. Error code: "));
      Serial.println(error, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("1. 4G module not started"));
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("3. Switch OFF 4G module"));
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////

  delay(60000);

}
        

/*
 *  ------------------------ 4G_11 - TCP client  --------------------------
 *
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

char frame[] = "Node01-2016/10/6-Value_1";

// SERVER settings
///////////////////////////////////////
char host[] = "";
uint16_t remote_port = 15010;
uint16_t local_port  = 4000; 
///////////////////////////////////////

// define Socket ID (from 'SOCKET_1' to 'SOCKET_6')
///////////////////////////////////////
uint8_t socketId = arduPi4G::SOCKET_1;
///////////////////////////////////////

// define variables
uint8_t  error;
uint32_t previous;
uint8_t  socketIndex;

void setup()
{
  printf("Start program\n");

  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();

}

void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");

    ////////////////////////////////////////////////
    // 2. TCP socket
    ////////////////////////////////////////////////

    error = _4G.openSocket(socketId, TCP_CLIENT, host, remote_port, local_port);

    if (error == 0)
    {
      printf("2.1. Opening a socket... done!\n");

      printf("IP address:%s\n", _4G._ip);

      //////////////////////////////////////////////
      // 2.2. Send data
      //////////////////////////////////////////////

      error = _4G.send(socketId, (char*)"This is a test message from Cooking Hacks!\n\n");

      if (error == 0)
      {
        printf("2.2. Sending a string... done!\n");
      }
      else
      {
        printf("2.2. Error sending data. Code: %d\n", error);
      }


      //////////////////////////////////////////////
      // 2.3. Create a frame and send it through the connection
      //////////////////////////////////////////////

      error = _4G.send(socketId, (uint8_t*)frame, sizeof(frame));
      if (error == 0)
      {
        printf("2.3. Sending a frame... done!\n");
      }
      else
      {
        printf("2.3. Error sending a frame. Code: %d\n", error);
      }


      //////////////////////////////////////////////
      // 2.4. Receive data
      //////////////////////////////////////////////

      // Wait for incoming data from the socket (if the other side responds)
      printf("2.4. Waiting to receive data...\n");

      error = _4G.receive(socketId, 60000);

      if (error == 0)
      {
        if (_4G.socketInfo[socketId].size > 0)
        {
          printf("\n-----------------------------------\n");
          printf("Data received:\n %s\n", _4G._buffer);
          printf("-----------------------------------\n");
        }
        else
        {
          printf("NO data received\n");
        }
      }
      else
      {
        printf("No data received. Error code: %d\n", error);
      }
    }
    else
    {
      printf("2.1. Error opening socket. Error code: %d\n", error);
    }

    //////////////////////////////////////////////
    // 2.5. Close socket
    //////////////////////////////////////////////
    error = _4G.closeSocket(socketId);

    if (error == 0)
    {
      printf("2.5. Socket closed OK\n");
    }
    else
    {
      printf("2.5. Error closing socket. Error code: %d\n", error);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("1. 4G module not started\n");
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("3. Switch OFF 4G module\n");
  _4G.OFF();


  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("4. Enter deep sleep...\n");

  delay(10000);

  printf("5. Wake up!!\n\n");

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*  
    -------------------------- 4G_06 - HTTP GET  ------------------------- 
    
    Explanation: This example shows how to send HTTP GET requests

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>. 

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
 */

#include "arduino4G.h"

// include the SD library:
#include <SPI.h>. 
#include <SD.h>. 

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
uint16_t port = 80;
char resource[] = "";
///////////////////////////////////////

// variables
uint8_t error;
uint8_t counter;

void setup()
{
  card.init(SPI_HALF_SPEED, 4);
  error = _4G.ON();
  if (error == 0)
    Serial.println(F("module ON..."));
  else
    Serial.println(F("module OFF"));
  
  Serial.println(F("Start program"));
  
  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}


void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////  
  error = _4G.ON();

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));

    ////////////////////////////////////////////////
    // 2. Waiting for Connection
    ////////////////////////////////////////////////

    // Waiting for network registration
    counter = 7;
    error = _4G.checkConnection(60);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.checkConnection(60);
        counter--;      
    }

    if (error == 0)
    {
      Serial.println(F("2.1. Connected to network"));
    }
    else
    {
      Serial.print(F("2.1. Error connecting to network. Code: "));
      Serial.println(error, DEC);
    } 

    ////////////////////////////////////////////////
    // 2. HTTP GET
    ////////////////////////////////////////////////
    Serial.println(F("2. Getting URL with GET method..."));

    // send the request
    counter = 3;
    error = _4G.http( GET_METHOD, host, port, resource);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.http( GET_METHOD, host, port, resource);
        counter--;      
    }


    // Check the answer
    if (error == 0)
    {
      Serial.print(F("Done. HTTP code: "));
      Serial.println(_4G._httpCode);
      Serial.print("Server response: ");
      Serial.println((char *)_4G._buffer);
    }
    else
    {
      Serial.print(F("Failed. Error code: "));
      Serial.println(error, DEC);
    }    
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("4G module not started"));
    Serial.print(F("Error code: "));
    Serial.println(error, DEC);
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("3. Switch OFF 4G module"));
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  delay(10000);
}

        

/*  
 *  --------------- 4G_06 - HTTP GET  --------------- 
 *  
 *  Copyright (C) Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
uint16_t port = 80;
char resource[] = "/test-get-post.php?varA=1&varB=2&varC=3&varD=4&varE=5&varF=6"\
         "&varG=7&varH=8&varI=9&varJ=10&varK=11&varL=12&varM=13&varN=14&varO=15";
///////////////////////////////////////

// variable
uint8_t error;
uint8_t counter;

void setup()
{
  printf("Start program\n");

  printf("********************************************************************\n");
  printf("GET method to the Libelium's test url\n");
  printf("You can use this php to test the HTTP connection of the module.\n");
  printf("The php returns the parameters that the user sends with the URL.\n");
  printf("********************************************************************\n");


  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}


void loop()
{

  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////  
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");

    ////////////////////////////////////////////////
    // 2. Waiting for Connection
    ////////////////////////////////////////////////

    // Waiting for network registration
    counter = 3;
    error = _4G.checkConnection(60);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.checkConnection(60);
        counter--;      
    }

    if (error == 0)
    {
      printf("2.1. Connected to network\n");
    }
    else
    {
      printf("2.1. Error connecting to network. Code: %d\n", error);
    } 

    ////////////////////////////////////////////////
    // 3. HTTP GET
    ////////////////////////////////////////////////

    printf("3. Getting URL with GET method...");

    // send the request
    counter = 3;
    error = _4G.http( GET_METHOD, host, port, resource);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.http( GET_METHOD, host, port, resource);
        counter--;      
    }

    // Check the answer
    if (error == 0)
    {
      printf("Done.\nHTTP code: %i\n", _4G._httpCode);
      printf("Server response: %s\n", _4G._buffer);
    }
    else
    {
      printf("Failed.\nError code: %d\n", error);
    }    
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("4G module not started\n");
    printf("Error code: %d\n", error);
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("4. Switch OFF 4G module\n");
  _4G.OFF();


  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("5. Enter deep sleep...\n");

  delay(10000);

  printf("6. Wake up!!\n\n");

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////

        

/*  
    -------------------- 4G_07 - HTTP POST  ---------------------- 
    
    Explanation: This example shows how to send HTTP GET requests

    Important: in Arduino UNO the same UART is used for Debug User Interface 
    and LE910 AT commands. Handle with care, user interface messages could 
    interfere with AT commands.

    Example: 
          Serial.print("operATo"); 
    It is seen as wrong AT command by the LE910 module.

    Copyright (C) 2016 Libelium Comunicaciones Distribuidas S.L.
    http://www.libelium.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>. 

    Version:           1.0
    Design:            David Gascón
    Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
                       & Ruben Martin
 */

#include "arduino4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
unsigned int port = 80;
char resource[] = "";
char data[] = "";
///////////////////////////////////////

// variables
int error;

void setup()
{
  error = _4G.ON();
  if (error == 0)
    Serial.println(F("module ON..."));
  else
    Serial.println(F("module OFF"));

  Serial.println(F("Start program"));


  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}


void loop()
{
  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////  
  error = _4G.ON();

  Serial.println(F("Start program"));

  if (error == 0)
  {
    Serial.println(F("1. 4G module ready..."));


    ////////////////////////////////////////////////
    // 2. HTTP POST
    ////////////////////////////////////////////////

    Serial.println(F("2. HTTP POST request..."));

    // send the request
    error = _4G.http( POST_METHOD, host, port, resource, data);

    // check the answer
    if (error == 0)
    {
      Serial.print(F("Done. HTTP code: "));
      Serial.println(_4G._httpCode);
      Serial.print("Server response: ");
      Serial.println((const char *)_4G._buffer);
    }
    else
    {
      Serial.print(F("Failed. Error code: "));
      Serial.println(error, DEC);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    Serial.println(F("4G module not started"));
    Serial.print(F("Error code: "));
    Serial.println(error, DEC);
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  Serial.println(F("3. Switch OFF 4G module"));
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  delay(1000);

}
        

/*  
 *  --------------- 4G_07 - HTTP POST  --------------- 
 *  
 *  Explanation: This example shows how to send HTTP GET requests
 *  
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *  Version:           1.0
 *  Design:            David Gascón
 *  Implementation:    Alejandro Gállego, Yuri Carmona, Luis Miguel Marti
 *                     & Ruben Martin
 */

#include "arduPi4G.h"

// APN settings
///////////////////////////////////////
char apn[] = "";
char login[] = "";
char password[] = "";
///////////////////////////////////////

// SERVER settings
///////////////////////////////////////
char host[] = "";
unsigned int port = 80;
char resource[] = "/test-get-post.php";
char data[] = "/test-get-post.php?varA=1&varB=2&varC=3&varD=4&varE=5&varF=6"\
     "&varG=7&varH=8&varI=9&varJ=10&varK=11&varL=12&varM=13&varN=14&varO=15";
///////////////////////////////////////

// variables
int error;
uint8_t counter;

void setup()
{
  printf("Start program\n");

  printf("********************************************************************\n");
  printf("POST method to the Libelium's test url\n");
  printf("You can use this php to test the HTTP connection of the module.\n");
  printf("The php returns the parameters that the user sends with the URL.\n");
  printf("********************************************************************\n");


  //////////////////////////////////////////////////
  // 1. sets operator parameters
  //////////////////////////////////////////////////
  _4G.set_APN(apn, login, password);


  //////////////////////////////////////////////////
  // 2. Show APN settings via USB port
  //////////////////////////////////////////////////
  _4G.show_APN();
}


void loop()
{

  //////////////////////////////////////////////////
  // 1. Switch ON
  //////////////////////////////////////////////////  
  error = _4G.ON();

  if (error == 0)
  {
    printf("1. 4G module ready...\n");
    ////////////////////////////////////////////////
    // 2. HTTP POST
    ////////////////////////////////////////////////

    printf("2. HTTP POST request...");

    // send the request
    counter = 3;
    error = _4G.http(POST_METHOD, host, port, resource, data);
    while ((counter > 0) && (error != 0))
    {
        delay(5000);
        error = _4G.http(POST_METHOD, host, port, resource, data);
        counter--;      
    }

    // check the answer
    if (error == 0)
    {
      printf("Done.\nHTTP code: %i\n", _4G._httpCode);
      printf("Server response: %s\n", _4G._buffer);
    }
    else
    {
      printf("Failed. Error code: %d\n", error);
    }
  }
  else
  {
    // Problem with the communication with the 4G module
    printf("4G module not started\n");
    printf("Error code: %d\n", error);
  }

  ////////////////////////////////////////////////
  // 3. Powers off the 4G module
  ////////////////////////////////////////////////
  printf("3. Switch OFF 4G module\n");
  _4G.OFF();

  ////////////////////////////////////////////////
  // 4. Sleep
  ////////////////////////////////////////////////
  printf("4. Enter deep sleep...\n");

  delay(10000);

  printf("4. Wake up!!\n\n");
  
}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////
int main()
{
    setup();
    while(1) loop();
    return (0);
}
//////////////////////////////////////////////