Xbee Api + Pic18f2620 si blocca in DataRdyUSART()

[alvangelo]

Ciao a tutti!!
Sono nuovo del forum.
Se qualcuno di voi ha qualche minuto da dedicarmi avrei un problemino da risolvere che mi sta facendo uscire pazzo....
In questi mesi ho sviluppato un'applicazione per pic18f2620 con XBee serie 2 scritta in C18 mediante MPLAB.
La mia applicazione di monitoraggio ambientale funziona alla perfezione utilizzando il metodo di lettura e di settaggio dei parametri COMMAND MODE (scrivo "+ + +", "ATNI", "ATDH", "ATDL" .... ecc) e sono in grado di leggere (o settare) perfettamente i parametri di funzionamento del modulo Xbee salvandoli su variabili settate sul microcontrollore.

Quando però inizio ad utilizzare frame "Xbee API" il microcontrollore rimane bloccato ", while(DataRdyUSART ())"..
Il modulo Xbee in pratica è come se non rispondesse al comando API che ho appena inviato..

Per esempio se io mando il seguente array di caratteri
"CArray [] = (0×7E, 0×00, 0×04, 0×08, 0×01, 0×6e, 0×69, 0×1f);"
Vorrei leggere il parametro NODE IDENITFIER dal dispositivo Xbee ma non ricevo nulla ...
DataRdyUSART () Non riceve nulla.

La cosa che mi sta facendo impazzire è proprio il fatto che utilizzando comandi AT il programma funziona alla perfezione... Gli interrupt , i WDt... tutto va bene.
Appena invio una semplicissima frame API si pianta e non riceve nulla....
Ho provato ad inviare la stessa frame API mediante XCTU e mi sono accorto che effettivamente è corretta in quanto ricevo una frame di risposta contenente i parametri che ho impostato.
Qualcuno di voi saprebbe dirmi il perchè??

[GuyCoast]

Ciao e benvenuto, ora non ricordo bene, ma il modulo xbee per funzionare con le API deve essere settanto in quella modalita' attraverso xctu o l'apposito comando AT, prima di poter ricevere i comandi.

[alvangelo]

Io ho già settato il modulo in modalità api (AP=1)...
Il problema è che il pic sembra non ricevere nulla dal modulo radio dopo aver inviato una frame API corretta...

[GuyCoast]

Potrebbe essere un problema del buffer di ricezione, prova testare il bit overrun error (OERR), nel caso devi implementare un buffer di ricezione nel software.

[alvangelo]

Salve, ho controllato il valore del registro OERR tramite RCSTA ed ho visto (tramite pickit3 debugger) che quando il programma si blocca RCSTA=0x9A. Quindi la maschera in binario vale "10011010". In effetti quindi c'è un Over Run Error.... ma come posso evitarlo???
Allego una prozione del codice per render meglio l'idea delle routines che sto effettuando per tentare di leggere il parametro NODE IDENTIFIER dal modulo Xbee:

unsigned char readParam (unsigned char DeviceType) 
{

	unsigned char k = 0;
	unsigned char i = 0;
	unsigned char ind = 0;
	unsigned char checksum = 0;
	unsigned char read_at_param32[4];


	SLEEPZB = 1; 			//LATAbits.LATA5=1
	Delay10KTCYx(20);
	SLEEPZB = 0;
	Delay10KTCYx(20);
	LED2 = 0;

	Delay10KTCYx(ATGUARDTIME);

	LED2 = 1;


	if ((DeviceType == 0) || (DeviceType == 1) || (DeviceType == 2))   	
	{
		unsigned char cArray[]={0x7e, 0x00, 0x04, 0x08, 0x01, 0x6e, 0x69, 0x1f};
		for( ind=0; ind<8; ind++ )
		{
			while(BusyUSART());
			WriteUSART(cArray[ind]);
			while(BusyUSART());
		}
		k=0;
		do
		{ 
			
			if (AttesaRxUART(TIMEOUT) != 0) return 99;
		    tempChar = ReadUSART();
			buffer[k] = tempChar;
			k++;
		}while((k<12));

		if (buffer[7] == 1) 
		{
			LED2 = 1;
			return 6;
		}

		read_at_param32[0]=buffer[7];
		read_at_param32[1]=buffer[8];
		read_at_param32[2]=buffer[9];
		read_at_param32[3]=buffer[10];
		strcpy(ParamNet.NI,read_at_param32);

		LED2 = !LED2;
	}
}
	
unsigned char AttesaRxUART(unsigned int timeoutRX)
{

	postTimerTMT1 = 0; 
	postTimerSENS = 0;
	postTimerSEND_DATA = 0;
	//postTimerBeacon = 0;
	PIE1bits.TMR1IE = 1;

	while (!DataRdyUSART())
	{
		postTimerSENS = 0;
		postTimerSEND_DATA = 0;
		//postTimerBeacon = 0;
		
		if (postTimerTMT1 >= (timeoutRX*4)) 
		{
			PIE1bits.TMR1IE = 0;
			return 2;
		}
	}

	PIE1bits.TMR1IE = 0;

	return 0;

}

[GuyCoast]

Ciao, devi creare un buffer di ricezione, utilizzando l'interrupt dell'uart in ricezione.

Ora ho poco tempo, se hai la pazienza di aspettare, piu' tardi ti posto il codice che utilizzo io, anche se è in c30 penso sia facilmente adattabile al C18.

[GuyCoast]

#define Rx_BufferSize 32                //definisce dimensione buffer in 32 byte

//definizioni variabili
unsigned char U1RxBuff[Rx_BufferSize];    // buffer seriale
unsigned char U1RxPtrIn = 0;            // indice bytes in ingresso catturati dall'interrupt
unsigned char U1RxPtrOut = 0;            // indice byte in uscita letti dalla routine seriale


void     _UARTRXInterrupt(void)            // UART RX interrupt
{
    _U1RXIF = 0;                         // interrupt flag reset    
    
    U1RxBuff[U1RxPtrIn] = ReadUART();    // legge il byte presente nella seriale. ReadUART() routine presente nella libreria C18
    U1RxPtrIn ++;                        // avanza di un byte
    if (U1RxPtrIn >= Rx_BufferSize)
        U1RxPtrIn = 0;                    //se l'indice arriva al termine del buffer azzera e riparte dll'inizio     
}


unsigned char BuffReadU1(void)            //Routine che restituisce il primo byte memorizzato nel buffer
{
       unsigned char c = 0;
           
    c = U1RxBuff[U1RxPtrOut];        //Legge il buffer e mette il byte nella variabile c
    ++U1RxPtrOut;                    //avanza l'indice di un byte

    if (U1RxPtrOut >= Rx_BufferSize)    //Controlla la fine del buffer 
        U1RxPtrOut = 0;
    
     return (c);                           //restituisce il byte letto
}


void UartRX(void)                        //Routine di ricezione seriale principale 
{ 
    if(U1RxPtrIn != U1RxPtrOut)         //Controlla se gli indici sono diversi sono presenti nuovi dati nel buffer
        data  = BuffReadU1();            //legge il byte e lo mette nella variabile utente
                 
}

Ecco il codice semplificato della routine del buffer, come dicevo prima, va riadattata al tuo codice, ma il concetto è lo stesso.
I dati ricevuti dall' uart vengono memorizzati nel buffer a scorrimento attraverso l'interrupt di ricezione.
Successivamente vengono prelevati dalla routine dell'utente da dentro il buffer, che intanto potra' memorizzare altri dati.
Il buffer è circolare, nel senso che quando arriva al termine, viene azzerato e riparte dell'inizio.

Ciao
Guido

[alvangelo]

Grazie mille per il consiglio!!
Avevo già risolto andando ad azzerare i registri ogni qualvolta mi salvavo un carattere ricevuto sulla seriale. Adesso provo pure ad adattare la tua soluzione.
Grazie!