hola a todos... esto creando un proyecto de Inmotica con XBEE y microcontroladores PIC...
Ya tengo lista la parte de conexion USB, pero tengo muchas dudas con las interrupciones .. cuando debo colocarlas??? cuando las activo? cuando las desactivo? al entrar en un isr de una interrupcion se limpia la bandera que se activo?
Este es mi codigo, y en el mismo tengo un problema.. Asi como esta escrito, es para hacer pruebas por eso solo cambio el estado de unos led cuando ocurre una interrupcion.. La interrupcion de LVD(LOW_VOLT_DETECT) funciona perfectamente pero la de INT_RDA no me funciona.. LES AGRADEZCO DE ANTE MANO EN LO QUE ME PUEDAN AYUDAR.... SALUDOS
#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
- [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
- [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
=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);
} 
