/WaspXBeeXSC.cpp

/*
 *  Copyright (C) 2009 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 Lesser General Public License as published by
 *  the Free Software Foundation, either version 2.1 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 Lesser General Public License for more details.
  
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:		0.11
 *  Design:		David Gascón
 *  Implementation:	Alberto Bielsa
 */
 

#ifndef __WPROGRAM_H__
	#include "WaspClasses.h"
#endif

void	WaspXBeeXSC::init(uint8_t protocol_used, uint8_t frequency, uint8_t model_used)
{
	protocol=protocol_used;
	freq=frequency;
	model=model_used;
}

/*
 Function: Set the module into Command Mode
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::setCommandMode()
{
  uint8_t error=0;

	delay(1500);
  	XBee.print("+++");
  	delay(1000);
	clean();
	error=0;
	return error;
}

/*
 Function: Exits the module from Command Mode
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::exitCommandMode()
{
  	clean();
  	XBee.println("atcn");
  	delay(1000);
  	return check();
}

/*
 Function: Set the Module Vendor ID
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "vendorID" variable the module Vendor ID
*/
uint8_t WaspXBeeXSC::setVendorID(uint8_t VID_H, uint8_t VID_L)
{
  clean();
  XBee.print("atid");
  XBee.print(VID_H,HEX);
  XBee.println(VID_L,HEX);
  delay(1000);
  if(!check())
  {
	vendorID[0]=VID_H;
	vendorID[1]=VID_L;
	return 0;
  }
  return 1;
}

/*
 Function: Get the Module Vendor ID
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "vendorID" variable the module Vendor ID
*/
uint8_t WaspXBeeXSC::getVendorID()
{
  uint8_t ByteIN[10];
  uint8_t error=2;
  uint8_t i=0;

  clean();
  XBee.println("atid");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  vendorID[0]=converter(ByteIN[0],ByteIN[1]);
  vendorID[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}


/*
 Function: Set the Baud Rate used in the module
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "baudRate" variable the Baud Rate used in the module
*/
uint8_t WaspXBeeXSC::setBaudRate(uint8_t brate)
{
  clean();
  XBee.print("atbd");
  XBee.println(brate,DEC);
  delay(1000);
  if(!check())
  {
	baudRate=brate;
	return 0;
  }
  return 1;
}


/*
 Function: Get the Baud Rate used in the module
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "baudRate" variable the Baud Rate used in the module
*/
uint8_t WaspXBeeXSC::getBaudRate()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atbd");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  baudRate=converter(ByteIN[0]);
  return error;
}

/*
 Function: Get the dBm level in the most recent packet
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "valueRSSI" variable the dBm level in the most recent packet
*/
uint8_t WaspXBeeXSC::getRSSI()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atdb");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  valueRSSI=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Set the networking address of a module
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "destAddress" variable the networking address of the module
*/
uint8_t WaspXBeeXSC::setDestAddress(uint8_t destAD_H, uint8_t destAD_L)
{
  clean();
  XBee.print("atdt");
  XBee.print(destAD_H,HEX);
  XBee.println(destAD_L,HEX);
  delay(1000);
  
  if(!check())
  {
	destAddress[0]=destAD_H;
	destAddress[1]=destAD_L;
	return 0;
  }
  return 1;
}

/*
 Function: Get the networking address of a module
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "destAddress" variable the Baud Rate used in the module
*/
uint8_t WaspXBeeXSC::getDestAddress()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atdt");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  destAddress[0]=converter(ByteIN[0],ByteIN[1]);
  destAddress[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set the receive error count
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "receiveErrorCount" variable the receive error count
*/
uint8_t WaspXBeeXSC::setReceiveErrorCount(uint8_t recerror_H, uint8_t recerror_L)
{
  clean();
  XBee.print("ater");
  XBee.print(recerror_H,HEX);
  XBee.println(recerror_L,HEX);
  delay(1000);
  
  if(!check())
  {
	receiveErrorCount[0]=recerror_H;
	receiveErrorCount[1]=recerror_L;
	return 0;
  }
  return 1;
}

/*
 Function: Set the receive error count
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "receiveErrorCount" variable the receive error count
*/
uint8_t WaspXBeeXSC::getReceiveErrorCount()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("ater");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  receiveErrorCount[0]=converter(ByteIN[0],ByteIN[1]);
  receiveErrorCount[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Force a Wake-up initializer to be sent on the next transmit
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::forceWakeUP()
{
  clean();
  XBee.println("atfh");
  delay(1000);
  return check();
}

/*
 Function: Resets the module through the UART
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::forceReset()
{
  clean();
  XBee.println("atfr");
  delay(1000);
  return check();
}

/*
 Function: Set the receive good count
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "receiveGoodCount" variable the receive good count
*/
uint8_t WaspXBeeXSC::setReceiveGoodCount(uint8_t recgood_H, uint8_t recgood_L)
{
  clean();
  XBee.print("atgd");
  XBee.print(recgood_H,HEX);
  XBee.println(recgood_L,HEX);
  delay(1000);
  
  if(!check())
  {
	receiveGoodCount[0]=recgood_H;
	receiveGoodCount[1]=recgood_L;
	return 0;
  }
  return 1;
}

/*
 Function: Set the receive good count
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "receiveGoodCount" variable the receive good count
*/
uint8_t WaspXBeeXSC::getReceiveGoodCount()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atgd");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  receiveGoodCount[0]=converter(ByteIN[0],ByteIN[1]);
  receiveGoodCount[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set the Hopping Channel used in the communication
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "channel" variable the Hopping Channel used in the communication
*/
uint8_t WaspXBeeXSC::setHoppingChannel(uint8_t hchannel)
{
  clean();
  XBee.print("athp");
  XBee.println(hchannel,DEC);
  delay(1000);
  
  if(!check())
  {
	channel=hchannel;
	return 0;
  }
  return 1;
}

/*
 Function: Get the Hopping Channel used in the communication
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "channel" variable the Hopping Channel used in the communication
*/
uint8_t WaspXBeeXSC::getHoppingChannel()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("athp");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  channel=converter(ByteIN[0]);
  return error;
}

/*
 Function: Set the time before Wake-UP initializer
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeBeforeWakeUP" variable the time before Wake-UP initializer
*/
uint8_t WaspXBeeXSC::setTimeBeforeWakeUP(uint8_t timeHT_H, uint8_t timeHT_L)
{
  clean();
  XBee.print("atht");
  XBee.print(timeHT_H,HEX);
  XBee.println(timeHT_L,HEX);
  delay(1000);
  
  if(!check())
  {
	timeBeforeWakeUP[0]=timeHT_H;
	timeBeforeWakeUP[1]=timeHT_L;
	return 0;
  }
  return 1;
}

/*
 Function: Get the time before Wake-UP initializer
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeBeforeWakeUP" variable the time before Wake-UP initializer
*/
uint8_t WaspXBeeXSC::getTimeBeforeWakeUP()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atht");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  timeBeforeWakeUP[0]=converter(ByteIN[0],ByteIN[1]);
  timeBeforeWakeUP[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set the amount of time Wake-UP initializer is sent
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeWakeUpInit" variable the amount of time Wake-UP initializer is sent
*/
uint8_t WaspXBeeXSC::setTimeWakeUpInit(uint8_t timeLH)
{
  clean();
  XBee.print("atlh");
  XBee.println(timeLH,HEX);
  delay(1000);
  
  if(!check())
  {
	timeWakeUpInit=timeLH;
	return 0;
  }
  return 1;
}

/*
 Function: Get the amount of time Wake-UP initializer is sent
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeWakeUpInit" variable the amount of time Wake-UP initializer is sent
*/
uint8_t WaspXBeeXSC::getTimeWakeUpInit()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atlh");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  timeWakeUpInit=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Set the address mask
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "addressMask" variable the address mask
*/
uint8_t WaspXBeeXSC::setAddressMask(uint8_t mask_H, uint8_t mask_L)
{
  clean();
  XBee.print("atmk");
  XBee.print(mask_H,HEX);
  XBee.println(mask_L,HEX);
  delay(1000);
  
  if(!check())
  {
	addressMask[0]=mask_H;
	addressMask[1]=mask_L;
	return 0;
  }
  return 1;
}

/*
 Function: Get the address mask
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "addressMask" variable the address mask
*/
uint8_t WaspXBeeXSC::getAddressMask()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atmk");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  addressMask[0]=converter(ByteIN[0],ByteIN[1]);
  addressMask[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set Pin Wake-UP ON/OFF
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "pinWakeUP" variable Pin Wake-UP ON/OFF
*/
uint8_t WaspXBeeXSC::setPinWakeUP(uint8_t pin)
{
  clean();
  XBee.print("atpw");
  XBee.println(pin,DEC);
  delay(1000);
  
  if(!check())
  {
	pinWakeUP=pin;
	return 0;
  }
  return 1;
}

/*
 Function: Get Pin Wake-UP ON/OFF
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "pin" variable Pin Wake-UP ON/OFF
*/
uint8_t WaspXBeeXSC::getPinWakeUP()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atpw");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  pinWakeUP=converter(ByteIN[0]);
  return error;
}

/*
 Function: Restore all configurable parameters to defaults values
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::restoreDefaults()
{
  clean();
  XBee.println("atre");
  delay(1000);
  return check();
}

/*
 Function: Set Random delay slots
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "delaySlots" variable the Random delay slots
*/
uint8_t WaspXBeeXSC::setDelaySlots(uint8_t slot)
{
  clean();
  XBee.print("atrn");
  XBee.println(slot,HEX);
  delay(1000);
  
  if(!check())
  {
	delaySlots=slot;
	return 0;
  }
  return 1;
}

/*
 Function: Get Random delay slots
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "delaySlots" variable the Random delay slots
*/
uint8_t WaspXBeeXSC::getDelaySlots()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atrn");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  delaySlots=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Set the packetization timeout
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "packetTimeout" variable the packetization timeout
*/
uint8_t WaspXBeeXSC::setPacketTimeout(uint8_t pack_H, uint8_t pack_L)
{
  clean();
  XBee.print("atro");
  XBee.print(pack_H,HEX);
  XBee.println(pack_L,HEX);
  delay(1000);
  
  if(!check())
  {
	packetTimeout[0]=pack_H;
	packetTimeout[1]=pack_L;
	return 0;
  }
  return 1;
}

/*
 Function: Get the packetization timeout
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "packetTimeout" variable the packetization timeout
*/
uint8_t WaspXBeeXSC::getPacketTimeout()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atro");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  packetTimeout[0]=converter(ByteIN[0],ByteIN[1]);
  packetTimeout[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set the time the output pin is active with the RSSI value
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeRSSI" variable the time the output pin is active with the RSSI value
*/
uint8_t WaspXBeeXSC::setRSSItime(uint8_t rssiTime)
{
  clean();
  XBee.print("atrp");
  XBee.println(rssiTime,HEX);
  delay(1000);
  
  if(!check())
  {
	timeRSSI=rssiTime;
	return 0;
  }
  return 1;
}

/*
 Function: Get the time the output pin is active with the RSSI value
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeRSSI" variable the time the output pin is active with the RSSI value
*/
uint8_t WaspXBeeXSC::getRSSItime()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atrp");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  timeRSSI=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Set the number of retries that can be sent for a given packet RF
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "retries" variable the number of retries that can be sent for a given packet RF
*/
uint8_t WaspXBeeXSC::setRetries(uint8_t retry)
{
  clean();
  XBee.print("atrr");
  XBee.println(retry,HEX);
  delay(1000);
  
  if(!check())
  {
	retries=retry;
	return 0;
  }
  return 1;
}

/*
 Function: Get the number of retries that can be sent for a given packet RF
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "retries" variable the number of retries that can be sent for a given packet RF
*/
uint8_t WaspXBeeXSC::getRetries()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atrr");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  retries=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Get RSSI of the last packet received
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "RSSI" variable the RSSI of the last packet received
*/
uint8_t WaspXBeeXSC::getRSSIvalue()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atrs");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  RSSI=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Set the number of bits in the data packet
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "stopBits" variable the number of bits in the data packet
*/
uint8_t WaspXBeeXSC::setStopBits(uint8_t stop)
{
  clean();
  XBee.print("atsb");
  XBee.println(stop,HEX);
  delay(1000);
  
  if(!check())
  {
	stopBits=stop;
	return 0;
  }
  return 1;
}

/*
 Function: Get the number of bits in the data packet
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "stopBits" variable the number of bits in the data packet
*/
uint8_t WaspXBeeXSC::getStopBits()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atsb");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  stopBits=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Get the 32b higher Source Mac 
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "sourceMacHigh" variable the 32b higher Source Mac 
*/
uint8_t WaspXBeeXSC::getSourceMacHigh()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atsh");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  if(i<5)
  {
	  ByteIN[3]=ByteIN[2];
	  ByteIN[2]=ByteIN[1];
	  ByteIN[1]=ByteIN[0];
	  ByteIN[0]=0;
  }
  it=0; 
  i=0;
  while(i<4)
  {
	sourceMacHigh[it]=converter(ByteIN[i],ByteIN[i+1]);
	i++;
	i++;
	it++;
  }
  return error;
}

/*
 Function: Get the 32b lowe Source Mac 
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "sourceMacLow" variable the 32b lower Source Mac 
*/
uint8_t WaspXBeeXSC::getSourceMacLow()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atsl");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  if(i<5)
  {
	  ByteIN[3]=ByteIN[2];
	  ByteIN[2]=ByteIN[1];
	  ByteIN[1]=ByteIN[0];
	  ByteIN[0]=0;
  }
  i=0;
  it=0;
  while(i<4)
  {
	sourceMacLow[it]=converter(ByteIN[i],ByteIN[i+1]);
	i++;
	i++;
	it++;
  }
  return error;
}

/*
 Function: Set the Sleep Mode
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "sleepMode" variable the Sleep Mode
*/
uint8_t WaspXBeeXSC::setSleepMode(uint8_t smode)
{
  clean();
  XBee.print("atsm");
  XBee.println(smode,DEC);
  delay(1000);
  
  if(!check())
  {
	sleepMode=smode;
	return 0;
  }
  return 1;
}

/*
 Function: Get the Sleep Mode
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "sleepMode" variable the Sleep Mode
*/
uint8_t WaspXBeeXSC::getSleepMode()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atsm");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  sleepMode=converter(ByteIN[0]);
  return error;
}


/*
 Function: Set the amount of time the module stays inactive before entering into Sleep Mode
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "awakeTime" variable the amount of time the module stays inactive before entering into Sleep Mode
*/
uint8_t WaspXBeeXSC::setAwakeTime(uint8_t awake_H, uint8_t awake_L)
{
  clean();
  XBee.print("atst");
  XBee.print(awake_H,HEX);
  XBee.println(awake_L,HEX);
  delay(1000);
  
  if(!check())
  {
	awakeTime[0]=awake_H;
	awakeTime[1]=awake_L;
	return 0;
  }
  return 1;
}


/*
 Function: Get the amount of time the module stays inactive before entering into Sleep Mode
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "awakeTime" variable the amount of time the module stays inactive before entering into Sleep Mode
*/
uint8_t WaspXBeeXSC::getAwakeTime()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atst");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  awakeTime[0]=converter(ByteIN[0],ByteIN[1]);
  awakeTime[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set the Time before sending again Initializer
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeBeforeInit" variable the Time before sending again Initializer
*/
uint8_t WaspXBeeXSC::setTimeBeforeInit(uint8_t timeInit)
{
  clean();
  XBee.print("atsy");
  XBee.println(timeInit,HEX);
  delay(1000);
  
  if(!check())
  {
	timeBeforeInit=timeInit;
	return 0;
  }
  return 1;
}

/*
 Function: Get the Time before sending again Initializer
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "timeBeforeInit" variable the Time before sending again Initializer
*/
uint8_t WaspXBeeXSC::getTimeBeforeInit()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atsy");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  timeBeforeInit=converter(ByteIN[0],ByteIN[1]);
  return error;
}

/*
 Function: Set the trasmit error count
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "transmitErrorCount" variable the transmit error count
*/
uint8_t WaspXBeeXSC::setTransmitErrorCount(uint8_t txerror_H, uint8_t txerror_L)
{
  clean();
  XBee.print("attr");
  XBee.print(txerror_H,HEX);
  XBee.println(txerror_L,HEX);
  delay(1000);
  
  if(!check())
  {
	transmitErrorCount[0]=txerror_H;
	transmitErrorCount[1]=txerror_L;
	return 0;
  }
  return 1;
}

/*
 Function: Set the transmit error count
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "transmitErrorCount" variable the transmit error count
*/
uint8_t WaspXBeeXSC::getTransmitErrorCount()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("attr");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  transmitErrorCount[0]=converter(ByteIN[0],ByteIN[1]);
  transmitErrorCount[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Set the max number of bytes a module can send before waiting some random time
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "transmitLimit" variable the max number of bytes a module can send before waiting some random time
*/
uint8_t WaspXBeeXSC::setTransmitLimit(uint8_t txlim_H, uint8_t txlim_L)
{
  clean();
  XBee.print("attt");
  XBee.print(txlim_H,HEX);
  XBee.println(txlim_L,HEX);
  delay(1000);
  
  if(!check())
  {
	transmitLimit[0]=txlim_H;
	transmitLimit[1]=txlim_L;
	return 0;
  }
  return 1;
}

/*
 Function: Get the max number of bytes a module can send before waiting some random time
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "transmitLimit" variable the max number of bytes a module can send before waiting some random time
*/
uint8_t WaspXBeeXSC::getTransmitLimit()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("attt");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  transmitLimit[0]=converter(ByteIN[0],ByteIN[1]);
  transmitLimit[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Get the Firmware Version of the module
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Values: Stores in global "firmwareVersion" variable the Firmware Version of the module
*/
uint8_t WaspXBeeXSC::getSoftVersion()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atvr");
  delay(1000);
  while(XBee.available() > 0) 
  {
	ByteIN[i]=XBee.read();
	i++;
	error=0;
  }
  firmwareVersion[0]=converter(ByteIN[0],ByteIN[1]);
  firmwareVersion[1]=converter(ByteIN[2],ByteIN[3]);
  return error;
}

/*
 Function: Write the values into a non-volatil memory
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::writeValues()
{
  uint8_t ByteIN[10];
  uint8_t error=1;
  uint8_t i=0;

  clean();
  XBee.println("atwr");
  delay(1000);
  return check();
}

/*
 Function: Send bytes to other modules in the same network
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::sendData(struct packetXSC* packet)
{
  uint8_t error=2;

	error=setCommandMode();
	error=getSourceMacHigh();
	error=getSourceMacLow();
	error=exitCommandMode();
	packet->sourceMacHigh[0]=sourceMacHigh[0];
	packet->sourceMacHigh[1]=sourceMacHigh[1];
	packet->sourceMacLow[0]=sourceMacLow[0];
	packet->sourceMacLow[1]=sourceMacLow[1];

	// Enviamos los datos
	XBee.print(packet->sourceMacHigh[0],HEX);
	XBee.print(packet->sourceMacHigh[1],HEX);
	XBee.print(packet->sourceMacLow[0],HEX);
	XBee.print(packet->sourceMacLow[1],HEX);	
	XBee.print("-");
	XBee.print(packet->data_length,DEC);
	XBee.print("-");
	for(it=0;it<packet->data_length;it++)
	{
		XBee.print(packet->data[it],BYTE);
	}
	error=0;
	return error;
}

/*
 Function: Read incoming data via RF
 Returns: Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::readData(struct packetXSC* packet)
{
  uint8_t error=2;
  uint8_t end=0;  
  uint16_t interval=2000;
  long previous=millis();
  uint8_t counter3=0;
  uint8_t trama=0;
  uint8_t length=0;
  uint8_t dataIN[110];

  	for(int i=0;i<110;i++) dataIN[i]=0;
	previous=millis();
	while(end==0)
	{
		if(XBee.available()>0)
		{
			previous=millis();
			dataIN[counter3]=XBee.read();
			counter3++;
		}
		
		if( (millis()-previous) > interval )
		{
			end=1;
			XBee.flush();
		} 
		
	}
	end=0;
	if(dataIN[0]==10) end=1;
	if( dataIN[8+end]!='-' ) return 1;
	packet->sourceMacHigh[0]=converter(dataIN[0+end],dataIN[1+end]);
	packet->sourceMacHigh[1]=converter(dataIN[2+end],dataIN[3+end]);
	packet->sourceMacLow[0]=converter(dataIN[4+end],dataIN[5+end]);
	packet->sourceMacLow[1]=converter(dataIN[6+end],dataIN[7+end]);
	it=9;
	while(dataIN[it]!='-')
	{
		length++;
		it++;
	}
	switch(length)
	{
		case 1: packet->data_length=converter(dataIN[9]);
			break;
		case 2:	packet->data_length=converter(dataIN[9],dataIN[10]);
			break;
		case 3:	packet->data_length=converter(dataIN[9],dataIN[10],dataIN[11]);
			break;
	}
	packet->data_length=Utils.dec2hex(packet->data_length);
	it=0;
	for(it=0;it<packet->data_length;it++)
	{
		packet->data[it]=char(dataIN[it+10+length]);
	}
	return 0;
}


/*
 Function: Transparent function. The user uint8_troduces an AT command within a string and the function executes it without knowing its meaning
 Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
 Parameters:
  atcommand : String to specify the AT command to execute
*/
uint8_t WaspXBeeXSC::sendCommandAT(char* atcommand)
{
	uint8_t error=1;
	uint8_t i=0;

	clean();
	XBee.print("at");
	while( *atcommand!='#' )
	{
		XBee.print(*atcommand++,BYTE);
	}
	XBee.println("");
	delay(1000);
	while(XBee.available() > 0) 
	{
		commandAT[i]=XBee.read();
		i++;
		error=0;
	}
	return error;
}


/*
 Function: Connect XBee, activating switch in Waspmote
 Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::ON()
{
	uint8_t error=2;
	XBee.begin();
	XBee.setMode(XBEE_ON);
	delay(50);
	clean();
	error=0;
	return error;
}


/*
 Function: Set XBee to sleep, asserting PIN 9
 Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::sleep()
{
	uint8_t error=2;
	pinMode(XBEE_SLEEP, OUTPUT);
	digitalWrite(XBEE_SLEEP,HIGH); 
	XBee.close();
	error=0;
	return error;
}


/*
 Function: Wake up XBee, de-asserting PIN 9
 Returns: Integer that determines if there has been any error 
   error=2 --> The command has not been executed
   error=1 --> There has been an error while executing the command
   error=0 --> The command has been executed with no errors
*/
uint8_t WaspXBeeXSC::wake()
{
	uint8_t error=2;
	pinMode(XBEE_SLEEP, OUTPUT);
	digitalWrite(XBEE_SLEEP,LOW); 
	XBee.begin();
	delay(50);
	clean();
	error=0;
	return error;
}


/*
 Function: Generates a decimal number from an ASCII character which was a number
 Returns: The generated number
*/
uint8_t WaspXBeeXSC::converter(uint8_t conv1)
{
  uint8_t aux=0;
  uint8_t resul=0;

	switch(conv1)
	{
		case 48: aux=0;
			 break;
		case 49: aux=1;
			 break;
		case 50: aux=2;
			 break;
		case 51: aux=3;
			 break;
		case 52: aux=4;
			 break;
		case 53: aux=5;
			 break;
		case 54: aux=6;
			 break;
		case 55: aux=7;
			 break;
		case 56: aux=8;
			 break;
		case 57: aux=9;
			 break;
	}
	resul=aux;
	return resul;
}


/*
 Function: Generates a decimal number from two ASCII characters which were numbers
 Returns: The generated number
*/
uint8_t WaspXBeeXSC::converter(uint8_t conv1, uint8_t conv2)
{
  uint8_t aux=0;
  uint8_t aux2=0;
  uint8_t resul=0;

	switch(conv1)
	{
		case 48: aux=0;
			 break;
		case 49: aux=1;
			 break;
		case 50: aux=2;
			 break;
		case 51: aux=3;
			 break;
		case 52: aux=4;
			 break;
		case 53: aux=5;
			 break;
		case 54: aux=6;
			 break;
		case 55: aux=7;
			 break;
		case 56: aux=8;
			 break;
		case 57: aux=9;
			 break;
		case 65: aux=10;
			 break;
		case 66: aux=11;
			 break;
		case 67: aux=12;
			 break;
		case 68: aux=13;
			 break;
		case 69: aux=14;
			 break;
		case 70: aux=15;
			 break;
	}
	switch(conv2)
	{
		case 48: aux2=0;
			 break;
		case 49: aux2=1;
			 break;
		case 50: aux2=2;
			 break;
		case 51: aux2=3;
			 break;
		case 52: aux2=4;
			 break;
		case 53: aux2=5;
			 break;
		case 54: aux2=6;
			 break;
		case 55: aux2=7;
			 break;
		case 56: aux2=8;
			 break;
		case 57: aux2=9;
			 break;
		case 65: aux2=10;
			 break;
		case 66: aux2=11;
			 break;
		case 67: aux2=12;
			 break;
		case 68: aux2=13;
			 break;
		case 69: aux2=14;
			 break;
		case 70: aux2=15;
			 break;
		default: aux2=100;
			 break;
	}
	if(aux2==100) // Only one character but we have treated two, so We have to fix it
	{
		resul=aux;
	}
	else
	{
		resul=(aux*16)+aux2;
	}
	return resul;
}

/*
 Function: Generates a decimal number from three ASCII characters which were numbers
 Returns: The generated number
*/
uint8_t WaspXBeeXSC::converter(uint8_t conv1, uint8_t conv2, uint8_t conv3)
{
  uint8_t aux=0;
  uint8_t aux2=0;
  uint8_t aux3=0;
  uint8_t resul=0;

	switch(conv1)
	{
		case 48: aux=0;
			 break;
		case 49: aux=1;
			 break;
		case 50: aux=2;
			 break;
		case 51: aux=3;
			 break;
		case 52: aux=4;
			 break;
		case 53: aux=5;
			 break;
		case 54: aux=6;
			 break;
		case 55: aux=7;
			 break;
		case 56: aux=8;
			 break;
		case 57: aux=9;
			 break;
	}
	switch(conv2)
	{
		case 48: aux2=0;
			 break;
		case 49: aux2=1;
			 break;
		case 50: aux2=2;
			 break;
		case 51: aux2=3;
			 break;
		case 52: aux2=4;
			 break;
		case 53: aux2=5;
			 break;
		case 54: aux2=6;
			 break;
		case 55: aux2=7;
			 break;
		case 56: aux2=8;
			 break;
		case 57: aux2=9;
			 break;
	}
	switch(conv3)
	{
		case 48: aux3=0;
			 break;
		case 49: aux3=1;
			 break;
		case 50: aux3=2;
			 break;
		case 51: aux3=3;
			 break;
		case 52: aux3=4;
			 break;
		case 53: aux3=5;
			 break;
		case 54: aux3=6;
			 break;
		case 55: aux3=7;
			 break;
		case 56: aux3=8;
			 break;
		case 57: aux3=9;
			 break;
	}
	resul=aux3*100+aux2*10+aux;
	return resul;
}

void WaspXBeeXSC::clean()
{
	uint8_t ByteIN=0;
	
	while(XBee.available() > 0) 
	{
		ByteIN = XBee.read();
	}
}

uint8_t WaspXBeeXSC::check()
{
	uint8_t ByteIN[10];
	uint8_t error=0;
	uint8_t i=0;
	uint8_t	counter=0;
	long previous=0;
	uint8_t end=0;
	long interval=1000;
	
	previous=millis();
	while(end==0)
	{
		if(XBee.available()>0)
		{
			ByteIN[i]=XBee.read();
			i++;
			previous=millis();
		}
		if( (millis()-previous) > interval )
		{
			end=1;
			XBee.flush();
		} 
	}
	counter=i;
	i=0;
	while(counter>i)
	{
		if(ByteIN[i]=='O')
		{
			if(ByteIN[i+1]=='K')
			{
				return 0;
			}
		}
		i++;		
	}
	return 1;
}

WaspXBeeXSC	xbeeXSC = WaspXBeeXSC();