wget http://www.cooking-hacks.com/media/cooking/images/documentation/tutorial_kit_sigfox/arduPi_api_Sigfox_v1_2.zip && unzip -u arduPi_api_Sigfox_v1_2.zip && cd cooking/examples/Sigfox && chmod +x cook.sh && cd ../../..  

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"


/*********************************************************
 *  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);
}                 

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

{
   Sigfox.getID();
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 
}



void loop() 
{
  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  error = Sigfox.getID();
    
  // Check status
  if( error == 0 ) 
  {
    //"Get ID OK" Id in Sigfox._id
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Get ID ERROR" 
    digitalWrite(error_led, HIGH);
  } 

  delay(5000);
}

				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  } 
}



void loop() 
{
  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  error = Sigfox.getID();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get ID OK\n");
    printf("Module ID: %X\n", Sigfox._id);
  }
  else 
  {
    printf("Get ID ERROR\n"); 
  } 

  delay(5000);
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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

		

www.libelium.com/development/waspmote/examples/sigfox-01-read-id
				

{
   char data[] = “0102030405060708090A0B”;
   Sigfox.send(data);
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // 1. switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check status
  if( error == 0 ) 
  {
    //"Switch ON OK"     
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 

  //////////////////////////////////////////////
  // 2. send data
  //////////////////////////////////////////////
  
  // Send 12 bytes at most
  error = Sigfox.send("000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Sigfox packet sent OK"
    digitalWrite(error_led, LOW);     
  }
  else 
  {
    //"Sigfox packet sent ERROR" 
    digitalWrite(error_led, HIGH);
  } 
}


void loop() 
{  
  //////////////////////////////////////////////
  // 3. sleep
  //////////////////////////////////////////////
}
				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // 1. switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  } 

  //////////////////////////////////////////////
  // 2. send data
  //////////////////////////////////////////////
  
  // Send 12 bytes at most
  error = Sigfox.send((char*)"000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Sigfox packet sent OK\n");
  }
  else 
  {
    printf("Sigfox packet sent ERROR\n"); 
  } 

  printf("Enter Sleep\n");
}


void loop() 
{  
  //////////////////////////////////////////////
  // 3. sleep
  //////////////////////////////////////////////
}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/sigfox-02-send-data-string
				

{
   uint8_t data[] = { 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B };
   Sigfox.send(data, 12);
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

#define second 1000
#define minute 60*second
//const unsigned int second = 1000; // 1 segundo
//const unsigned int minute = 60;   // 1 minutes
unsigned long pausetime = 1 * minute;  // pause in minutes
unsigned long previousMillis = 0; 

// define variable to create a speficic frame to be sent
uint8_t data[12];
uint8_t size;

// define error variable
uint8_t error;

// define error pin
const int error_led =  13;

// define analogs pins
const int temperature_pin = A0;
const int battery_pin = A1;

// define digitals pins
const int DIGITAL1 = 2;
const int DIGITAL2 = 3;
const int DIGITAL3 = 4;
const int DIGITAL4 = 5;
const int DIGITAL5 = 6;
const int DIGITAL6 = 7;
const int DIGITAL7 = 8;
const int DIGITAL8 = 9;

// define vars for sensors
float temperature;
uint8_t battery;
uint8_t digitalPins;
uint8_t digital1;
uint8_t digital2;
uint8_t digital3;
uint8_t digital4;
uint8_t digital5;
uint8_t digital6;
uint8_t digital7;
uint8_t digital8;

// define union-type variables
union
{
  uint8_t  value1[4];
  float    value2;
}temp_union;


void setup() 
{
  //Initialize pins
  pinMode(error_led, OUTPUT);
  for (int i=2; i==9; i++) pinMode(i, INPUT);

  //////////////////////////////////////////////
  // 1. switch on              
  //////////////////////////////////////////////  

  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"     
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 
}

void loop() 
{
  unsigned long currentMillis = millis();
  //Wait "pausetime" in minutes to send data array
  if (currentMillis - previousMillis >= pausetime) 
  {
    // save the last time in send data
    previousMillis = currentMillis;
    
    //////////////////////////////////////////////
    // 2. create array with sensor data
    // Sigfox Back-END device "Display type" must be: 
    // Temp::float:32 Battery::uint:8 Digital8::bool:7 Digital7::bool:6
    //       Digital6::bool:5 Digital5::bool:4 Digital4::bool:3
    //       Digital3::bool:2 Digital2::bool:1 Digital1::bool:0
    //////////////////////////////////////////////
  
    // 2. Reading sensors:
    // 2.1. simulate temperature raw reading.
    temperature = (float)analogRead(temperature_pin);  
   
    // 2.2. simulate battery level raw reading
    battery = (uint8_t)analogRead(battery_pin);  
 
    // 2.3. Digital pins reading
    digital1 = digitalRead(DIGITAL1);
    digital2 = digitalRead(DIGITAL2);
    digital3 = digitalRead(DIGITAL3);
    digital4 = digitalRead(DIGITAL4);
    digital5 = digitalRead(DIGITAL5);
    digital6 = digitalRead(DIGITAL6);
    digital7 = digitalRead(DIGITAL7);
    digital8 = digitalRead(DIGITAL8);
  
    //Digital Pins (bitmap):
    digitalPins |= digital1;
    digitalPins |= digital2 << 1;
    digitalPins |= digital3 << 2;
    digitalPins |= digital4 << 3;
    digitalPins |= digital5 << 4;
    digitalPins |= digital6 << 5;
    digitalPins |= digital7 << 6;
    digitalPins |= digital8 << 7;  
  
    // 2.4. Fill structure fields
    temp_union.value2 = temperature;  
  
    // fill 'data' buffer with data
    data[0] = temp_union.value1[3]; // big-endian
    data[1] = temp_union.value1[2];
    data[2] = temp_union.value1[1];
    data[3] = temp_union.value1[0];
    data[4] = battery;
    data[5] = digitalPins;
    size = 6;
         
    //Final Frame to send in "data"
  
    //////////////////////////////////////////////
    // 3. send data
    //////////////////////////////////////////////
   
    //3. Sending packet:
    error = Sigfox.send(data,size);
  
    // Check sending status
    if( error == 0 ) 
    {
      //"Sigfox packet sent OK"
      digitalWrite(error_led, LOW);     
    }
    else 
    {
      //"Sigfox packet sent ERROR" 
      digitalWrite(error_led, HIGH);
    } 
  }
  //////////////////////////////////////////////
  // 4. sleep pause_time (minutes)
  //////////////////////////////////////////////
}

				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

#define second 1000
#define minute 60*second
unsigned long pausetime = 1 * minute;  // pause in minutes
unsigned long previousMillis = 0; 

// define variable to create a speficic frame to be sent
uint8_t data[12];
uint8_t size;

// define error variable
uint8_t error;

// define analogs pins
const int temperature_pin = 0;
const int battery_pin = 1;

// define digitals pins
const int DIGITAL1 = 2;
const int DIGITAL2 = 3;
const int DIGITAL3 = 4;
const int DIGITAL4 = 5;
const int DIGITAL5 = 6;
const int DIGITAL6 = 7;
const int DIGITAL7 = 8;
const int DIGITAL8 = 9;

// define vars for sensors
float temperature;
uint8_t battery;
uint8_t digitalPins;
uint8_t digital1;
uint8_t digital2;
uint8_t digital3;
uint8_t digital4;
uint8_t digital5;
uint8_t digital6;
uint8_t digital7;
uint8_t digital8;

// define union-type variables
union
{
  uint8_t  value1[4];
  float    value2;
}temp_union;


void setup() 
{
  //Initialize pins
  for (int i=2; i==9; i++) pinMode(i, INPUT);

  //////////////////////////////////////////////
  // 1. switch on              
  //////////////////////////////////////////////  
  printf("1. Switch on the module:\n");

  error = Sigfox.ON(sock);
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n"); 
  } 
}

void loop() 
{
  unsigned long currentMillis = millis();

  //Wait "pausetime" in minutes to send data array
  if (currentMillis - previousMillis >= pausetime) 
  {
    // save the last time in send data
    previousMillis = currentMillis;
    
    //////////////////////////////////////////////
    // 2. create array with sensor data
    // Sigfox Back-END device "Display type" must be: 
    // Temp::float:32 Battery::uint:8 Digital8::bool:7 Digital7::bool:6
    //       Digital6::bool:5 Digital5::bool:4 Digital4::bool:3
    //       Digital3::bool:2 Digital2::bool:1 Digital1::bool:0
    //////////////////////////////////////////////
  
    // 2. Reading sensors:
    printf("2. Reading sensors:\n");
 
    // 2.1. simulate temperature raw reading.
    temperature = (float)analogRead(temperature_pin);  
    printf("RAW temperature: %f\n", temperature);  
   
    // 2.2. simulate battery level raw reading
    battery = (uint8_t)analogRead(battery_pin);  
    printf("RAW battery: %d\n", battery);
 
    // 2.3. Digital pins reading
    digital1 = digitalRead(DIGITAL1);
    digital2 = digitalRead(DIGITAL2);
    digital3 = digitalRead(DIGITAL3);
    digital4 = digitalRead(DIGITAL4);
    digital5 = digitalRead(DIGITAL5);
    digital6 = digitalRead(DIGITAL6);
    digital7 = digitalRead(DIGITAL7);
    digital8 = digitalRead(DIGITAL8);
  
    //Digital Pins (bitmap):
    digitalPins |= digital1;
    digitalPins |= digital2 << 1;
    digitalPins |= digital3 << 2;
    digitalPins |= digital4 << 3;
    digitalPins |= digital5 << 4;
    digitalPins |= digital6 << 5;
    digitalPins |= digital7 << 6;
    digitalPins |= digital8 << 7; 
    
    printf("Digital Pins (bitmap HEX): 0x%X\n", digitalPins);
  
    // 2.4. Fill structure fields
    temp_union.value2 = temperature;  
  
    // fill 'data' buffer with data
    data[0] = temp_union.value1[3]; // big-endian
    data[1] = temp_union.value1[2];
    data[2] = temp_union.value1[1];
    data[3] = temp_union.value1[0];
    data[4] = battery;
    data[5] = digitalPins;
    size = 6;
         
    //Final Frame to send in "data"
    printf("Final Frame to send: 0x%X\n", data);
  
    //////////////////////////////////////////////
    // 3. send data
    //////////////////////////////////////////////
    
    printf("3. Sending packet:\n");
   
    //3. Sending packet:
    error = Sigfox.send(data,size);
  
    // Check sending status
    if( error == 0 ) 
    {
      printf("Sigfox packet sent OK\n");
    }
    else 
    {
      printf("Sigfox packet sent ERROR\n");
    } 
  //////////////////////////////////////////////
  // 4. sleep pause_time (minutes)
  //////////////////////////////////////////////
  printf("4. Sleep %d minutes\n", (pausetime/(60*second)));
  printf("-----------------------------\n");
  }
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/sigfox-03-send-data-array
				

{
   char data[] = “0102030405060708090A0B”;
   Sigfox.sendACK(data);
}
            

/*
 *  Sigfox 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
 */ 
 
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // 1. switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check status
  if( error == 0 ) 
  {
    //"Switch ON OK"     
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 

  //////////////////////////////////////////////
  // 2. send data
  //////////////////////////////////////////////
  
  // Send 12 bytes at most
  error = Sigfox.sendACK("000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Sigfox packet sent OK"
    digitalWrite(error_led, LOW);   

    //"Back-End response" in Sigfox._buffer
  }
  else 
  {
    //"Sigfox packet sent ERROR" 
    digitalWrite(error_led, LOW);
  } 
}


void loop() 
{  
  //////////////////////////////////////////////
  // 3. sleep
  //////////////////////////////////////////////
}
 
				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // 1. switch on
  //////////////////////////////////////////////
  printf("Sigfox - Sending example\n");

  error = Sigfox.ON(sock);
  
  // Check status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  } 

  //////////////////////////////////////////////
  // 2. send data
  //////////////////////////////////////////////
  printf("Sending a packet...\n");

  // Send 12 bytes at most
  error = Sigfox.sendACK((char*)"000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Sigfox packet sent OK\n");
    printf("Back-End response: 0x%X\n", Sigfox._buffer);
  }
  else 
  {
    printf("Sigfox packet sent ERROR\n"); 
  } 

  printf("Enter Sleep\n");
}


void loop() 
{  
  //////////////////////////////////////////////
  // 3. sleep
  //////////////////////////////////////////////
}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/sigfox-04-send-data-string-ack
				

{
   uint8_t data[] = { 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B };
   Sigfox.sendACK(data, 12);
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

const unsigned int second = 1000; // 1 segundo
const unsigned int minute = 60;   // 1 minutes
unsigned long pausetime = 1 * minute * second;  // pause in minutes
unsigned long previousMillis = 0; 

// define variable to create a speficic frame to be sent
uint8_t data[12];
uint8_t size;

// define error variable
uint8_t error;

// define error pin
const int error_led =  13;

// define analogs pins
const int temperature_pin = A0;
const int battery_pin = A1;

// define digitals pins
const int DIGITAL1 = 2;
const int DIGITAL2 = 3;
const int DIGITAL3 = 4;
const int DIGITAL4 = 5;
const int DIGITAL5 = 6;
const int DIGITAL6 = 7;
const int DIGITAL7 = 8;
const int DIGITAL8 = 9;

// define vars for sensors
float temperature;
uint8_t battery;
uint8_t digitalPins;
uint8_t digital1;
uint8_t digital2;
uint8_t digital3;
uint8_t digital4;
uint8_t digital5;
uint8_t digital6;
uint8_t digital7;
uint8_t digital8;

// define union-type variables
union
{
  uint8_t  value1[4];
  float    value2;
}temp_union;


void setup() 
{
  //Initialize pins
  pinMode(error_led, OUTPUT);
  for (int i=2; i==9; i++) pinMode(i, INPUT);

  //////////////////////////////////////////////
  // 1. switch on              
  //////////////////////////////////////////////  

  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"     
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 
}

void loop() 
{
  unsigned long currentMillis = millis();
  //Wait "pausetime" in minutes to send data array
  if (currentMillis - previousMillis >= pausetime) 
  {
    // save the last time in send data
    previousMillis = currentMillis;
    
    //////////////////////////////////////////////
    // 2. create array with sensor data
    // Sigfox Back-END device "Display type" must be: 
    // Temp::float:32 Battery::uint:8 Digital8::bool:7 Digital7::bool:6
    //       Digital6::bool:5 Digital5::bool:4 Digital4::bool:3
    //       Digital3::bool:2 Digital2::bool:1 Digital1::bool:0
    //////////////////////////////////////////////
  
    // 2. Reading sensors:
    // 2.1. simulate temperature raw reading.
    temperature = (float)analogRead(temperature_pin);  
   
    // 2.2. simulate battery level raw reading
    battery = (uint8_t)analogRead(battery_pin);  
 
    // 2.3. Digital pins reading
    digital1 = digitalRead(DIGITAL1);
    digital2 = digitalRead(DIGITAL2);
    digital3 = digitalRead(DIGITAL3);
    digital4 = digitalRead(DIGITAL4);
    digital5 = digitalRead(DIGITAL5);
    digital6 = digitalRead(DIGITAL6);
    digital7 = digitalRead(DIGITAL7);
    digital8 = digitalRead(DIGITAL8);
  
    //Digital Pins (bitmap):
    digitalPins |= digital1;
    digitalPins |= digital2 << 1;
    digitalPins |= digital3 << 2;
    digitalPins |= digital4 << 3;
    digitalPins |= digital5 << 4;
    digitalPins |= digital6 << 5;
    digitalPins |= digital7 << 6;
    digitalPins |= digital8 << 7;  
  
    // 2.4. Fill structure fields
    temp_union.value2 = temperature;  
  
    // fill 'data' buffer with data
    data[0] = temp_union.value1[3]; // big-endian
    data[1] = temp_union.value1[2];
    data[2] = temp_union.value1[1];
    data[3] = temp_union.value1[0];
    data[4] = battery;
    data[5] = digitalPins;
    size = 6;
         
    //Final Frame to send in "data"
  
    //////////////////////////////////////////////
    // 3. send data
    //////////////////////////////////////////////
   
    //3. Sending packet:
    error = Sigfox.sendACK(data,size);
  
    // Check sending status
    if( error == 0 ) 
    {
      //"Sigfox packet sent OK"
      digitalWrite(error_led, LOW);     
    }
    else 
    {
      //"Sigfox packet sent ERROR" 
      digitalWrite(error_led, HIGH);
      //"Back-End response" in Sigfox._buffer
    } 
  }
  //////////////////////////////////////////////
  // 4. sleep pause_time (minutes)
  //////////////////////////////////////////////
}

				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

#define second 1000
#define minute 60*second
unsigned long pausetime = 1 * minute;  // pause in minutes
unsigned long previousMillis = 0; 

// define variable to create a speficic frame to be sent
uint8_t data[12];
uint8_t size;

// define error variable
uint8_t error;

// define analogs pins
const int temperature_pin = 0;
const int battery_pin = 1;

// define digitals pins
const int DIGITAL1 = 2;
const int DIGITAL2 = 3;
const int DIGITAL3 = 4;
const int DIGITAL4 = 5;
const int DIGITAL5 = 6;
const int DIGITAL6 = 7;
const int DIGITAL7 = 8;
const int DIGITAL8 = 9;

// define vars for sensors
float temperature;
uint8_t battery;
uint8_t digitalPins;
uint8_t digital1;
uint8_t digital2;
uint8_t digital3;
uint8_t digital4;
uint8_t digital5;
uint8_t digital6;
uint8_t digital7;
uint8_t digital8;

// define union-type variables
union
{
  uint8_t  value1[4];
  float    value2;
}temp_union;


void setup() 
{
  //Initialize pins
  for (int i=2; i==9; i++) pinMode(i, INPUT);

  //////////////////////////////////////////////
  // 1. switch on              
  //////////////////////////////////////////////  
  printf("1. Switch on the module:\n");

  error = Sigfox.ON(sock);
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n"); 
  } 
}

void loop() 
{
  unsigned long currentMillis = millis();


  //Wait "pausetime" in minutes to send data array
  if (currentMillis - previousMillis >= pausetime) 
  {
    // save the last time in send data
    previousMillis = currentMillis;
    
    //////////////////////////////////////////////
    // 2. create array with sensor data
    // Sigfox Back-END device "Display type" must be: 
    // Temp::float:32 Battery::uint:8 Digital8::bool:7 Digital7::bool:6
    //       Digital6::bool:5 Digital5::bool:4 Digital4::bool:3
    //       Digital3::bool:2 Digital2::bool:1 Digital1::bool:0
    //////////////////////////////////////////////
  
    // 2. Reading sensors:
    printf("2. Reading sensors:\n");
 
    // 2.1. simulate temperature raw reading.
    temperature = (float)analogRead(temperature_pin);
    printf("RAW temperature: %f\n", temperature);  
   
    // 2.2. simulate battery level raw reading
    battery = (uint8_t)analogRead(battery_pin);  
    printf("RAW battery: %d\n", battery);
 
    // 2.3. Digital pins reading
    digital1 = digitalRead(DIGITAL1);
    digital2 = digitalRead(DIGITAL2);
    digital3 = digitalRead(DIGITAL3);
    digital4 = digitalRead(DIGITAL4);
    digital5 = digitalRead(DIGITAL5);
    digital6 = digitalRead(DIGITAL6);
    digital7 = digitalRead(DIGITAL7);
    digital8 = digitalRead(DIGITAL8);
  
    //Digital Pins (bitmap):
    digitalPins |= digital1;
    digitalPins |= digital2 << 1;
    digitalPins |= digital3 << 2;
    digitalPins |= digital4 << 3;
    digitalPins |= digital5 << 4;
    digitalPins |= digital6 << 5;
    digitalPins |= digital7 << 6;
    digitalPins |= digital8 << 7; 
    
    printf("Digital Pins (bitmap HEX): 0x%X\n", digitalPins);
  
    // 2.4. Fill structure fields
    temp_union.value2 = temperature;  
  
    // fill 'data' buffer with data
    data[0] = temp_union.value1[3]; // big-endian
    data[1] = temp_union.value1[2];
    data[2] = temp_union.value1[1];
    data[3] = temp_union.value1[0];
    data[4] = battery;
    data[5] = digitalPins;
    size = 6;
         
    //Final Frame to send in "data"
    printf("Final Frame to send: 0x%X\n", data);
  
    //////////////////////////////////////////////
    // 3. send data
    //////////////////////////////////////////////
    
    printf("3. Sending packet:\n");
   
    //3. Sending packet:
    error = Sigfox.sendACK(data,size);
  
    // Check sending status
    if( error == 0 ) 
    {
      printf("Sigfox packet sent OK\n");
      printf("Back-End response: 0x%X\n", Sigfox._buffer);
    }
    else 
    {
      printf("Sigfox packet sent ERROR\n");
    } 
  //////////////////////////////////////////////
  // 4. sleep pause_time (minutes)
  //////////////////////////////////////////////
  printf("Sleep %d minutes\n", pausetime/(60*second));
  }
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/sigfox-05-send-data-array-ack
				

{
   Sigfox.sendKeepAlive();
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 

  //////////////////////////////////////////////
  // Send Keep-Alive packet
  //////////////////////////////////////////////
  Sigfox.sendKeepAlive();
   
  // Check sending status
  if( error == 0 ) 
  {
    //"Send Keep-Alive: OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Send Keep-Alive: ERROR"
    digitalWrite(error_led, HIGH);
  }       
}


void loop() 
{

  delay(10000);
}
				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  } 

  //////////////////////////////////////////////
  // Send Keep-Alive packet
  //////////////////////////////////////////////
  Sigfox.sendKeepAlive();
   
  // Check sending status
  if( error == 0 ) 
  {
    printf("Send Keep-Alive: OK\n");
  }
  else 
  {
    printf("Send Keep-Alive: ERROR\n");
  }       
}


void loop() 
{
  delay(10000);
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/sigfox-06-send-keep-alive
				

{
   Sigfox.setPower(14);
}
            

{
   Sigfox.getPower();
}
            

/*
 *  Sigfox 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
 */ 
 
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 
}

void loop() 
{
  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  error = Sigfox.setPower(14);
    
  // Check status
  if( error == 0 ) 
  {
    //"Power Level set OK"
    digitalWrite(error_led, LOW);

  }
  else 
  {
    //"Power Level set ERROR"  
    digitalWrite(error_led, HIGH);
  }
 } 
  
  
  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  error = Sigfox.getPower();
    
  // Check status
  if( error == 0 ) 
  {
    //"Power Level get OK"
    //"Power Level" in Sigfox._power
    digitalWrite(error_led, LOW);

  }
  else 
  {
    //"Power Level get ERROR"
    digitalWrite(error_led, HIGH);
  } 
  
  delay(5000);
}
				

/*
 *  Sigfox 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
 */ 
 
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  } 
}

void loop() 
{
  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  error = Sigfox.setPower(14);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Power Level set OK\n");
  }
  else 
  {
    printf("Power Level set ERROR\n");  
  }
 

  
  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  error = Sigfox.getPower();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Power Level get OK\n");
    printf("Power Level: %d\n", Sigfox._power);

  }
  else 
  {
    printf("Power Level get ERROR\n");
  } 
  
  delay(5000);
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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

				

www.libelium.com/development/waspmote/examples/sigfox-07-set-get-power-level
				

{
   int16_t   count   = 10;
   uint16_t  period  = 1;
   int16_t   channel = 1;

   Sigfox.testTransmit(count, period, channel);
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

// define TEST settings
/////////////////////////////////////////////
uint16_t  counter = 10;
uint16_t  period  = 10;
int16_t   channel = -1;
/////////////////////////////////////////////


void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
  
  //////////////////////////////////////////////
  // Perform SIGFOX TX test
  //////////////////////////////////////////////

  Sigfox.testTransmit(counter,period,channel);
   
  // Check sending status
  if( error == 0 ) 
  {
    //"Sigfox TX test: OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Sigfox TX test: ERROR"
    digitalWrite(error_led, HIGH);
  }       
}


void loop() 
{
  delay(10000);
}
				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

// define TEST settings
/////////////////////////////////////////////
uint16_t  counter = 10;
uint16_t  period  = 10;
int16_t   channel = -1;
/////////////////////////////////////////////


void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n"); 
  }   
  
  //////////////////////////////////////////////
  // Perform SIGFOX TX test
  //////////////////////////////////////////////
  printf("Testing...\n");

  Sigfox.testTransmit(counter,period,channel);
   
  // Check sending status
  if( error == 0 ) 
  {
    printf("Sigfox TX test: OK\n");
  }
  else 
  {
    printf("Sigfox TX test: ERROR\n");
  }       
  
  //////////////////////////////////////////////
  // Sleep
  //////////////////////////////////////////////
  printf("Sleep...\n");
}


void loop() 
{
  delay(10000);
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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

				

www.libelium.com/development/waspmote/examples/sigfox-08-test-sigfox
				

{
   Sigfox.showFirmware();
}
            

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;


void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
}


void loop() 
{

  //////////////////////////////////////////////
  // get Firmware data
  //////////////////////////////////////////////
  Sigfox.showFirmware();
  //Firmware version stored in "SigFox._firmware" string
 
  delay(5000);
}
				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;


void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n"); 
  }   
}


void loop() 
{

  //////////////////////////////////////////////
  // show Firmware data
  //////////////////////////////////////////////
  
  Sigfox.showFirmware();
  //Firmware version stored in "SigFox._firmware" string
 
  delay(5000);
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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

				

www.libelium.com/development/waspmote/examples/sigfox-09-show-firmware
				

{
   Sigfox.setAddressLAN(0x000001);
   Sigfox.getAddressLAN();
}
            

/*
 *  Sigfox 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
 */ 
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////


// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK" 
    digitalWrite(error_led, LOW);  
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._address
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set Mask OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set Mask ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._mask
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);    
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set frequency OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get frequency OK"
    // "Frequency: " in Sigfox._frequency
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set power level OK"
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Set power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get power level OK"
    // "Power Level (dBm): " in Sigfox._powerLAN
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
	
  delay(5000);
}
				

/*
 *  Sigfox 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
 */ 
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get LAN Address OK\n");
    printf("Module ID: 0x%X\n", Sigfox._address);
  }
  else 
  {
    printf("Get LAN Address ERROR\n");
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set Mask OK\n");
  }
  else 
  {
    printf("Set Mask ERROR\n");
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get Mask OK\n");
    printf("Mask ID: 0x%X\n", Sigfox._mask);
  }
  else 
  {
    printf("Get Mask ERROR\n");
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set frequency OK\n");
  }
  else 
  {
    printf("Set frequency ERROR\n");
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get frequency OK\n");
    printf("Frequency: %d\n", Sigfox._frequency);
  }
  else 
  {
    printf("Get frequency ERROR\n");
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set power level OK\n");
  }
  else 
  {
    printf("Set power level ERROR\n");
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get power level OK\n");
    printf("Power Level (dBm): %s\n", Sigfox._powerLAN);
  }
  else 
  {
    printf("Get power level ERROR\n");
  }

  printf("---------------------------\n");
  delay(5000);

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/lan-01-configure-module
				

{
   Sigfox.setMask(0xFFFFFF);
   Sigfox.getMask();
}
            

/*
 *  Sigfox 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
 */ 
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////


// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK" 
    digitalWrite(error_led, LOW);  
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._address
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set Mask OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set Mask ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._mask
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);    
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set frequency OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get frequency OK"
    // "Frequency: " in Sigfox._frequency
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set power level OK"
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Set power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get power level OK"
    // "Power Level (dBm): " in Sigfox._powerLAN
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
	
  delay(5000);
}
				

/*
 *  Sigfox 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
 */ 
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get LAN Address OK\n");
    printf("Module ID: 0x%X\n", Sigfox._address);
  }
  else 
  {
    printf("Get LAN Address ERROR\n");
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set Mask OK\n");
  }
  else 
  {
    printf("Set Mask ERROR\n");
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get Mask OK\n");
    printf("Mask ID: 0x%X\n", Sigfox._mask);
  }
  else 
  {
    printf("Get Mask ERROR\n");
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set frequency OK\n");
  }
  else 
  {
    printf("Set frequency ERROR\n");
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get frequency OK\n");
    printf("Frequency: %d\n", Sigfox._frequency);
  }
  else 
  {
    printf("Get frequency ERROR\n");
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set power level OK\n");
  }
  else 
  {
    printf("Set power level ERROR\n");
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get power level OK\n");
    printf("Power Level (dBm): %s\n", Sigfox._powerLAN);
  }
  else 
  {
    printf("Get power level ERROR\n");
  }

  printf("---------------------------\n");
  delay(5000);

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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



				

www.libelium.com/development/waspmote/examples/lan-01-configure-module
				

{
   Sigfox.setFrequency(869312500);
   Sigfox.getFrequency();
}
            

/*
 *  Sigfox 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
 */ 
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////


// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK" 
    digitalWrite(error_led, LOW);  
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._address
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set Mask OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set Mask ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._mask
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);    
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set frequency OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get frequency OK"
    // "Frequency: " in Sigfox._frequency
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set power level OK"
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Set power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get power level OK"
    // "Power Level (dBm): " in Sigfox._powerLAN
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
	
  delay(5000);
}
				

/*
 *  Sigfox 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
 */ 
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get LAN Address OK\n");
    printf("Module ID: 0x%X\n", Sigfox._address);
  }
  else 
  {
    printf("Get LAN Address ERROR\n");
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set Mask OK\n");
  }
  else 
  {
    printf("Set Mask ERROR\n");
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get Mask OK\n");
    printf("Mask ID: 0x%X\n", Sigfox._mask);
  }
  else 
  {
    printf("Get Mask ERROR\n");
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set frequency OK\n");
  }
  else 
  {
    printf("Set frequency ERROR\n");
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get frequency OK\n");
    printf("Frequency: %d\n", Sigfox._frequency);
  }
  else 
  {
    printf("Get frequency ERROR\n");
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set power level OK\n");
  }
  else 
  {
    printf("Set power level ERROR\n");
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get power level OK\n");
    printf("Power Level (dBm): %s\n", Sigfox._powerLAN);
  }
  else 
  {
    printf("Get power level ERROR\n");
  }

  printf("---------------------------\n");
  delay(5000);

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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



				

www.libelium.com/development/waspmote/examples/lan-01-configure-module
				

{
   Sigfox.setPowerLAN(14);
   Sigfox.getPowerLAN();
}
            

/*
 *  Sigfox 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
 */ 
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////


// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK" 
    digitalWrite(error_led, LOW);  
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._address
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set Mask OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set Mask ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get LAN Address OK"
    // "Module ID:" in Sigfox._mask
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Get LAN Address ERROR"
    digitalWrite(error_led, HIGH);    
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set frequency OK"
    digitalWrite(error_led, LOW);    
  }
  else 
  {
    // "Set frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get frequency OK"
    // "Frequency: " in Sigfox._frequency
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get frequency ERROR"
    digitalWrite(error_led, HIGH);    
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set power level OK"
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Set power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    // "Get power level OK"
    // "Power Level (dBm): " in Sigfox._powerLAN
    digitalWrite(error_led, LOW);        
  }
  else 
  {
    // "Get power level ERROR"
    digitalWrite(error_led, HIGH);        
  } 
	
  delay(5000);
}
				

/*
 *  Sigfox 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
 */ 
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. Range: From 0x000000 to 0xFFFFFF. Default: 0x000000
// MASK: Define the Mask address. Range: From 0x000000 to 0xFFFFFF. Default: 0xFFFFFF
// FREQUENCY: Define the Frequency. Range: From 868000000 to 869700000. Default: 869700000
// POWER: Define the RF power level in dBm. Range: From -35 to 14. Default: 14
///////////////////////////////////////////////////////////////////////////////////////////
uint32_t address   = 0x000001;
uint32_t mask      = 0xFFFFFF;
uint32_t frequency = 869700000;
uint8_t  power     = 14;
///////////////////////////////////////////////////////////////////////////////////////////

uint8_t error;


void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   
}


void loop() 
{
  //////////////////////////////////////////////
  // 1. Set/Get LAN address
  //////////////////////////////////////////////
  
  // 1.1. Set LAN address
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 
  
  // 1.2. Get LAN address
  error = Sigfox.getAddressLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get LAN Address OK\n");
    printf("Module ID: 0x%X\n", Sigfox._address);
  }
  else 
  {
    printf("Get LAN Address ERROR\n");
  }
  
  
  //////////////////////////////////////////////
  // 2. Set/Get Mask address
  //////////////////////////////////////////////
 
  // 2.1. Set mask
  error = Sigfox.setMask(mask);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set Mask OK\n");
  }
  else 
  {
    printf("Set Mask ERROR\n");
  } 
  
  // 2.2. Get mask
  error = Sigfox.getMask();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get Mask OK\n");
    printf("Mask ID: 0x%X\n", Sigfox._mask);
  }
  else 
  {
    printf("Get Mask ERROR\n");
  } 

  
  //////////////////////////////////////////////
  // 3. Set/Get Frequency band
  //////////////////////////////////////////////
 
  // 3.1. Set frequency
  error = Sigfox.setFrequency(frequency);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set frequency OK\n");
  }
  else 
  {
    printf("Set frequency ERROR\n");
  } 
  
  // 3.2. Get frequency
  error = Sigfox.getFrequency();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get frequency OK\n");
    printf("Frequency: %d\n", Sigfox._frequency);
  }
  else 
  {
    printf("Get frequency ERROR\n");
  } 
      
  
  //////////////////////////////////////////////
  // 4. Set/Get Power level
  //////////////////////////////////////////////
 
  // 4.1. Set power level
  error = Sigfox.setPowerLAN(power);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set power level OK\n");
  }
  else 
  {
    printf("Set power level ERROR\n");
  } 
  
  // 4.2. Get power level
  error = Sigfox.getPowerLAN();
    
  // Check status
  if( error == 0 ) 
  {
    printf("Get power level OK\n");
    printf("Power Level (dBm): %s\n", Sigfox._powerLAN);
  }
  else 
  {
    printf("Get power level ERROR\n");
  }

  printf("---------------------------\n");
  delay(5000);

}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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



				

www.libelium.com/development/waspmote/examples/lan-01-configure-module
				

{
   char data[] = “00112233445566778899AABBCCDDEEFF00”;
   Sigfox.sendLAN(data);
}
            

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

// define buffer for data transmission
char data[35];

uint8_t error;
uint8_t e = 0;
uint32_t counter = 0;

void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);

  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
  
  
  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 
}


void loop()
{
  // create new data
  counter++;
  snprintf(data, sizeof(data), "%034x", counter);

  // "data to send:" in data

  
  //////////////////////////////////////////////
  // Send command
  //////////////////////////////////////////////  
   
  error = Sigfox.sendLAN(data);

  // Check status
  if( error == 0 ) 
  {
    // "Send packet OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Send packet ERROR"
    digitalWrite(error_led, HIGH);
  }
  
  delay(5000);
}

				

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

// define buffer for data transmission
char data[35];

uint8_t error;
uint8_t e = 0;
uint32_t counter = 0;

void setup() 
{
  
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   
  
  
  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 
}


void loop()
{
  // create new data
  counter++;
  snprintf(data, sizeof(data), "%034x", counter);

  printf("data to send: %s\n", data);
  
  //////////////////////////////////////////////
  // Send command
  //////////////////////////////////////////////  
   
  error = Sigfox.sendLAN(data);

  // Check status
  if( error == 0 ) 
  {
    printf("Send packet OK\n");
  }
  else 
  {
    printf("Send packet ERROR\n");
  }
  
  delay(5000);
}
//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/lan-02-send-data-string
				

{
   uint8_t data[17];
   
   data[0]  = 0x00;
   data[1]  = 0x11;
   data[2]  = 0x22;
   data[3]  = 0x33;
   data[4]  = 0x44;
   data[5]  = 0x55;
   data[6]  = 0x66;
   data[7]  = 0x77;
   data[8]  = 0x88;
   data[9]  = 0x99;
   data[10] = 0xAA;
   data[11] = 0xBB;
   data[12] = 0xCC;
   data[13] = 0xDD;
   data[14] = 0xEE;
   data[15] = 0xFF;
   data[16] = 0x00;

   Sigfox.sendLAN(data, 17);
}
            

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

// define buffer for data transmission
uint8_t data[17];
uint8_t length;

uint8_t error;
uint32_t counter = 0;

void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);

  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   
  
  
  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 

}


void loop()
{
  
  //////////////////////////////////////////////
  // Create array of bytes to send
  //////////////////////////////////////////////  
  
  length = 0;
  data[length++] = 0x00;
  data[length++] = 0x01;
  data[length++] = 0x02;
  data[length++] = 0x03;
  data[length++] = 0x04;
  data[length++] = 0x05;
  data[length++] = 0x06;
  data[length++] = 0x07;
  data[length++] = 0x08;
  data[length++] = 0x09;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = counter++;
  
  // "Data to send:" in data string
 
  //////////////////////////////////////////////
  // Send command
  //////////////////////////////////////////////  
   
  error = Sigfox.sendLAN(data, length);

  // Check status
  if( error == 0 ) 
  {
    // "Send packet OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Send packet ERROR"
    digitalWrite(error_led, HIGH);
  }

  delay(5000);
}

				

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

// define buffer for data transmission
uint8_t data[17];
uint8_t length;

uint8_t error;
uint32_t counter = 0;

void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n"); 
  }   
  
  
  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);
    
  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 

}


void loop()
{
  
  //////////////////////////////////////////////
  // Create array of bytes to send
  //////////////////////////////////////////////  
  
  length = 0;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = 0x00;
  data[length++] = counter++;
  
  printf("Data to send: %d\n", counter);
 
  //////////////////////////////////////////////
  // Send command
  //////////////////////////////////////////////  
   
  error = Sigfox.sendLAN(data, length);

  // Check status
  if( error == 0 ) 
  {
    printf("Send packet OK\n");
  }
  else 
  {
    printf("Send packet ERROR\n");
  }

  delay(5000);
}


//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/lan-05-send-data-array
				

{
   Sigfox.receive(10);
}
            

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

uint8_t error;


void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);

  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   


  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);

  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 
}



void loop()
{
  // Receive data
  // "Waiting for data..."

  error = Sigfox.receive(10);

  if (error == 0) 
  {
    // "Packet received: " in Sigfox._packet
    digitalWrite(error_led, LOW);
  }
  else
  {
    // "Packet not received (timeout)"
    digitalWrite(error_led, HIGH);
  }
}


				

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"


//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

uint8_t error;


void setup() 
{
  
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   


  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);

  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 
}



void loop()
{
  // Receive data
  printf("Waiting for data...\n");

  error = Sigfox.receive(10);

  if (error == 0) 
  {
    printf("Packet received: %s\n", Sigfox._packet);
  }
  else
  {
    printf("Packet not received (timeout)\n");
  }
  delay(5000); 
}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/lan-03-receive-single-packet
				

{
   // after switching on the module:
   Sigfox.setMultiPacket();

   // every time we listen to a new incoming packet:
   Sigfox.getMultiPacket(10);
}
            

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);

  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   


  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);

  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 

  
  //////////////////////////////////////////////
  // Set Multi-packet reception  mode
  //////////////////////////////////////////////
  error = Sigfox.setMultiPacket();

  // Check status
  if( error == 0 ) 
  {
    // "Set Multi-packet mode OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Set Multi-packet mode ERROR"
    digitalWrite(error_led, HIGH);
  } 

}



void loop()
{
  // Receive data
  // wait for a new packet (10 seconds)
  error = Sigfox.getMultiPacket(10);

  if (error == 0) 
  {
    // "Packet received: " in Sigfox._packet
    digitalWrite(error_led, LOW);
  }
  else
  {
    // "Packet not received (timeout)"
    digitalWrite(error_led, HIGH);
  }
}


				

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
     
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address. 
// Range: From 0x000000 to 0xFFFFFF. 
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n"); 
  }   


  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);

  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 

  
  //////////////////////////////////////////////
  // Set Multi-packet reception  mode
  //////////////////////////////////////////////
  error = Sigfox.setMultiPacket();

  // Check status
  if( error == 0 ) 
  {
    printf("Set Multi-packet mode OK\n");
  }
  else 
  {
    printf("Set Multi-packet mode ERROR\n");
  } 

}


void loop()
{
  // Receive data
  printf("Waiting for data...\n");   

  // wait for a new packet (10 seconds)
  error = Sigfox.getMultiPacket(10);

  if (error == 0) 
  {
    printf("Packet received: %s\n", Sigfox._packet);
  }
  else
  {
    printf("Packet not received (timeout)\n");
  }
  delay(5000);
}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/lan-04-receive-multi-packet
				

{
   Sigfox.disableRX();
}
            

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
  
     
#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address.
// Range: From 0x000000 to 0xFFFFFF.
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

uint8_t error;

// sigfox packet is 12-byte length (24 hexa)
char sigfox_packet[25];



void setup()
{
  pinMode(error_led, OUTPUT);

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    //"Switch ON OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  }   


  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);

  // Check status
  if( error == 0 ) 
  {
    // "Set LAN Address OK"
    digitalWrite(error_led, LOW);
  }
  else 
  {
    // "Set LAN Address ERROR"
    digitalWrite(error_led, HIGH);
  } 


  //////////////////////////////////////////////
  // Set Multi-packet reception  mode
  //////////////////////////////////////////////
  error = Sigfox.setMultiPacket();

  // Check status
  if( error == 0 )
  {
    // "Set Multi-packet mode OK"
    digitalWrite(error_led, LOW);
  }
  else
  {
    // "Set Multi-packet mode ERROR"
    digitalWrite(error_led, HIGH);
  }
}



void loop()
{
  // Receive data
  // "Waiting for LAN data..."

  // wait for a new packet (10 seconds)
  error = Sigfox.getMultiPacket(10);

  if (error == 0)
  {
    // "LAN Packet received: " in Sigfox._packet);

    // copy first 12 bytes from received LAN packet
    snprintf( sigfox_packet, sizeof(sigfox_packet), "%s", Sigfox._packet);

    // "Routing the packet to Sigfox network (only first 12 bytes)...
    // "Sigfox packet to send: " in sigfox_packet
    // send Sigfox packet with received data (only first 12 bytes)
    error = Sigfox.send(sigfox_packet);

    // Check sending status
    if( error == 0 )
    {
      // "Sigfox packet sent OK"
      digitalWrite(error_led, LOW);
    }
    else
    {
      // "Sigfox packet sent ERROR"
      digitalWrite(error_led, HIGH);
    }
  }
  else
  {
    // "Packet not received (timeout)"
    digitalWrite(error_led, HIGH);
  }
}
				

/*
 *  Sigfox 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
 */ 

// Put your libraries here (#include ...)
  
#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

// ADDRESS: Define the LAN network address.
// Range: From 0x000000 to 0xFFFFFF.
// Default: 0x000000
//////////////////////////////////////////////
uint32_t address   = 0x000001;
//////////////////////////////////////////////

uint8_t error;

// sigfox packet is 12-byte length (24 hexa)
char sigfox_packet[25];



void setup()
{

  //////////////////////////////////////////////
  // switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);

  // Check sending status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  }   


  //////////////////////////////////////////////
  // Set LAN address
  //////////////////////////////////////////////
  error = Sigfox.setAddressLAN(address);

  // Check status
  if( error == 0 ) 
  {
    printf("Set LAN Address OK\n");
  }
  else 
  {
    printf("Set LAN Address ERROR\n");
  } 


  //////////////////////////////////////////////
  // Set Multi-packet reception  mode
  //////////////////////////////////////////////
  error = Sigfox.setMultiPacket();

  // Check status
  if( error == 0 )
  {
    printf("Set Multi-packet mode OK\n");
  }
  else
  {
    printf("Set Multi-packet mode ERROR\n");
  }

}


void loop()
{
  // Receive data
  printf("Waiting for LAN data...\n");

  // wait for a new packet (10 seconds)
  error = Sigfox.getMultiPacket(10);

  if (error == 0)
  {
    printf("---------------------------------------\n");
    printf("LAN Packet received: %s\n", Sigfox._packet);

    // copy first 12 bytes from received LAN packet
    snprintf( sigfox_packet, sizeof(sigfox_packet), "%s", Sigfox._packet);

    printf("Routing the packet to Sigfox network (only first 12 bytes)...\n");
    printf("Sigfox packet to send: %s\n", sigfox_packet);

    // send Sigfox packet with received data (only first 12 bytes)
    error = Sigfox.send(sigfox_packet);

    // Check sending status
    if( error == 0 )
    {
      printf("Sigfox packet sent OK\n");
    }
    else
    {
      printf("Sigfox packet sent ERROR\n");
    }
    printf("---------------------------------------\n\n");
  }
  else
  {
    printf("Packet not received (timeout)\n\n");
  }
}
//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

www.libelium.com/development/waspmote/examples/lan-06-lan-to-sigfox-gateway
				

Temp::float:32 AccX::uint:16:little-endian AccY::uint:16:little-endian AccZ::uint:16:little-endian Battery::uint:8 Digital8::bool:7 Digital7::bool:6 Digital6::bool:5 Digital5::bool:4 Digital4::bool:3 Digital3::bool:2 Digital2::bool:1 Digital1::bool:0
            

<?php
    $data['data'] = array(
	"id" 		=> $_GET["id"],
     	"time" 	=> $_GET["time"],
     	"duplicate" 	=> $_GET["duplicate"],
     	"snr" 		=> $_GET["snr"],
     	"station" 	=> $_GET["station"],
     	"data" 	=> $_GET["data"],
     	"avgSignal" 	=> $_GET["avgSignal"],
     	"lat"		=> $_GET["lat"],
     	"lng"		=> $_GET["lng"],
     	"rssi" 	=> $_GET["rssi"],
	"seqNumber"	=> $_GET["seqNumber"], 
     );

     if ($fd = fopen('YOUR_PATH/sigfox.json','a')){
       fwrite($fd,json_encode($data));
       fclose($fd);
     }
?>
            

<?php

$user = "##YOUR_USER##";
$password = "##YOUR_PASSWORD##";
$url = "https://backend.sigfox.com/api/devices/##YOUR_DEVICE_ID##/messages";

$ch = curl_init();
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_URL,$url);
curl_setopt($ch, CURLOPT_USERPWD, "$user:$password");
$result=curl_exec($ch);
curl_close($ch);

$data = (json_decode($result, true));

?>


<html>
	<table>
	<thead>
		<tr>
			<th>device</th>
			<th>time</th>
			<th>data</th>
			<th>snr</th>
		</tr>
	</thead>
	<tbody>
		<?php
			foreach($data['data'] as $reg){
		?>
			<tr>
				<td><?php echo $reg['device']?></td>
				<td><?php echo $reg['time']?></td>
				<td><?php echo $reg['data']?></td>
				<td><?php echo $reg['snr']?></td>
			</tr>
		<?php
			}
		?>
	</tbody>
</html>

/*
 *  Sigfox 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
 */ 

#include <cookingClasses.h>
#include <cookingSigfox.h>
#include <cookingUART.h>
#include <cookingUtils.h>

// Pin definition for Sigfox module error LED:
const int error_led =  13;

//////////////////////////////////////////////
uint8_t socket = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  pinMode(error_led, OUTPUT);
  
  //////////////////////////////////////////////
  // 1. switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(socket);
  
  // Check status
  if( error == 0 ) 
  {
    //"Switch ON OK"     
    digitalWrite(error_led, LOW);
  }
  else 
  {
    //"Switch ON ERROR" 
    digitalWrite(error_led, HIGH);
  } 

  //////////////////////////////////////////////
  // 2. send data
  //////////////////////////////////////////////
  
  // Send 12 bytes at most
  error = Sigfox.send("000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 ) 
  {
    //"Sigfox packet sent OK"
    digitalWrite(error_led, LOW);     
  }
  else 
  {
    //"Sigfox packet sent ERROR" 
    digitalWrite(error_led, LOW);
  } 
}


void loop() 
{  
  //////////////////////////////////////////////
  // 3. sleep
  //////////////////////////////////////////////
}
				

/*
 *  Sigfox 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
 */ 

#include "cookingClasses.h"
#include "cookingSigfox.h"
#include "cookingUART.h"
#include "cookingUtils.h"

//////////////////////////////////////////////
uint8_t sock = SOCKET0;     //Asign to UART0
//////////////////////////////////////////////

uint8_t error;

void setup() 
{
  //////////////////////////////////////////////
  // 1. switch on
  //////////////////////////////////////////////
  error = Sigfox.ON(sock);
  
  // Check status
  if( error == 0 ) 
  {
    printf("Switch ON OK\n");
  }
  else 
  {
    printf("Switch ON ERROR\n");
  } 

  //////////////////////////////////////////////
  // 2. send data
  //////////////////////////////////////////////
  
  // Send 12 bytes at most
  error = Sigfox.send((char*)"000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 ) 
  {
    printf("Sigfox packet sent OK\n");
  }
  else 
  {
    printf("Sigfox packet sent ERROR\n"); 
  } 

  printf("Enter Sleep\n");
}


void loop() 
{  
  //////////////////////////////////////////////
  // 3. sleep
  //////////////////////////////////////////////
}

//////////////////////////////////////////////
// Main loop setup() and loop() declarations
//////////////////////////////////////////////

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

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


				

#include <WaspSigfox.h>

uint8_t socket = SOCKET0;
uint8_t error;

void setup()
{
  USB.ON(); 
  USB.println(F("Sigfox - Sending example"));
}

void loop()
{
  // 1. switch on
  error = Sigfox.ON(socket);

  // Check sending status
  if( error == 0 )
  {
    USB.println(F("Switch ON OK"));
  }
  else 
  {
    USB.println(F("Switch ON ERROR"));
  }
  
  
  // 2. send data
  
  USB.println(F("Sending a packet..."));
  
  // Send 12 bytes at most
  error = Sigfox.send("000102030405060708090A0B");
  
  // Check sending status
  if( error == 0 )
  {
    USB.println(F("Sigfox packet sent OK"));
  }
  else 
  {
    USB.println(F("Sigfox packet sent ERROR"));
  }
  
  
  // 3. sleep
  USB.println("\nEnter sleep");
  PWR.deepSleep("00:01:00:00",RTC_OFFSET,RTC_ALM1_MODE1,ALL_OFF);
  USB.println("\n***************************************");
}