Autor Tema: Mis experiencias con el BUS CAN  (Leído 614702 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1335 en: 14 de Febrero de 2013, 17:18:15 »
Jejejej, y del que sigo teniendo, pero vamos poco a poco.
Si...está en una línea comentada. pero vamos porque lo único que quería es ver si entraba en la interrupción y lo puse donde primero pillé

pues voy a poner filtros y máscaras a cero a ver.
Si que pasa la línea de transmisión de un mensaje, se va a la función y termina dicha función, luego al if para comprobar el valor y ahí se fini.

Un saludo.
« Última modificación: 14 de Febrero de 2013, 17:26:39 por afelio »

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1336 en: 14 de Febrero de 2013, 17:37:09 »
Los filtros y las máscaras los he borrado, ya no están.
Ahora....sigue sin ir.

Os pego una imagen para que veais donde se para:



Al punto de ruptura no llega, el siguiente paso de donde está ahora la línea....es perderse.

Un saludo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #1337 en: 14 de Febrero de 2013, 17:48:03 »
No tienes declarado cuantos datos envias (valor entre 0 y 8) en el mensaje, mira la variable DLC como la cargas.

Citar
 /*Mensaje a enviar */
    messageTx->messageWord[0] = 0;
    messageTx->messageWord[1] = 0;
    messageTx->messageWord[2] = 0;
    messageTx->messageWord[3] = 0;
 
    messageTx->msgSID.SID = 0x201;
    messageTx->msgEID.IDE = 0;
    messageTx->msgEID.RTR = 1;
    messageTx->msgEID.DLC = 0;

Si lo que intentas es enviar 4 datos, DLC deberia ser igual a 4...

Ademas pones el bit RTR en 1, eso obliga a contestar y no tiene que contestar. Ponlo en 0.
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1338 en: 14 de Febrero de 2013, 18:06:28 »
Ya está puesto, si no te digo que he hecho tantas modificaciones al que hice que ya no se ni que hago.

Pues nada, sigue sin ir. Y lo raro es que se pierde en el while cuando debería estar ahí en el bucle infinitamente.
Ya por hoy desisto.

Un saludo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #1339 en: 14 de Febrero de 2013, 18:12:53 »
Pega el código que tienes de nuevo, así le doy otra leída mas...
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1340 en: 14 de Febrero de 2013, 18:26:59 »
Muchas gracias por la ayuda MGLSOFT, y perdona el tiempo que te estoy quitando.

Código: C
  1. #include <p32xxxx.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <plib.h>
  5. //#include <peripheral\system.h>
  6. #include <peripheral\CAN.h>
  7. #include "GenericTypeDefs.h"
  8.  
  9.  
  10.  
  11.  
  12. #define SYSTEM_FREQ 80000000
  13. #define CAN_BUS_SPEED 125000
  14.  
  15. /*Fsys = 80MHz */
  16. /*Fpb = 80MHz  */
  17. #pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
  18. #pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_1
  19.  
  20. BYTE CAN1MessageFifoArea[2 * 8 * 16];
  21. BOOL isCAN1MsgReceived = FALSE;
  22. CANRxMessageBuffer * messageRx;
  23. CANTxMessageBuffer * messageTx;
  24. int prueba=0;
  25.  
  26.  
  27. void CAN1Init(void);
  28. void CAN1TxSendRTRMsg(void);
  29.  
  30.  
  31. /************************************/
  32. /************************************/
  33. /* Función Principal                */
  34. /************************************/
  35. /************************************/
  36.  
  37. void main (void){
  38.  
  39.     /*Ponemos los puertos Analógicos-Digitales*/
  40.     AD1PCFG = 0xFFFF;
  41.     /*Pin del Led como salida*/
  42.     _TRISF3=0;
  43.     _LATF3 = 0;
  44.     /*Pines del CAN como entrada y Salida Respectivamente.*/
  45.    _TRISF0=1;
  46.    _TRISF1=0;
  47.  
  48.     INTEnableSystemMultiVectoredInt();
  49.  
  50.     /*Configuramos CAN1*/
  51.     CAN1Init();
  52.     prueba=0;
  53.  
  54.  
  55.     while(1){
  56.         if(prueba==0){
  57.             CAN1TxSendRTRMsg();
  58.         }
  59.         //CAN1TxSendRTRMsg();
  60.         //CAN1RxMsgProcess();
  61.         /*Verificamos si Tx = Rx*/
  62.         if ((messageRx->messageWord[2]==0)){
  63.             _LATF3 = 1;
  64.         }
  65.         else
  66.             _LATF3 = 0;
  67.     }
  68. }
  69.  
  70.  
  71.  
  72.  
  73. /***************************/
  74. /***************************/
  75. /*Configuración del Bus CAN*/
  76. /***************************/
  77. /***************************/
  78.  
  79. void CAN1Init(void)
  80. {
  81.     CAN_BIT_CONFIG canBitConfig;
  82.     UINT baudPrescalar;
  83.  
  84.     /*Ponemos el módulo CAN en modo configuración*/
  85.     CANEnableModule(CAN1,TRUE);
  86.     CANSetOperatingMode(CAN1, CAN_CONFIGURATION);
  87.     /*Esperamos hasta que entre en modo configuración*/
  88.     while(CANGetOperatingMode(CAN1) != CAN_CONFIGURATION);
  89.  
  90.     /*Configuramos el reloj del módulo CAN*/
  91.     canBitConfig.phaseSeg2Tq            = CAN_BIT_3TQ;
  92.     canBitConfig.phaseSeg1Tq            = CAN_BIT_3TQ;
  93.     canBitConfig.propagationSegTq       = CAN_BIT_1TQ;
  94.     canBitConfig.phaseSeg2TimeSelect    = TRUE;
  95.     canBitConfig.sample3Time            = FALSE;
  96.     canBitConfig.syncJumpWidth          = CAN_BIT_1TQ;
  97.  
  98.     CANSetSpeed(CAN1,&canBitConfig,SYSTEM_FREQ,CAN_BUS_SPEED);
  99.  
  100.     /*Asignamos el tamaño del Búfer*/
  101.     CANAssignMemoryBuffer(CAN1,CAN1MessageFifoArea,(2 * 8 * 16));
  102.  
  103.     /*Seleccionamos las FIFOS                     */
  104.     /*FIFO0 para Tx                               */
  105.     /*FIFO1 para Rx                               */
  106.     /*FIFO0 con RTR deshabilitado y prioridad baja*/
  107.     /*FIFO1 recepción del mensaje completo*/
  108.     CANConfigureChannelForTx(CAN1, CAN_CHANNEL0, 8, CAN_TX_RTR_DISABLED, CAN_LOW_MEDIUM_PRIORITY);
  109.     CANConfigureChannelForRx(CAN1, CAN_CHANNEL1, 8, CAN_RX_FULL_RECEIVE);
  110.  
  111.     /*Configuramos Filtros y máscaras         */
  112.     /*Filtro0 para aceptar SID 0x201          */
  113.     /*Máscara0 para comparar todos los ID     */
  114.     /*El mensaje debe ser almacenado en FIFO1 */
  115.     //CANConfigureFilter      (CAN1, CAN_FILTER0, 0x001, CAN_SID);
  116.     //CANConfigureFilterMask  (CAN1, CAN_FILTER_MASK0, 0x7FC, CAN_SID, CAN_FILTER_MASK_IDE_TYPE);
  117.     //CANLinkFilterToChannel  (CAN1, CAN_FILTER0, CAN_FILTER_MASK0, CAN_CHANNEL1);
  118.     //CANEnableFilter         (CAN1, CAN_FILTER0, TRUE);
  119.  
  120.     /*Habilitamos interrupciones y eventos      */
  121.     /*Habilitamos la recepción si hay un evento */
  122.     /*Habilitamos la interrupción               */
  123.     CANEnableChannelEvent(CAN1, CAN_CHANNEL1, CAN_RX_CHANNEL_NOT_EMPTY, TRUE);
  124.     CANEnableModuleEvent (CAN1, CAN_RX_EVENT, TRUE);
  125.  
  126.     INTSetVectorPriority(INT_CAN_1_VECTOR, INT_PRIORITY_LEVEL_4);
  127.     INTSetVectorSubPriority(INT_CAN_1_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
  128.     INTEnable(INT_CAN1, INT_ENABLED);
  129.     //IEC1SET = 0x04000000;
  130.  
  131.     /*Ponemos el módulo CAN en modo normal */
  132.     CANSetOperatingMode(CAN1, CAN_LOOPBACK);
  133.     while(CANGetOperatingMode(CAN1) != CAN_LOOPBACK);
  134.  
  135.     CANClearModuleEvent(CAN1, CAN_OPERATION_MODE_CHANGE_EVENT);
  136.  
  137. }
  138.  
  139.  
  140.  
  141.  
  142. /***************************************************/
  143. /***************************************************/
  144. /*Función para enviar un mensaje al bus CAN        */
  145. /***************************************************/
  146. /***************************************************/
  147.  
  148. void CAN1TxSendRTRMsg(void)
  149. {
  150.     //CANTxMessageBuffer * messageTx;//Lo saco a variable global
  151.  
  152.     /*Actualizamos el índice en la FIFO0 */
  153.     messageTx = CANGetTxMessageBuffer(CAN1,CAN_CHANNEL0);
  154.  
  155.     /*Mensaje a enviar */
  156.     messageTx->messageWord[0] = 0;
  157.     messageTx->messageWord[1] = 0;
  158.     messageTx->messageWord[2] = 0;
  159.     messageTx->messageWord[3] = 0;
  160.  
  161.     messageTx->msgSID.SID = 0x001;
  162.     messageTx->msgEID.IDE = 0;
  163.     messageTx->msgEID.RTR = 0;
  164.     messageTx->msgEID.DLC = 4;
  165.  
  166.     /*Actualizamos el índice a la nueva posición de la FIFO0*/
  167.     CANUpdateChannel(CAN1,CAN_CHANNEL0);
  168.  
  169.     /*Limpiamos la FIFO0 permitiendo enviar cualquier mensaje de Tx*/
  170.     CANFlushTxChannel(CAN1,CAN_CHANNEL0);
  171. }
  172.  
  173.  
  174.  
  175.  
  176. /***************************************************/
  177. /***************************************************/
  178. /*Manejador de la interrupción del CAN1            */
  179. /*Todos los eventos se habilitan en CanEnableEvent */
  180. /*En este caso un evento en la recepción           */
  181. /***************************************************/
  182. /***************************************************/
  183.  
  184. void __ISR (_CAN_1_VECTOR, ipl4) CAN1Interrupt(void)
  185. {
  186.     /*Verifica si hay un evento en la recepción*/
  187.     if((CANGetModuleEvent(CAN1) & CAN_RX_EVENT) != 0)
  188.     {
  189.         /*Se podría verificar que causó el evento mediante*/
  190.         /*CANGetModuleEvent(), que devuelve el código     */
  191.         /*que representa la prioridad más alta del evento */
  192.         /*pendiente                                       */
  193.                 if(CANGetPendingEventCode(CAN1) == CAN_CHANNEL1_EVENT)
  194.                 {
  195.                     /*Verificamos si se ha producido un evento en la FIFO1    */
  196.                     /*El evento CAN_RX_CHANNEL_NOT_EMPTY es persistente       */
  197.                     /*Se puede leer la FIFO por la interrupción para borrar   */
  198.                     /*la condición de evento o deshabilitar el origen de      */
  199.                     /*de los eventos y hacerlo mediante una función como aquí */
  200.                     CANEnableChannelEvent(CAN1, CAN_CHANNEL1, CAN_RX_CHANNEL_NOT_EMPTY, FALSE);
  201.                     messageRx = (CANRxMessageBuffer *)CANGetRxMessage(CAN1,CAN_CHANNEL1);
  202.                     CANUpdateChannel(CAN1, CAN_CHANNEL1);
  203.                     CANClearModuleEvent (CAN1, CAN_RX_EVENT);
  204.                     prueba=1;
  205.                 }
  206.     }
  207.     /*Se borra la bandera de la interrupción  */
  208.     /*Siempre al final para que si se produce */
  209.     /*otra interrupción no tenga efecto       */
  210.     INTClearFlag(INT_CAN1);
  211. }
  212.  

Un saludo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #1341 en: 14 de Febrero de 2013, 19:00:53 »
Te faltan completar aperturas y cierres de llaves en el If-Else.

raro que no te grito el compilador!!

Citar
    while(1){    <------------------------<< abre nivel 1
        if(prueba==0){   <--------------<< abre nivel IF 1
            CAN1TxSendRTRMsg();
        }    >>----------------------->  cierra nivel IF 1
        //CAN1TxSendRTRMsg();
   //CAN1RxMsgProcess();
        /*Verificamos si Tx = Rx*/
        if ((messageRx->messageWord[2]==0)){  <-----------<< abre nivel IF 2
            _LATF3 = 1;
        }    >>----------------->     cierra nivel IF 2
        else              <--------------------<<  AQUI DEBIERAS ABRIR NIVEL ELSE 2
            _LATF3 = 0;
    }    >>--------------------->  Y AQUI CERRARLO, PERO TOMA ESTE COMO CIERRE DEL IF 2 O ALGO ASI, POR ESO SE VA DE VIAJE....

Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1342 en: 15 de Febrero de 2013, 05:28:31 »
Buenos días,

Hoy no podré probar el código ya que por asuntos propios tengo que realizar un viaje, pero de mañana Sábado no pasa.

Creo que ahí no debe estar el fallo, pues al tener sólo un comando no es necesario poner los corchetes del else, por eso no me dio error, aún así los pondré y probaré. (Cuando he programado otros micros de otras marcas no habido problemas por eso.

Pensando un poco, creo que el problema puede estar en el Watchdog, que no está desactivado, no??
Lo pregunto porque no se como se desactiva el Watchdog del PIC.

Un saludo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1343 en: 15 de Febrero de 2013, 05:48:58 »
Acabo de ver en el post de más arriba, donde configuro el reloj que tengo desactivado el Watchdog:

FWDTEN = OFF

Asi que descartada mi suposición.

Un saludo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #1344 en: 15 de Febrero de 2013, 08:41:05 »
Esta bien lo que dices, hay una sola instruccion, pero igual ponle la apertura y cierre.
A veces los compiladores hacen cosas raras...
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1345 en: 15 de Febrero de 2013, 08:46:28 »
Si es por eso...tengo que decir que es demasiado delicado el compilador.

Lo probaré en cuando pueda.

Un saludo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1346 en: 16 de Febrero de 2013, 09:13:58 »
Nada, con los corchetes pasa exactamente lo mismo.

Puede ser que sea por el tratamiento de la estructura de los mensajes recibidos??

Código: C
  1. if ((messageRx->messageWord[2]==0)){  

El problema es cuando llega al if, y apartir de ahí se pierde el debug y se para no se donde....
Voy a probar a crear una estructura, y en la interrupción asigno dichos valores a mi estructura recien creada para en el if tratar dicha estructura.

Ya no se me ocurren más cosas.

Un saludo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1347 en: 17 de Febrero de 2013, 07:46:12 »
Buenas,

MGLSOFT  :-/ :-/ :-/.
He solucionado lo del while(1).

Me parece tristísimo que tenga que celebrar que hace un while(1), pero estas cosas tan obvias que funcionan siempre...cuando fallan dan una guerra.
Bueno, pues como puse en el post anterior, pensé que a la hora de realizar el segundo if, buscando la estructura de datos de la librería del CAN se perdía y no volvía en si.
Pues he creado una estructura y ahora el if es sobre esa estructura realizando el bucle infinito sin problemas.

ahora decir, que sigue sin entrar en la interrupción de las narices.
Seguiré mirando a ver que puede ser...he añadido una nueva línea, habilitando la Tx  :oops:
Pego el código por si podeis ayudarme, (Más todavía).

Código: C
  1. #include <p32xxxx.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <plib.h>
  5. //#include <peripheral\system.h>
  6. #include <peripheral\CAN.h>
  7. #include "GenericTypeDefs.h"
  8.  
  9.  
  10.  
  11.  
  12. #define SYSTEM_FREQ 80000000
  13. #define CAN_BUS_SPEED 125000
  14.  
  15. /*Fsys = 80MHz */
  16. /*Fpb = 80MHz  */
  17. #pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
  18. #pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_1
  19.  
  20.  
  21. typedef struct{
  22.     unsigned B0recibido:32;
  23.     //unsigned B1recibido:8;
  24.     //unsigned B2recibido:8;
  25.     //unsigned B3recibido:8;
  26.     //unsigned B4recibido:8;
  27.     //unsigned B5recibido:8;
  28.     //unsigned B6recibido:8;
  29.     //unsigned B7recibido:8;
  30. }TDatosRecibidos;
  31.  
  32.  
  33. BYTE CAN1MessageFifoArea[2 * 8 * 16];
  34. BOOL isCAN1MsgReceived = FALSE;
  35. int prueba=0;
  36.  
  37.  
  38. void CAN1Init(void);
  39. void CAN1TxSendRTRMsg(void);
  40.  
  41.  
  42. /************************************/
  43. /************************************/
  44. /* Función Principal                */
  45. /************************************/
  46. /************************************/
  47.  
  48. void main (void){
  49.     TDatosRecibidos Datos;
  50.  
  51.     /*Ponemos los puertos Analógicos-Digitales*/
  52.     AD1PCFG = 0xFFFF;
  53.     /*Pin del Led como salida*/
  54.     _TRISF3=0;
  55.     _LATF3 = 0;
  56.     /*Pines del CAN como entrada y Salida Respectivamente.*/
  57.    _TRISF0=1;
  58.    _TRISF1=0;
  59.  
  60.     INTEnableSystemMultiVectoredInt();
  61.  
  62.     /*Configuramos CAN1*/
  63.     CAN1Init();
  64.     prueba=0;
  65.  
  66.  
  67.     while(1){
  68.         if(prueba==0){
  69.             CAN1TxSendRTRMsg();
  70.         }
  71.         //CAN1TxSendRTRMsg();
  72.         //CAN1RxMsgProcess();
  73.         /*Verificamos si Tx = Rx*/
  74.         if(Datos.B0recibido == 0x12345678){
  75.             _LATF3 = 1;
  76.         }
  77.         else{
  78.             _LATF3 = 0;
  79.         }
  80.     }
  81. }
  82.  
  83.  
  84.  
  85.  
  86. /***************************/
  87. /***************************/
  88. /*Configuración del Bus CAN*/
  89. /***************************/
  90. /***************************/
  91.  
  92. void CAN1Init(void)
  93. {
  94.     CAN_BIT_CONFIG canBitConfig;
  95.     UINT baudPrescalar;
  96.  
  97.     /*Ponemos el módulo CAN en modo configuración*/
  98.     CANEnableModule(CAN1,TRUE);
  99.     CANSetOperatingMode(CAN1, CAN_CONFIGURATION);
  100.     /*Esperamos hasta que entre en modo configuración*/
  101.     while(CANGetOperatingMode(CAN1) != CAN_CONFIGURATION);
  102.  
  103.     /*Configuramos el reloj del módulo CAN*/
  104.     canBitConfig.phaseSeg2Tq            = CAN_BIT_3TQ;
  105.     canBitConfig.phaseSeg1Tq            = CAN_BIT_3TQ;
  106.     canBitConfig.propagationSegTq       = CAN_BIT_1TQ;
  107.     canBitConfig.phaseSeg2TimeSelect    = TRUE;
  108.     canBitConfig.sample3Time            = FALSE;
  109.     canBitConfig.syncJumpWidth          = CAN_BIT_1TQ;
  110.  
  111.     CANSetSpeed(CAN1,&canBitConfig,SYSTEM_FREQ,CAN_BUS_SPEED);
  112.  
  113.     /*Asignamos el tamaño del Búfer*/
  114.     CANAssignMemoryBuffer(CAN1,CAN1MessageFifoArea,(2 * 8 * 16));
  115.  
  116.     /*Seleccionamos las FIFOS                     */
  117.     /*FIFO0 para Tx                               */
  118.     /*FIFO1 para Rx                               */
  119.     /*FIFO0 con RTR deshabilitado y prioridad baja*/
  120.     /*FIFO1 recepción del mensaje completo*/
  121.     CANConfigureChannelForTx(CAN1, CAN_CHANNEL0, 8, CAN_TX_RTR_DISABLED, CAN_LOW_MEDIUM_PRIORITY);
  122.     CANConfigureChannelForRx(CAN1, CAN_CHANNEL1, 8, CAN_RX_FULL_RECEIVE);
  123.  
  124.     /*Configuramos Filtros y máscaras         */
  125.     /*Filtro0 para aceptar SID 0x201          */
  126.     /*Máscara0 para comparar todos los ID     */
  127.     /*El mensaje debe ser almacenado en FIFO1 */
  128.     //CANConfigureFilter      (CAN1, CAN_FILTER0, 0x001, CAN_SID);
  129.     //CANConfigureFilterMask  (CAN1, CAN_FILTER_MASK0, 0x7FC, CAN_SID, CAN_FILTER_MASK_IDE_TYPE);
  130.     //CANLinkFilterToChannel  (CAN1, CAN_FILTER0, CAN_FILTER_MASK0, CAN_CHANNEL1);
  131.     //CANEnableFilter         (CAN1, CAN_FILTER0, TRUE);
  132.  
  133.     /*Habilitamos interrupciones y eventos      */
  134.     /*Habilitamos la recepción si hay un evento */
  135.     /*Habilitamos la interrupción               */
  136.     CANEnableChannelEvent(CAN1, CAN_CHANNEL1, CAN_RX_CHANNEL_NOT_EMPTY, TRUE);
  137.     CANEnableModuleEvent (CAN1, CAN_RX_EVENT, TRUE);
  138.  
  139.     INTSetVectorPriority(INT_CAN_1_VECTOR, INT_PRIORITY_LEVEL_4);
  140.     INTSetVectorSubPriority(INT_CAN_1_VECTOR, INT_SUB_PRIORITY_LEVEL_0);
  141.     INTEnable(INT_CAN1, INT_ENABLED);
  142.     //IEC1SET = 0x04000000;
  143.  
  144.     /*Ponemos el módulo CAN en modo normal */
  145.     CANSetOperatingMode(CAN1, CAN_LOOPBACK);
  146.     while(CANGetOperatingMode(CAN1) != CAN_LOOPBACK);
  147.  
  148.     CANClearModuleEvent(CAN1, CAN_OPERATION_MODE_CHANGE_EVENT);
  149.  
  150. }
  151.  
  152.  
  153.  
  154.  
  155. /***************************************************/
  156. /***************************************************/
  157. /*Función para enviar un mensaje al bus CAN        */
  158. /***************************************************/
  159. /***************************************************/
  160.  
  161. void CAN1TxSendRTRMsg(void)
  162. {
  163.     CANTxMessageBuffer * message;//Lo saco a variable global
  164.  
  165.     /*Actualizamos el índice en la FIFO0 */
  166.     message = CANGetTxMessageBuffer(CAN1,CAN_CHANNEL0);
  167.  
  168.     /*Mensaje a enviar */
  169.     //message->messageWord[0] = 0;
  170.     //message->messageWord[1] = 0;
  171.     message->messageWord[2] = 0x12345678;
  172.     //message->messageWord[3] = 0;
  173.  
  174.     message->msgSID.SID = 0x001;
  175.     message->msgEID.IDE = 0;
  176.     message->msgEID.RTR = 0;
  177.     message->msgEID.DLC = 4;
  178.  
  179.     /*Actualizamos el índice a la nueva posición de la FIFO0*/
  180.     CANUpdateChannel(CAN1,CAN_CHANNEL0);
  181.     //Habilitamos la transmisión.
  182.     C1FIFOCON0SET=0x00000008;
  183.  
  184.  
  185.     /*Limpiamos la FIFO0 permitiendo enviar cualquier mensaje de Tx*/
  186.     CANFlushTxChannel(CAN1,CAN_CHANNEL0);
  187. }
  188.  
  189.  
  190.  
  191.  
  192. /***************************************************/
  193. /***************************************************/
  194. /*Manejador de la interrupción del CAN1            */
  195. /*Todos los eventos se habilitan en CanEnableEvent */
  196. /*En este caso un evento en la recepción           */
  197. /***************************************************/
  198. /***************************************************/
  199.  
  200. void __ISR (_CAN_1_VECTOR, ipl4) CAN1Interrupt(void)
  201. {
  202.     CANRxMessageBuffer * message;
  203.     /*Verifica si hay un evento en la recepción*/
  204.     if((CANGetModuleEvent(CAN1) & CAN_RX_EVENT) != 0)
  205.     {
  206.         /*Se podría verificar que causó el evento mediante*/
  207.         /*CANGetModuleEvent(), que devuelve el código     */
  208.         /*que representa la prioridad más alta del evento */
  209.         /*pendiente                                       */
  210.                 if(CANGetPendingEventCode(CAN1) == CAN_CHANNEL1_EVENT)
  211.                 {
  212.                     /*Verificamos si se ha producido un evento en la FIFO1    */
  213.                     /*El evento CAN_RX_CHANNEL_NOT_EMPTY es persistente       */
  214.                     /*Se puede leer la FIFO por la interrupción para borrar   */
  215.                     /*la condición de evento o deshabilitar el origen de      */
  216.                     /*de los eventos y hacerlo mediante una función como aquí */
  217.                     CANEnableChannelEvent(CAN1, CAN_CHANNEL1, CAN_RX_CHANNEL_NOT_EMPTY, FALSE);
  218.                     message = (CANRxMessageBuffer *)CANGetRxMessage(CAN1,CAN_CHANNEL1);
  219.                     CANUpdateChannel(CAN1, CAN_CHANNEL1);
  220.                     CANClearModuleEvent (CAN1, CAN_RX_EVENT);
  221.                     prueba=1;
  222.                 }
  223.     }
  224.     /*Se borra la bandera de la interrupción  */
  225.     /*Siempre al final para que si se produce */
  226.     /*otra interrupción no tenga efecto       */
  227.     INTClearFlag(INT_CAN1);
  228. }
  229.  

Un Saludo.

Desconectado afelio

  • PIC16
  • ***
  • Mensajes: 130
Re: Mis experiencias con el BUS CAN
« Respuesta #1348 en: 17 de Febrero de 2013, 09:30:28 »
Nada, sigo sin ser capaz de hacer que atienda la interrupción de recepción.
Desesperado estoy ya.

Un saludo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #1349 en: 17 de Febrero de 2013, 11:45:31 »
Te estas intentando morder la cola, como los perros.
Es decir, estas girando en redondo, vuelves a cometer errores que antes solucionaste.

Los datos a transmitir por un mensaje CAN son de tipo INT8, es decir van de 0 a 255 decimal, o 0 a FF hexa.
En tu programa pones en una sola posicion el dato 0x12345678 , que de por si excede el valor numerico que puedes mandar en una posicion.

Haz lo siguiente, ponle DLC = 1
y en mesage.mesageword1 = 11

y en el main haz la comparacion sobre ese numero y esa posicion esclusivamente.
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.