Mis experiencias con el BUS CAN

[peteorito]

Hola :
 Despues de un tiempo vuelvo a retomar el tema,  tengo ya conectado  mediante 18f4550 + mcp2515 el ordenador  con bus can, me gustaria que cuando el bus can reciba  una trama active la !int del mcp2515 que iria conectado con pin b0 de 18f4550,  la cosa es no se como configurar los registro y los bit.
 Os pediria que me dijeras los registros he visto que en la pagina 45 del mcp2515
 seria esta  CANINTE.RXnIE = 1 , pero no se donde ni como se pone
 Muchas gracias

[MerLiNz]

al ser un dispositivo SPI debes configurarlo mediante comandos por SPI

Para ello tienes que enviar un comando WRITE (2) seguido de la direccion del registro 0x2B y seguido de los bits que quieres modificar para que se produzca la interrupcion

[peteorito]

Gracias tomo nota!!
  Pensaba que era mas sencillo , ademas  no cojo las patillas que tiene habilitadas para el protocolo, coj otras para que en la placa se queden mas cerca... y tambien toy pegaete en spi

[MerLiNz]

Si te buscas un pic con CAN integrado te resultara mas sencillo, solo necesitaras un mcp2551, lo demas podras configurarlo en el firmware del pic sin tener que usar SPI

[PICSHIRU]

Hola antes de nada felicitar a MGLSOFT por este buen hilo. Espero que me puedan ayudar con mi problema.

Estoy con un proyecto de manejo del bus can usando el controlador integrado del pic18f2580 + mcp2551. Tengo conectado al bus el CAN BUS Analyzer tool de Microchip en modo de escucha y un simulador de centralita multi ecu de ozen elektronic

he conseguido con exito comunicarme con la centralita, realizando consultas a varios pid incluidos los multiframe y capturar las respuestas, mi problema es que la centralita solo me responde al id de broadcast y no a los individuales. La cuestion es si es normal o tengo algun problema en la creacion de las tramas.
La central parece aceptar el codigo pero no veo respuesta. tal vez sea una cuestion de filtros, aunque estan configurados para aceptar todo. Si teneis alguna sugerencia...

Aqui os pongo la funcion de manejo del can, por si sirve

Código: C

1. ERROR_CODE SendQuery(int32 ECU_ID,int8 MODE,int8 PID,struct ODB_MPacket *OBDPacket)
2. {
3.    int8 i;
4.    int8 Alen;
5.    int8 ByteCheck;
6.    struct rx_stat rxstat;
7.    unsigned int32 ReceiptID;
8.    static TICKTYPE lastTick;
9.    TICKTYPE currTick;
10.    struct OBD_Packet OBDPacketToSend;
11.    struct OBD_Packet OBDFlowControlFrame;
12.    OBDPacketToSend.NBYTES  =0x02;   //stardard packet
13.    OBDPacketToSend.MODO    =MODE;
14.    OBDPacketToSend.PID     =PID;      
15.    OBDPacketToSend.DATA[0] =0x55;   //No usados 55h para mas compatibilidad
16.    OBDPacketToSend.DATA[1] =0x55;
17.    OBDPacketToSend.DATA[2] =0x55;
18.    OBDPacketToSend.DATA[3] =0x55;
19.    OBDPacketToSend.DATA[4] =0x55;
20.    
21.    
22.    OBDFlowControlFrame.NBYTES=0x30;  //trama de control de flujo
23.    OBDFlowControlFrame.MODO=0x07;
24.    OBDFlowControlFrame.PID=0xF9;
25.    
26.    i=0;
27.    *OBDPacket->NRecibidos=0;
28.    
29.    if(can_tbe())
30.    {  
31.       can_putd(ECU_ID,&OBDPacketToSend,8,3,0,0);  //enviamos la consulta
32.       currTick = lastTick=TickGet();      //inicializamos el timeout
33.       TimeOut=False;
34.       do
35.       {
36.          currTick = TickGet();
37.          if(can_kbhit())
38.          {
39.            can_getd(ReceiptID,&OBDPacket->OBDPacketToSave[i],Alen,rxstat); //capturamos la respuesta
40.            OBDPacket->NRecibidos=OBDPacket->NRecibidos+1;                       //incrementamos los el numero de paquetes recibidos
41.            OBDPacket->Receipt_ID[i]=ReceiptID;                                            //guardamos la id del paquete
42.            ByteCheck=OBDPacket->OBDPacketToSave[i].NBYTES;                   //chequeamos el tipo de trama
43.            ByteCheck=ByteCheck&0xF0;
44.             if (ByteCheck==0x10)
45.             {    
46.                can_putd(ECU_ID,&OBDFlowControlFrame,3,3,0,0);                    //si es un first frame enviamos trama de control
47.                fprintf(DEBUG,"First Frame detected\r\n");
48.             }
49.             else if (ByteCheck==0x20)
50.             {
51.                fprintf(DEBUG,"Consecutive Frame detected\r\n");
52.             }
53.             i++;
54.             lastTick=currTick;
55.          }
56.          else if (TickGetDiff(currTick, lastTick) > (TICKS_PER_SECOND*5)) // si han pasado 5 segundos sin respuesta error por timeout
57.          {
58.             TimeOut=True;
59.             #ifdef PROGRAM_DEBUG
60.                fprintf(DEBUG,"TimeOut\r\n");
61.             #endif
62.             lastTick = currTick;
63.          }
64.       }while(!TimeOut);         // cinco segundos
65.       if(OBDPacket->NRecibidos!=0)   // si hay algun paquete el resultado es bueno
66.       {
67.          return(EC_OK);
68.       }
69.       else
70.       {
71.          return(EC_TIMEOUT);
72.       }
73.    }
74.    else
75.    {
76.       return(EC_SENDBUFFERBUSY);
77.    }
78. }

 

[MGLSOFT]

No entiendo donde defines la estructura OBD_Packet, que luego copias en las demas....

Tampoco entiendo como es que transmites mensajes con id de broadcast, es decir, conoces cuales son los id que usa esa central ?

[PICSHIRU]

Mis disculpas, tal vez omiti demasiados detalles

La central me responde al broadcast siempre y responden aquellas ecus que soportan el pid de la solicitud. Ésta tiene 3 y son 0x7E8, 0xE9h y 0x7EA

Uso la id de broadcast por que no me queda otra. Mi problema es que no responde cuando la misma consulta la envio con 0x7E0 por ejemplo. pero tampoco responde cuando uso el Analyzer en modo normal y transmito desde el.

Código: C

1. #include <CAN_GSM.h>
2.  
3. #define PROGRAM_DEBUG
4.  
5.  
6. #define CAN_USE_EXTENDED_ID           FALSE
7. #define CAN_BRG_SEG_2_PHASE_TS     TRUE  
8. #define CAN_BRG_PRESCALAR               4
9. #define CAN_BRG_SYNCH_JUMP_WIDTH 0
10. #define CAN_BRG_PROPAGATION_TIME  2
11. #define CAN_BRG_PHASE_SEGMENT_1   5
12. #define CAN_BRG_PHASE_SEGMENT_2   5
13. #define CAN_BRG_WAKE_FILTER           TRUE
14. #define CAN_BRG_SAM                         FALSE
15.  
16. #include <can-18F4580.c>
17. #include <Tick.c>
18.  
19. #define STACK_USE_SHA1 TRUE
20.  
21. #include <Hashes.c>
22.  
23.  
24. /**
25.  *
26.  */
27. #define BroadcastID_11    0x7DF
28. #define BroadcastID_29    0X18DB33F1
29.  
30.  
31. int1 TimeOut;
32.  
33.  
34. struct OBD_Packet{
35.    int8 NBYTES;    //0 Numero bytes adicionales
36.    int8 MODO;      //1 Modo
37.    int8 PID;       //2 PID
38.    int8 DATA[5];    //3 Data
39. };
40.  
41.  
42. struct ODB_MPacket{
43.    int8 NRecibidos;
44.    unsigned int32 Receipt_ID[8];
45.    struct OBD_Packet OBDPacketToSave[8];  
46. };
47.  
48.  
49.  
50. enum ERROR_CODE {  
51.                     EC_OK=0,
52.                     EC_SENDBUFFERBUSY=1,
53.                     EC_TIMEOUT =2};
54.  
55.  
56. ERROR_CODE SendQuery(int32 ECU_ID,int8 MODE,int8 PID,struct ODB_MPacket *OBDPacket)
57. {
58.    int8 i;
59.    int8 Alen;
60.    int8 ByteCheck;
61.    struct rx_stat rxstat;
62.    unsigned int32 ReceiptID;
63.    static TICKTYPE lastTick;
64.    TICKTYPE currTick;
65.    struct OBD_Packet OBDPacketToSend;
66.    struct OBD_Packet OBDFlowControlFrame;
67.    OBDPacketToSend.NBYTES  =0x02; //stardard packet
68.    OBDPacketToSend.MODO    =MODE; //Mostrar valor actual
69.    OBDPacketToSend.PID     =PID; //Mostrar PIS soportados
70.    OBDPacketToSend.DATA[0] =0x55; //No usados 55h
71.    OBDPacketToSend.DATA[1] =0x55;
72.    OBDPacketToSend.DATA[2] =0x55;
73.    OBDPacketToSend.DATA[3] =0x55;
74.    OBDPacketToSend.DATA[4] =0x55;
75.    
76.    
77.    OBDFlowControlFrame.NBYTES=0x30;
78.    OBDFlowControlFrame.MODO=0x07;
79.    OBDFlowControlFrame.PID=0xF9;
80.    
81.    i=0;
82.    *OBDPacket->NRecibidos=0;
83.    
84.    if(can_tbe())
85.    {  
86.       can_putd(ECU_ID,&OBDPacketToSend,8,3,0,0);
87.       currTick = lastTick=TickGet();
88.       TimeOut=False;
89.       do
90.       {
91.          currTick = TickGet();
92.          if(can_kbhit())
93.          {
94.            can_getd(ReceiptID,&OBDPacket->OBDPacketToSave[i],Alen,rxstat);
95.            OBDPacket->NRecibidos=OBDPacket->NRecibidos+1;
96.            //fprintf(DEBUG,"NRecibidos:%d\r\n",OBDPacket->NRecibidos);
97.            OBDPacket->Receipt_ID[i]=ReceiptID;
98.            //fprintf(DEBUG,"ReceiptID:%lx\r\n",OBDPacket->Receipt_ID[i]);
99.            ByteCheck=OBDPacket->OBDPacketToSave[i].NBYTES;
100.            //fprintf(DEBUG,"ByteCheck:%x\r\n",ByteCheck);
101.            ByteCheck=ByteCheck&0xF0;
102.             if (ByteCheck==0x10)
103.             {    
104.                can_putd(ECU_ID,&OBDFlowControlFrame,3,3,0,0);
105.                fprintf(DEBUG,"First Frame detected\r\n");
106.             }
107.             else if (ByteCheck==0x20)
108.             {
109.                fprintf(DEBUG,"Consecutive Frame detected\r\n");
110.             }
111.             i++;
112.          }
113.          else if (TickGetDiff(currTick, lastTick) > (TICKS_PER_SECOND*5)) //4 segundos lo iremos ajustando hacia abajo
114.          {
115.             TimeOut=True;
116.             #ifdef PROGRAM_DEBUG
117.                fprintf(DEBUG,"TimeOut\r\n");
118.             #endif
119.             lastTick = currTick;
120.          }
121.       }while(!TimeOut); // cinco segundos o los datos
122.       if(OBDPacket->NRecibidos!=0)
123.       {
124.          return(EC_OK);
125.       }
126.       else
127.       {
128.          return(EC_TIMEOUT);
129.       }
130.    }
131.    else
132.    {
133.       return(EC_SENDBUFFERBUSY);
134.    }
135. }
136.  
137.  
138.  
139.  
140.  
141. void main()
142. {
143.  
144.    static struct ODB_MPacket OBDPacket;
145.    Set_tris_a(0x00);
146.    Set_tris_b(0x00);
147.    Set_tris_c(0x80);
148.    setup_timer_1(T1_INTERNAL|T1_DIV_BY_2);
149.    TickInit();
150.    can_init();
151.    enable_interrupts(INT_RDA);
152.    STACK_STATUS=GET_IMEI;
153.    CASE_STATUS=SEND_CMD;
154.    CONNECTION_STATUS=0;
155.    MODEM_STATUS=0;
156.    fprintf(DEBUG,"Ready\r\n")
157.    delay_ms(5000);
158.    fprintf(DEBUG,"Query Result%d\r\n",SendQuery(BroadcastID_11,0X01,0x00,&OBDPacket));
159.    while(true)
160.    {
161.      
162.    // GSM_STACK();
163.      
164.    }
165.  
166. }

[MGLSOFT]

int8 NBYTES;    //0 Numero bytes adicionales
   int8 MODO;      //1 Modo
   int8 PID;       //2 PID
   int8 DATA[5];    //3 Data

por que DATA esta limitado a 5 bytes??
Nunca usan los 8 posibles del CAN ??

[PICSHIRU]

Hasta donde se la trama se compone de, entre otras cosas, un id, un dlc y 8 bytes de datos que son los que guardo en la estructura, es cierto que podria usar un sencillo array de ocho elementos pero tengo previsto complicarlo mucho mas.

[MGLSOFT]

Podrias ampliaros au mas de como es ese protocolo y el uso de sus id ??
En lo que muestras no se ven cosas raras, pero eso no dice si esta bien o mal, ni que esta mal...

[JUAN_RAMON_RG]

Les paso un link en donde viene explicado lo de los pid y el uso de los 8 bytes que comenta el compañero...espero que les sirva

http://obdcon.sourceforge.net/2010/06/obd-ii-pids/

[afelio]

Buenos días,

Sabeis si en modo Loopback se atienden a las interrupciones??
Si lo hago sin interrupciones recibo el mensaje, pero al hacerlo por interrupciones en el PIC32 no atiende a éstas y no recibo ningún mensaje.

Un saludo.

[afelio]

Buenas,

Ya he verificado que si se puede acceder a las interrupciones en el modo Loopback. Era un error de configuración en las interrupciones.

Pero ahora me surge una duda sobre los datos.

Tenemos en la estructura BYTE data[8]

Me pregunto si se podría cargar en la misma función de transmitir
data[0] = 0xAA
data[1] = 0xBB
...
...

Muchas gracias.
Un saludo.

[peteorito]

Hola:
 Despues de  llevar un tiempo cacharreando con el CAN , me he puesto a ver  las configuraciones,   segun he leido  con estos parametros que son los que trae el CCS por defecto estamos trabajando ¿con un Cristal de 20mhz y un velocidad de  transmision de 125KPBS?, pero mi duda sale que cuando lo intento calcular con  el programa que se habla en la pagina 2 del post que no me coinciden, conoceis alguna web para calcularlo a mano , o vengan ex`plicado cada parametro . Gracias!

Código: C

1. #include "can-18F4580.c"
2. #define CAN_BRG_SYNCH_JUMP_WIDTH  0  //synchronized jump width (def: 1 x Tq)
3. #define CAN_BRG_PRESCALAR  4  //baud rate generator prescalar (def: 4) ( Tq = (2 x (PRE + 1))/Fosc )
4. #define CAN_BRG_PHASE_SEGMENT_1  5 //phase segment 1 (def: 6 x Tq)
5. #define CAN_BRG_PROPAGATION_TIME 2 //propagation time select (def: 3 x Tq)
6. #define CAN_BRG_PHASE_SEGMENT_2 5 //phase segment 2 time select (def: 6 x Tq)

[JUAN_RAMON_RG]

Muy buenas noches..estoy haciendo un proyecto de comunicacion can bus con un automovil ...pero alguien tiene idea de las configuracion de velocidad con las que se comunica el can bus del automovil...gracias.