//Definición de variables

#include <xc.h>

#include "XBeeAPI.h"

#include <stdio.h>

#include <plib/usart.h>

#include "Glaube.h"

#define _XTAL_FREQ 32000000

unsigned int Length;

unsigned char ApiID;

unsigned char ApiOp;

unsigned char Pmtr[32];

unsigned char AT_Resp=0xFF;

//VARIABLES GLOBALES

unsigned char BufferRxUART[127];

unsigned char FlagPaqRx2=0;

unsigned char iRx1XBAPI=0;

unsigned int PaqXBAPILen=0;

unsigned int NoPaqXBAPI=0;

void UART_XBeeAPI_ISR(void)

{

BufferRxUART[iRx1XBAPI] = Read2USART();

if (iRx1XBAPI == 2) // Se recive suficiente información para determinar la longitud del paquete

if (BufferRxUART[0] == XBAPI_StrDel) //Identificacion de un paquete API XBee

PaqXBAPILen = Make16(BufferRxUART[1], BufferRxUART[2]); //Se obtiene la longitud del paquete esperado

//Terminación por longitud de paquete esperado

if (iRx1XBAPI >= PaqXBAPILen + 3) //Si se ha alcanzado el final del paquete esperado

{

iRx1XBAPI = 0; //Se cierra el paquete

NoPaqXBAPI++; //Se aumenta el contador de paquetes recividos

FlagPaqRx2 = 1; //Se habilita bandera de nuevo paquete

//PIR3bits.RC2IF = 0; //Experimental

//NewPackUART(PaqXBAPILen); //PaqXBAPILen = Longitud de paquete - Start Delimiter - Length Bytes - Check Sum

//FlagBufferRx1Full=0; //Se deshabilita bandera de buffer Rx lleno

return ;

}

iRx1XBAPI++;

//PIR3bits.RC2IF = 0; // clear rx flag

}

void XBAPI_Tx(unsigned char Data[], unsigned char Length, unsigned char FrameID,unsigned char FrameOp,unsigned char GB_ID, unsigned char AdrsAdressat[], unsigned char AdrsHerkunft[], unsigned char AdrsReiseziel[])

{

unsigned char BufferTxXBAPI[XBAPI_BuffLen];

Length+=17; //Ajuste de longitud por direcciones y Glaube Options

BufferTxXBAPI[0]=0x7E;

BufferTxXBAPI[1]=0x00; // La longitud no supera 255 bytes

BufferTxXBAPI[2]=Length+11; //Longitud de los datos Data Length+11 (Address Length + API ID Len+FrameID Len+ Option Len)

BufferTxXBAPI[3]=0x00; //Identificador de envio para direccion de 64 Bits... Pag 61.

BufferTxXBAPI[4]=FrameID;

BufferTxXBAPI[13]=FrameOp; //Options

BufferTxXBAPI[30]=GB_ID;

for(unsigned char i=0;i<=7;i++)

{

BufferTxXBAPI[i+5]=AdrsAdressat[i]; //Direccion destino inmediato

BufferTxXBAPI[i+14]=AdrsHerkunft[i]; //Direccion de origen

BufferTxXBAPI[i+22]=AdrsReiseziel[i]; //Direccion de destino final

}

for(unsigned char i=0;i<=Length;i++)

{

//BufferTxXBAPI[i+30]=Data[i];

BufferTxXBAPI[i+31]=Data[i];

}

//CheckSum

//BufferTxXBAPI[26]=0xF2;

BufferTxXBAPI[Length+14]=ChecksumGen(BufferTxXBAPI);

for(unsigned char i=0;i<=Length+14;i++)

{

while(!TXSTA2bits.TRMT);

//Write1USART(BufferTx[i]);

Write2USART(BufferTxXBAPI[i]);

}

}

int Make16 (char MSB, char LSB)

{

int Maked16=0;

Maked16=(MSB<<8)+LSB;

return Maked16;

}

char Make8(int Var, int NoByte)

{

//Función para separar una variable de 16 bits en dos de 8 bits

//Var= Variable de 16 bits a ser separada

//NoByte = 1,2 Selecciona el byte que será retornado, 1=MSB, 2=LSB

unsigned char Maked8=0;

if(NoByte==2)

Maked8=Var & 0xFF;

if(NoByte==1)

Maked8=Var>>8;

return Maked8;

}

void Setup_USART1XBAPI()

{

//Declaración de Variables

unsigned char USART1Config=0;

unsigned int BaudRate=0;

TRISCbits.RC6=0; //TX es salida

TRISCbits.RC7=1; //RX es entrada

//Configuración USART

USART1Config=USART_TX_INT_OFF //Interrupcion por Ttransmisión: Off

&USART_RX_INT_OFF //Interrupcion por Recepción: Off

&USART_ASYNCH_MODE //Modo Asíncrono

&USART_EIGHT_BIT //Transmision de 8bits

&USART_CONT_RX //Recepción Continua

&USART_BRGH_HIGH //Baudios

&USART_ADDEN_OFF; //Detección de Dirección OFF

BaudRate=51; //Valor que se carga a SPRBH para Definir BaudRate = 9600

Close1USART(); //Cierra USART2 en caso de estar previamente abierto.

Open1USART(USART1Config, BaudRate); //Abre USART1

IPR1bits.RC1IP =1; //Receive Interrupt: High Priority

PIE1bits.RC1IE=1; //Receive Interrupt: Enabled

PIR1bits.RC1IF=0; //Reset de EUSART2 Receive Interrupt Flag

}

void putch(char data)

{

while(!TX2IF)

continue;

TXREG2 = data;

//

// while(!TX1IF)

// continue;

// TXREG1 = data;

}

char ChecksumGen(unsigned char Frame[])

{

int Checksum=0,IndS=0,Len;

unsigned int Sum=0;

Len=Make16(Frame[1],Frame[2]);

for(IndS=3;IndS<=Len+2;IndS++) //Checksum comienza despues de longitud y hasta el final.

{

Sum=Sum+Frame[IndS];

}

Checksum=Sum & 0xFF;

Checksum=0xFF-Sum;

return Checksum;

}

void Setup_USART2XBAPI()

{

//Declaración de Variables

unsigned char USART2Config=0;

unsigned int BaudRate=0;

TRISBbits.RB6=0; //TX es salida //cambiar estos son de USAR1

TRISBbits.RB7=1; //RX es entrada

//Configuración USART

USART2Config=USART_TX_INT_OFF //Interrupcion por Ttransmisión: Off

&USART_RX_INT_OFF //Interrupcion por Recepción: Off

&USART_ASYNCH_MODE //Modo Asíncrono

&USART_EIGHT_BIT //Transmision de 8bits

&USART_CONT_RX //Recepción Continua

&USART_BRGH_HIGH //Baudios

&USART_ADDEN_OFF; //Detección de Dirección OFF

//BaudRate=51; //Valor que se carga a SPRBH para Definir BaudRate = 9600

//BaudRate=25; //19200 8 mHZ

//BaudRate=103; //19200 32 mHz

BaudRate=51; //38400 32 MHz

Close2USART(); //Cierra USART2 en caso de estar previamente abierto.

Open2USART(USART2Config, BaudRate); //Abre USART2

IPR3bits.RC2IP=1; //Receive Interrupt: High Priority

PIE3bits.RC2IE=1; //Receive Interrupt: Enabled

PIR3bits.RC2IF=0; //Reset de EUSART2 Receive Interrupt Flag

}

void XBAPI_ATtx(unsigned char Length, unsigned char FrID, unsigned char AT1,unsigned char AT2,unsigned char Parameter[])

{

unsigned char BufferTxXBAPI[40];

BufferTxXBAPI[0]=0x7E;

BufferTxXBAPI[1]=0x00;

BufferTxXBAPI[2]=Length;

BufferTxXBAPI[3]=0x08;

BufferTxXBAPI[4]=FrID;

BufferTxXBAPI[5]=AT1;

BufferTxXBAPI[6]=AT2;

for(unsigned char i=0;i<Length-4;i++)

BufferTxXBAPI[7+i]=Parameter[i];

BufferTxXBAPI[Length+3]=ChecksumGen(BufferTxXBAPI);

for(unsigned char i=0;i<=Length+3;i++)

{

while(!TXSTA2bits.TRMT);

Write2USART(BufferTxXBAPI[i]);

}

}

void XBAPI_ATrx(unsigned char Daten[])

{

if (Daten[5]==0x53 && Daten[6]==0x48)

{

for(unsigned char i=0;i<=4;i++)

AdrsMyAdrs[i]=Daten[i+8];

XBAPI_Tx(AdrsMyAdrs,8,0x01,0x01,0x10,AdrsP2P,AdrsDummy,AdrsDummy); //Auxiliar

AT_Resp=0;

}

if (Daten[5]==0x53 && Daten[6]==0x4C)

{

for(unsigned char i=0;i<=4;i++)

AdrsMyAdrs[i+4]=Daten[i+8];

XBAPI_Tx(AdrsMyAdrs,8,0x01,0x01,0x10,AdrsP2P,AdrsDummy,AdrsDummy); //Auxiliar

AT_Resp=0;

}

if(Daten[5]==0x49 && Daten[6]==0x44)

{

if(Daten[7]==0x00)

{

AT_Resp=0;

}

}

if(Daten[5]==0x4B && Daten[6]==0x59)

{

if(Daten[7]==0x00)

{

AT_Resp=0;

}

}

if(Daten[5]==0x45 && Daten[6]==0x45)

{

if(Daten[7]==0x00)

{

AT_Resp=0;

}

}

if(Daten[5]==0x43 && Daten[6]==0x48)

{

if(Daten[7]==0x00)

{

AT_Resp=0;

}

}

if(Daten[5]==0x46 && Daten[6]==0x52)

{

if(Daten[7]==0x00)

{

AT_Resp=0;

}

}

if(Daten[5]==0x57 && Daten[6]==0x52)

{

if(Daten[7]==0x00)

{

AT_Resp=0;

}

}

}

void XBAPI_MdmSts(unsigned char Daten[])

{

if (Daten[4]==0x01)

{

AT_Resp=0x00;

}

}

void XBAPI_Melken(unsigned char Data[],char *AdrsAbsender, char *AdrsReiseziel, char *AdrsHerkunft, char *RSSI, char *ApiID, char *ApiOp, int *Length)

{

*Length=Make16(Data[1],Data[2]);

*ApiID=Data[3];

*RSSI=Data[12];

*ApiOp=Data[13];

for(unsigned char i=0;i<8;i++)

{

AdrsAbsender[i]=Data[i+4];

AdrsHerkunft[i]=Data[i+14];

AdrsReiseziel[i]=Data[i+22];

}

}

void DelayNms(unsigned int Ciclos)

{

for(unsigned int i=0;i<Ciclos;i++)

__delay_ms(10);

}

void NewPackUART(unsigned int RxLen)

{

if(BufferRxUART[3] == 0x80) //Paquete Rx normal

{

GB_Melken(BufferRxUART,RxLen);

}

if(BufferRxUART[3] == 0x88) //Respuesta comando AT

{

XBAPI_ATrx(BufferRxUART);

}

if(BufferRxUART[3]==0x8A)

{

XBAPI_MdmSts(BufferRxUART);

}

}

void GetMyAdrs(void)

{

XBAPI_ATtx(0x04,0x01,'S','H',Pmtr);

Wait4AT_Resp(0x00);

//DelayNms(500);

XBAPI_ATtx(0x04,0x01,'S','L',Pmtr);

//DelayNms(500);

Wait4AT_Resp(0x00);

}

void XB_Reset(void)

{

XBAPI_ATtx(0x04,0x01,'F','R',Pmtr);

Wait4AT_Resp(0x00);

}

void SetPAN_ID(unsigned char PAN_ID[])

{

XBAPI_ATtx(0x06,0x01,'I','D',PAN_ID);

Wait4AT_Resp(0x00);

}

void Wait4AT_Resp(unsigned char Resp)

{

unsigned char Del4Ans=0;

while(1)

{

if(FlagPaqRx2==1)

{

NewPackUART(0x00);

FlagPaqRx2=0;

}

if(AT_Resp==Resp)

{

AT_Resp=0xFF;

break;

}

if(Del4Ans==100)

{

AT_Resp=0xEE;

break;

}

DelayNms(30);

Del4Ans++;

}

}

void SetAES_Key(unsigned char Key[])

{

XBAPI_ATtx(0x14,0x01,'K','Y',Key);

Wait4AT_Resp(0x00);

}

void AES_EE(unsigned char En)

{

unsigned char Aux[1];

Aux[0]=En;

XBAPI_ATtx(0x05,0x01,'E','E',Aux);

Wait4AT_Resp(0x00);

}

void SetCH(unsigned char CH[])

{

XBAPI_ATtx(0x05,0x01,'C','H',CH);

Wait4AT_Resp(0x00);

}

void XBAPI_WR(void)

{

XBAPI_ATtx(0x04,0x01,'W','R',Pmtr);

Wait4AT_Resp(0x00);

}