Comunicación: Envio de datos por medio del protocolo Zig-Bee

En los desarrollos de robótica que se llevan a cabo dentro del grupo RSR de la Universidad Nacional, surge la necesidad de enviar información entre un equipo integrado con una tarjeta de desarrollo Arduino, y un computador con una interfáz realizada en Java. Esta comunicacion se realiza por medio de los módulos XBee los cuales trabajan con el protocolo Zig-Bee.

En el estudio de la información de estos módulos, observamos que la manera de enviar datos por medio de este protocolo, es a través de paquetes de bytes. Pero el inconveniente que se ha presentado es que para enviar estos datos, es necesario tomar el valor que esta almacenado en una determinada cantidad de bytes y enviarla partionada en valores de un byte.

Para empezar con la solución de un problema de estos, partimos primero con un algoritmo básico con el arduino que nos permitirá identificar la manera en que estos valores pofrán ser particionados. Pero es de vital importancia conocer los operadores de bits que vienen integrados con el lenguaje C, lenguaje en el cual se desarrollan los algoritmos para el arduino.

El código que se empleará será el siguiente:

//valor que se usar para ser particionado en valores de un solo Byte
long a = -1992;
//arreglo de valores donde estaran contenidos las unidade de Byte del valor

uint8_t b[4];

void setup(){
  //establecemos una comunicacion serial con una velocidad de 9600
 Serial.begin(9600);
}

void loop(){
  b[0] = (a >> 24) & 0xff;
  b[1] = (a >> 16) & 0xff;
  b[2] = (a >> 8) & 0xff;
  b[3] = (a >> 0) & 0xff;

  for(int i = 0;  i < 4; i++){
    Serial.print(b[i]);
    Serial.print("\t");
  }
  Serial.println();

  delay(100);
}

Éste código permite visualizar por medio de alguna terminal (para el caso puede ser la terminal que viene integrada con el Arduino), los valores particionados. Nótese que se emplearon algunos operadores a nivel de bytes como lo son & y <<. Una explicacion detallada de estos operadores para particionar los datos se expondrá en otra entrada.
 
El valor escogido a nivel de bits fué -1992. Por medio de un programa sencillo en java*, se pudo obtener los bits que se asocian con este valor:

11111111111111111111100000111000

Luego, los valores para el arreglo "b" en el programa son los siguientes (son los valores que se imprimieron en la terminal desde el arduino cargado con el código anterior):

b[0]= 255 (binario: 11111111)

b[1]= 255 (binario: 11111111)

b[2]= 248 (binario: 11111000)

b[3]= 56 (binario: 00111000)
 
De esta manera, el valor "a" en el código se pudo particionar en valores de de 1 byte.

Una vez ontenido este resultado, procedemos adaptar el código para ser enviado por medio del módulo XBee conectado por medio de los puertos rx-tx de la tarjeta Arduino (Cabe resaltar que es necesario añadir la libreria XBee para el Arduino IDE):

#include <XBee.h>

//Comunicacion
//ZIG-BEE: Direccion de 64 bits (Direccion del Coordinador)
XBeeAddress64 addr64 = XBeeAddress64(0x00000000, 0x00000000);
//ZIG-BEE: direccion de 16 bits
uint16_t addr16 = 0xFFFE;

//Paquete de datos a enviar
uint8_t payload[6];

XBee xbee = XBee();

//ZIG-BEE: Envio de datos
ZBTxRequest zbTx = ZBTxRequest(addr64, addr16, 0x00, 0x01, payload, sizeof(payload), 0x01);
//ZIG-BEE: Recepcion de datos
XBeeResponse response = XBeeResponse();
ZBRxResponse rx = ZBRxResponse();

long a = -1992;

void setup(){
  // Iniciar la comunicación serial.
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop(){

  digitalWrite(13, HIGH);

  //uint32_t luz2 = (uint32_t)(luz*100);
  payload[0] = 0xFE;
  //byte que indica la cantidad de datos que se envairan fragmentados
  payload[1] = 0x01;
  payload[2] = a >> 24 & 0xff;
  payload[3] = a >> 16 & 0xff;
  payload[4] = a >> 8 & 0xff;
  payload[5] = a & 0xff;
  xbee.send(zbTx);
  digitalWrite(13, LOW);
  delay(100);
}

EL valor "payload[1]", se usa para indicarle al programa que se enviarán valores con particiones de 4 bytes. El siguiente dato, "payload[2]", que tiene valor hexadecimal 0x01, inicará al programa que se enviará un solo dato particionado.

Una vez se carga el código a la tarjeta, podemos enviar nuestros valores particionados. Ahora solo resta que nuestro programa, el cual se desarrollará en Java, pueda tomar el valor que se particionó, y unirlo de nuevo para manipularlo. La forma en la que se volveran a unir esta información, por medio de un programa en Java se expondrá por aparte.

*El programa que se empleó en Java para obtener el valor en bits, se hizo con dos simples líneas:

int a = -1992;
System.out.println(Integer.toBinaryString(a));

SI hay algo que no se entienda, por favor decirlo para mejorar la redacción.