| View previous topic :: View next topic |
| Author |
Message |
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
| Problem with Interruption INT_RDA |
 Posted: Tue Jan 28, 2014 1:55 pm |
 |
|
Hello everybody, i´m making a project about INMOTIC, using XBEE, JAVA and USB.
JAVA. I used netbeans to program my interface and i had already connect with the pic. (USB connection)
I have a problem with the serial interrupt, i need to save a char which is sended by another XBEE module. In this case the char is 0x05. but when The XBEE who is hook up to the pic receive a data the INTERRUPTION does not anything... im going to paste my code below.. PLEASE HELp me
| Code: |
#include <18F4550.h>
#fuses XTPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN, MCLR
#use delay(clock=48000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)
#define USB_HID_DEVICE FALSE // deshabilitamos el uso de las directivas HID
#define USB_EP1_TX_ENABLE USB_ENABLE_BULK // turn on EP1(EndPoint1) for IN bulk/interrupt transfers
//(activacion de traferencia masiva en USB configurando el EndPoint 1 de transmision)
#define USB_EP1_RX_ENABLE USB_ENABLE_BULK // turn on EP1(EndPoint1) for OUT bulk/interrupt transfers
//(activacion de traferencia masiva en USB configurando el EndPoint 1 de recepcion)
#define USB_EP1_TX_SIZE 32 // size to allocate for the tx endpoint 1 buffer
//(tamaño del buffer de transferencia en la transmision entre 1 y 32 bytes para USB 2.0)
#define USB_EP1_RX_SIZE 32 // size to allocate for the rx endpoint 1 buffer
//(tamaño del buffer de transferencia en la recepcion entre 1 y 32 bytes para USB 2.0)
//#define EEPROM_SDA PIN_B1
//#define EEPROM_SCL PIN_B0
#include <pic18_usb.h> // Microchip PIC18Fxx5x Hardware layer for CCS's PIC USB driver
#include "header.h" // Configuración del USB y los descriptores para este dispositivo
#include <usb.c> // handles usb setup tokens and get descriptor reports
//#include "24256.c"
#define LED_ON(x) output_high(x)
#define LED_OFF(x) output_low(x)
#define ledR PIN_B1
#define ledV PIN_B0
BYTE numeroDeDispositivos=0;//inicialmente no hay dispositivos conectados
short correcto=FALSE; //indica resultado de la suma de control
BYTE recepcionXbee[50]; //almacenamiento de las recepciones
BYTE auxRecepXbee[100]; //auxiliar para el almacenamiento de las recepciones
BYTE sumaDeControl=0; //resultado de la suma de control
////////////////////////////////////////////
// Direccion de envio XBEE
//7E 00 12 10 01 00 13 A2 00 40 A1 21 F8 CB 97 00 00 48 4F 4C 41 9B
#define startbit 0X7E
#define tamamin 0x00
#define tamamax 0x12
#define frametype 0x10
#define frameid 0x01
#define bitMsb64dir 0x00
#define bit1_64dir 0x13
#define bit2_64dir 0xA2
#define bit3_64dir 0x00
#define bit4_64dir 0x40
#define bit5_64dir 0xA1
#define bit6_64dir 0x21
#define bitLsb64dir 0xF8
#define bitMsb16dir 0xCB
#define bitLsb16dir 0x97
#define broadcast_radius 0x00
#define options 0x00
#define rfdata1 0x48
#define rfdata2 0x4F
#define rfdata3 0x4C
#define rfdata4 0x41
#define checksum 0xFF - (frametype + frameid + bitMsb64dir + bit1_64dir + bit2_64dir + bit3_64dir + bit4_64dir + bit5_64dir + bit6_64dir + bitLsb64dir + bitMsb16dir + bitLsb16dir + broadcast_radius + options + rfdata1 + rfdata2 + rfdata3 + rfdata4)
////////////////////////////////////////////
//definiciones para tramas API
#define delimitador 0x7E
#define remotoAT 0x17
#define reconocimiento 0x01
#define dir16A 0xFF
#define dir16B 0xFE
#define aplicarcambio 0x02
#define sinconfig 0x00
#define eAnalogica 0x02
#define eDigital 0x03
#define Dbajo 0x04
#define Dalto 0x05
#define tamaPin 0x10
#define tamaConfig 0x0F
#define tamaND 0x04
#define comandoAT 0x08
#define atN 0x4E
#define atD 0x44
#define atW 0x57
#define atR 0x52
#define scND 0x64
#define atI 0x49
#define atS 0x53
#define idConfig 0x05
BYTE direcciones[55][8]; //lista de direcciones posibles
const int8 Lenbuf = 4;
int8 recbuf[Lenbuf];
char c;
BYTE prx=0;
BYTE i=0;
BYTE cuenta=0;
BYTE desbordaT1=0;
long intentos=0;
BYTE intentosB=0;
short comprobado=FALSE;
short tiempoAgotado=FALSE;
short recibi = FALSE;
short baje = FALSE;
#define intentosMAX 0x0A //numero máximo de intentos para ejecutar comando API
#define APICorrecto 0x00
#define APIERROR 0x01
#define APIComandoInvalido 0x02
#define APIParamtrInvalodo 0x03
#define APIFalloTransmision 0x04
/////////////////////////////////////////////////////////////////////////////
//
// If you are using a USB connection sense pin, define it here. If you are
// not using connection sense, comment out this line. Without connection
// sense you will not know if the device gets disconnected.
// (connection sense should look like this:
// 100k
// VBUS-----+----/\/\/\/\/\----- (I/O PIN ON PIC)
// |
// +----/\/\/\/\/\-----GND
// 100k
// (where VBUS is pin1 of the USB connector)
//
/////////////////////////////////////////////////////////////////////////////
///only the 18F4550 development kit has this pin
#define USB_CON_SENSE_PIN PIN_D0
/////////////////////////////////////////////////////////////////////////////
//
// Funciones encargadas de iniciar arrays a 0
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// limpiarAuxRecep
//
// se emplea para poner a 0 todos los elementos del array auxRecepXbee
/////////////////////////////////////////////////////////////////////////////
void limpiarAuxRecep(void)
{
int t=0;
do{auxRecepXbee[t++]=0;}while(t<=99);
}
/////////////////////////////////////////////////////////////////////////////
//
// limpiarRecepcion
//
// se emplea para poner a 0 todos los elementos del array recepcionXbee
/////////////////////////////////////////////////////////////////////////////
void limpiarRecepcion()
{
int t=0;
do {recepcionXbee[t++]=0;}while(t<=49);
prx=0;
}
/////////////////////////////////////////////////////////////////////////////
//
// limpiarDirecciones
//
// se emplea para poner a 0 todos los elementos del array direcciones
/////////////////////////////////////////////////////////////////////////////
void limpiarDirecciones()
{
int t=0;
int y=0;
for (t = 0 ; t < 45 ; t++)
for (y = 0 ; y < 8 ; y++){direcciones[t][y]=0;}
}
/////////////////////////////////////////////////////////////////////////////
//
// comprobacion
//
// subrutina encargada de comprobar la suma de control de una recepcion
// cuando sumaDeControl=sumaDeControl+recepcionXbee[3+j] la suma es correcta
// en caso afirmativo devuelve TRUE, de lo contrario devuelve FALSE
/////////////////////////////////////////////////////////////////////////////
short comprobacion()
{
int j=0;
sumaDeControl=0x00;
correcto=FALSE;
for (j=0;j<recepcionXbee[2];j++){sumaDeControl=sumaDeControl+recepcionXbee[3+j];}
sumaDeControl=0xFF-sumaDeControl;
if (sumaDeControl==recepcionXbee[recepcionXbee[2]+3])
{
correcto=TRUE;
return (correcto);
}
else
{
correcto=FALSE;
return (correcto);
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Manejo ND
//
// se encarga de comprobar que lo recibido tras el comando ND son tramas
// validas de los dispositivos de la red y almacena la dirección de estos
// Se almacena esta configuracion que será enviada en la subrutina
// envio_numero_dispositivo()
/////////////////////////////////////////////////////////////////////////////
void manejoND()
{
int x;
int h;
int k;
int l;
short resultado;
h=0;k=0;resultado=false;comprobado=false;//inicia las variables
limpiarRecepcion();
for (h=0;h<auxRecepXbee[2]+4;h++){recepcionXbee[h]=auxRecepXbee[h];} //se copia una trama completa
resultado=comprobacion();
if (resultado)
{
numeroDeDispositivos++;
x = recepcionXbee[19]-0x30;
for (k=0;k<8;k++){direcciones[x][k]=recepcionXbee[10+k];}//se almacena la direccion auxiliar
l=h;
while(auxRecepXbee[l]!=0)//si siguen habiendo tramas
{
x=0;
k=h;
l=k;
limpiarRecepcion();
for (h=0;h<auxRecepXbee[k+2]+4;h++)
{
recepcionXbee[h]=auxRecepXbee[l];//se copia la siguiente trama completa
l++;
}
resultado=false;
resultado=comprobacion();
if (resultado)
{
numeroDeDispositivos++;
x = recepcionXbee[19]-0x30;
for (k=0;k<8;k++){direcciones[x][k]=recepcionXbee[10+k];}//se almacena la direccion en auxiliar
}
}
comprobado=TRUE;
}
else comprobado=FALSE; //si comprobado=FALSE no hay dispositivos en la red o existen errores en recepción
}
/////////////////////////////////////////////////////////////////////////////
//
// Subprogramas
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// Rutinas XBee
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// Red XBee
//
// Comprueba cuantos dispositivos hay en la red y actualiza numero_de_dispositivos
// requiere enviar al coordinador el comando ND Node Discovery,
// por cada dispositivo se aumenta la variable numero_de_dispositovo
// además se debe guardar su dirección para posterior comunicación
//
// La trama de un comando ND es la siguiente:
// 0x7E 0x00 0x04 0x08 0x01 0x4E 0x44 0x64
// 0x0004 = tamaño
// 0x08 = Comando AT
// 0x01 = Identificador (reconocimiento)
// 0x4E44 = AT ('ND')
// 0x64 = Suma de control
// Suma de control [0xFF - (0x08 + 0x01 + 0x4E + 0x44)]
// hay que enviar la trama y esperar el tiempo NO, esperar recibir 0x7E
// a partir del byte 11 y hasta el 18 obtiene DH y DL 4 bytes cada uno
// una vez comprobado la suma de control incrementa número de dispositivos
/////////////////////////////////////////////////////////////////////////////
void redXBee()
{
enable_interrupts(global);disable_interrupts(INT_USB);
numeroDeDispositivos=0;
intentos=0; //variable empleada en para depuracion
comprobado=FALSE;
do
{
i=0;
limpiarAuxRecep();
disable_interrupts(INT_RDA);
tiempoAgotado=FALSE;
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
set_timer1(0);
cuenta=96;
enable_interrupts(INT_TIMER1);
putc(delimitador);putc(0x00);putc(tamaND);putc(comandoAT);
putc(reconocimiento);putc(atN);putc(atD);putc(scND); //envía comando ND
while(!tiempoAgotado)
{
if(kbhit())
{
auxRecepXbee[i]=getc();
i++;
}
if ((i>0)&&(auxRecepXbee[0]!=0x7E))
{
intentosB++;
limpiarAuxRecep();
break;
}
}
desbordaT1=0;
disable_interrupts(INT_TIMER1);
manejoND();
if (comprobado){intentos++;}
}while(!comprobado&&intentos<intentosMAX);
enable_interrupts(INT_USB);
}
///////////////////////////////////////////////////////////
//
//
//
//
// MAIN
//
//
//
///////////////////////////////////////////////////////////
void main(void) {
setup_low_volt_detect( LVD_38 | LVD_TRIGGER_BELOW );
limpiarDirecciones();
//redXBee(); //se hace un chequeo inicial para ver si hay dispositivos en la red
enable_interrupts(INT_LOWVOLT);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
LED_ON(ledR);
LED_OFF(ledV);
usb_init_cs(); //Inicializa el Modulo de Comunicacion USB
while (TRUE)
{
while (kbhit()){
LED_ON(PIN_B4);
while(recibi){
LED_ON(PIN_B4);
delay_ms(100);
LED_OFF(PIN_B4);
recibi = FALSE;
}
}
while(baje){
LED_ON(PIN_D2);
delay_ms(5);
LED_OFF(PIN_D2);
baje = FALSE;
}
usb_task();
if (usb_enumerated())
{
LED_ON(ledV);
if (usb_kbhit(1)) { //Verifica si se han recibido datos provenientes del PC
usb_get_packet(1, recbuf, Lenbuf); //Toma los dos bytes que llegan y los guarda en recbuf,
if (recbuf[0]== 1) { // Mandamos datos a la tarjeta numero 1 (recepcion de empleados)
LED_ON(PIN_C0);
}
else {
LED_OFF(PIN_C0); }
if (recbuf[1]==42) {
LED_ON(PIN_C1);
delay_ms(100);
LED_OFF(PIN_C1);
putc(startbit);
putc(tamamin);
putc(tamamax);
putc(frametype);
putc(frameid);
putc(bitMsb64dir);
putc(bit1_64dir);
putc(bit2_64dir);
putc(bit3_64dir);
putc(bit4_64dir);
putc(bit5_64dir);
putc(bit6_64dir);
putc(bitLsb64dir);
putc(bitMsb16dir);
putc(bitLsb16dir);
putc(broadcast_radius);
putc(options);
putc(rfdata1);
putc(rfdata2);
putc(rfdata3);
putc(rfdata4);
putc(checksum);
}
else {LED_OFF(PIN_C1);
}
if (recbuf[2]==50) {
LED_ON(PIN_C2);
}
else {LED_OFF(PIN_C2);
}
}
}
else{
LED_OFF(ledV);
}
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Interrupcion que me indica que el nivel de
// alimentacion esta por debajo de los 3.8V
//
//
// .
//
/////////////////////////////////////////////////////////////////////////////
#use delay(clock=48000000)
#int_lowvolt
void BajoVoltaje(void)
{
baje=TRUE;
clear_interrupt(INT_LOWVOLT);
}
#INT_RDA
void rda_isr(void)
{
recibi = TRUE ;
clear_interrupt(INT_RDA);
} |
|
|
 |
PCM programmer
Joined: 06 Sep 2003
Posts: 21708
|
|
| Posted: Tue Jan 28, 2014 3:31 pm |
|
|
| Quote: |
the pic receive a data the INTERRUPTION does not anything
#INT_RDA
void rda_isr(void)
{
recibi = TRUE ;
clear_interrupt(INT_RDA);
} |
You have to call getc() inside the #int_rda routine.
Also, you don't need to clear the interrupt with code. The compiler
does it for you. Do it like this:
| Code: |
#INT_RDA
void rda_isr(void)
{
char c;
c = getc();
// Put your code here.
} |
|
|
|
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
|
| Posted: Tue Jan 28, 2014 3:39 pm |
|
|
Hi PCM_PROGRAMER thank you very much for your comments..
Look i tried in this way:
| Code: |
/////////////////////////////////////////////////////////////////////////////
//
// Interrupción TIMER 0
//
// Activa la variable tiempo agotado para evitar bloqueos en la espera
// de recepciones enviadas por el coordinador al microcontrolador
/////////////////////////////////////////////////////////////////////////////
#INT_TIMER0
void isr_timer0(void)
{
tiempoAgotado=TRUE;
}
/////////////////////////////////////////////////////////////////////////////
//
// Interrupción TIMER 1
//
// Incrementa la variable desbordaT1 y la compara con la variable cuenta
// activando tiempoAgotado cuando se llega a la interrupción cuenta veces
/////////////////////////////////////////////////////////////////////////////
#INT_TIMER1
void isr_timer1(void)
{
desbordaT1++;
if (desbordaT1>cuenta){tiempoAgotado=TRUE;}
}
/////////////////////////////////////////////////////////////////////////////
//
// Interrupción Recepción serie
//
// Se activa cuando hay datos presentes en la recepción del microcontrolador
// almacena el caracter e inicia el timer0 a la vez que lo habilita haciendo
// que si no vuelve a recibir otro dato en el tiempo de desborde del timer,
// que tiene un margen de seguridad suficiente para evitar la pérdida de
// datos recibidos, se termine con la recepción
/////////////////////////////////////////////////////////////////////////////
#INT_RDA
void recepcionSerie(void)
{
while(kbhit())
{
recepcionXbee[prx]=getc();
prx++;
LED_ON(PIN_B2);
delay_ms(100);
LED_OFF(PIN_B2);
}
set_timer0(0); //el timer se rinicia cada vez que se recibe un caracter
enable_interrupts(INT_TIMER0);
} |
i wrote this part of the code which says LED_ON(PIN_B2); delay_ms(100); LED_OFF(PIN_B2); , to prove if PIC18f4550 is recieving any data.. but i have no response..
what is happening??? |
|
|
ezflyr
Joined: 25 Oct 2010
Posts: 1019
Location: Tewksbury, MA
|
|
| Posted: Tue Jan 28, 2014 4:59 pm |
|
|
Hi,
Well, for starters, you don't want 'kbhit' or the While() loop inside the ISR, so get rid of them. You also don't want any delays in any ISR - the goal is to
get in and out fast. Change the code to a single 'output_toggle(Pin_B2);' inside the ISR and see if the LED turns On/Off each time a new character is
received. Send them one at a time so that you can clearly observe the behavior of the LED.
Also, get rid of all the code not related to receiving serial data, and only add it back once you get this part working. Take it step-by-step......
John |
|
|
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
|
| Posted: Tue Jan 28, 2014 5:53 pm |
|
|
Hi exflyr
You mean that while(kbhit()) is not necesary??
And i know that we dont have to write any delay_ms inside a isr... Thank you!!
I tried writting output_toggle(PIN_B4) but nothing happens... It is like the software does walk anymore!!!
Thank you again |
|
|
ezflyr
Joined: 25 Oct 2010
Posts: 1019
Location: Tewksbury, MA
|
|
| Posted: Tue Jan 28, 2014 6:52 pm |
|
|
Hi,
How do you know your hardware is working? Have you tried flashing an LED at a known rate, ie., one second On and one second Off?
Once you know your code is actually running, forget the serial interrupt until you prove your serial hardware is working correctly. Inside Main() create a
loop which reads a character from the UART and then immediately echoes it right back. Test this with a terminal program running on your PC.
John |
|
|
Ttelmah
Joined: 11 Mar 2010
Posts: 19498
|
|
| Posted: Wed Jan 29, 2014 2:07 am |
|
|
Key thing, is to take a deep breath, and understand what INT_RDA 'says'.
It says 'there is a character waiting to be read'.
Now this will forever be true, until a character is read. The interrupt can't be cleared by you or the compiler, till a read takes place. Try to clear the interrupt, and it'll immediately re-set, since there is still a character waiting to be read.
Then it is only triggered when a character _is_ available, so you don't need to test with kbhit. The interrupt triggering, is saying that kbhit it true.
Look at the code PCM_programmer posts. Also look at ex_sisr.c, which shows how to save the character to a software 'ring' buffer.
In the case of an interrupt triggered by events like this, the physical thing doing the trigger is what must be handled by the interrupt. So INT_RB, which says that 'the pattern on the portB pins does not match what it was when the port was last read', requires you to read the port, or again it'll trigger for ever. INT_TBE, requires you to write a character to the UART transmit buffer, or again it'll trigger for ever. etc. etc..
Best Wishes |
|
|
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
|
| Posted: Wed Jan 29, 2014 6:45 am |
|
|
Hi Ttelmah thank you very much..
what i mean?
INT_RDA is activated forever???
what happen with my program?? it goes well until the first INT_RDA appears, then it freezes ( but the microcontroller continuing attached by USB) until i reset by hardware...
HI ezflyr...
Im gonna do what you said in order to prove my hardware and check that everything is going well..
I have another doubt.. i dont know if you have a knowledge about communicate Xbee in API mode, so for example if you want to send a byte form a Xbee to another one you have to build a frame.. so we have
0x7E Start byte
0x00 LSB lenght
0x12 MSB lenght
0x10 Frame type
0x01 Frame ID
0x00 LSB 64 bit address
0x13
0xA2
0x00
0x40
0xA1
0x22
0x0A MSB 64 bit address
0xCB LSB 16 bit address
0x97 MSB 16 bit address
0x00 Broadcast radius
0x00 Options
0x05 DATA
0x2A CHECKSUM
In this case DATA is the real value of my data, i mean the others byte are only part of the protocol API.
I think that when the microcontroller receive this DATA from another XBEE, it will receive all the frame and not only the DATA value... in this way my code would not work because i was comparing if c= 5 ... what do you think? |
|
|
ezflyr
Joined: 25 Oct 2010
Posts: 1019
Location: Tewksbury, MA
|
|
| Posted: Wed Jan 29, 2014 7:24 am |
|
|
Hi Josue,
You are getting way, way ahead of yourself! Unless you learn early on to break a project down into small, manageable 'chunks' then your embedded
development career is going to be pretty short  !
You MUST, I repeat MUST verify that your hardware is working correctly before you even begin to think about data packets, etc.!
Can you blink an LED at a known rate to verify that your PIC is actually running, and at the correct speed? Can you read a character sent from
the PC to the PIC UART, and echo it right back?
| Code: |
while(1)
{
putc(getc());
}
|
As to your last question, once you get this working, the PIC is going to receive ALL the characters (data and otherwise) sent from the Xbee. The
general technique is to detect the Start character, and then start buffering data until a CR or LF character is received. This is done inside
your serial ISR, and means that the entire 'packet' has been received. But, forget about this for now, at least until you can do the two tests I described above!!
John |
|
|
temtronic
Joined: 01 Jul 2010
Posts: 9221
Location: Greensville,Ontario
|
|
| Posted: Wed Jan 29, 2014 7:41 am |
|
|
The real 'fun' with xbee API mode is receiving the data.Due to the variable length you have to first get the 'token'( 0x7E) then get 2 more bytes( length of steam), then receive the entire stream.
After that it's easy to 'parse' the 'xb_buffer[]' to see remote DIO status, ADC value, etc. or just send the entire buffer to a PC.
jay |
|
|
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
|
| Posted: Wed Jan 29, 2014 7:43 am |
|
|
Guys i will upload a video to explain what is happening right now.. you can see on this link, i wanna apologize but im practicing my english..
http://www.youtube.com/watch?v=bHSI-uA5JYU&feature=youtu.be
Hi ezflyr.. im testing what you said right now.. in a few minutos ill let you know what happened..
Thanks |
|
|
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
|
| Posted: Wed Jan 29, 2014 8:47 am |
|
|
Hi ezflyr.. i did my first test like you told me.. my hardware is ok.. i send byte/char by the hypertemrinal and PIC receive and send back to the hyperterminal.
| Code: |
while(1)
{
putc(getc());
}
|
Could you see the video?
Thanks |
|
|
josue
Joined: 28 Jan 2014
Posts: 10
Location: Venezuela
|
|
| Posted: Wed Jan 29, 2014 9:18 am |
|
|
hi everybody... i try this code in my PIC and it went fine...
| Code: | while(1)
{
if(i == 10){
for(i=0;i<=10;i++){
putc(recepcionXbee[i]);
}
i=0;
}
}
}
#INT_RDA
void recepcionSerie(void)
{
recepcionXbee[i]= getc();
i++;
}
|
Please try to se the video and help me to understand what happen when the entire code... |
|
|
|
FAQ 
Search
Register
Profile 
Log in to check your private messages 
Log in
