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

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

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #675 en: 23 de Diciembre de 2009, 15:07:48 »
ok vamos a ver

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #676 en: 28 de Diciembre de 2009, 12:20:55 »
enviaré respuesta en 3 o 4 mensajes
« Última modificación: 28 de Diciembre de 2009, 12:36:24 por penguin »

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #677 en: 28 de Diciembre de 2009, 12:23:44 »
///////////////////////1r mensaje////////////////////////////////////////////

bueno disculpad el retraso, he ido haciendo otraspruebas fallidas...en fin uno se cansa de morder polvo!
Bueno hay librerías que uso pero que no modifico en abslouto, trate de ponerlas todas y se excedia en gran mesura el limite establecido, asi que las que no use, simplemente las enumeraré y sólo escribiré las que si modifico. Ahí va, tb comento lo que hago en cada uan de ellas. He de decir que para hacerla prueba "tonta" leo por SO ( osciloscopio) y no devuebe nada... ¿ no sabe contestar el pic o no envio bien las ordenes?

1) El main, el principal.
En el main, la única linea que "es importante" es la referente a la construcción de un frame de CAN y su posterior envio. Eso me falla, ya que no veo absolutamente nada por can high ni can low, asi que lo que se ve antes de eso, son simples pruebas que deberian ver donde falla el asunto. Es decir, trato de escribir por SPI ( son en paquetes de 3) lo siguiente :
1. escribir :implica, por SPI orden escribir, escribir direccion y escribir data
leer:implica por SPI orden escribir, escribir direccion y automaticamente el MCP contesta por SO ( a SPI PIC). LA 3a escritura es de relleno.
Muestro:
Código: C
  1. #include <18F4550.h>
  2. #include <stdlib.h>
  3. #fuses HS,NOPROTECT,NOLVP,NOWDT,XTPLL,PLL5,NOPROTECT,USBDIV,CPUDIV2
  4. //#fuses HS,NOPROTECT,NOLVP,NOWDT,NOPROTECT,USBDIV,CPUDIV2
  5. #use delay(clock=48000000)
  6. #include <spi-can-mcp2510.c>
  7. //#define CAN_DO_DEBUG TRUE
  8. #define Set_125K_Baud TRUE
  9. #byte   porta = 0xf80
  10. #byte   portb = 0xf81
  11. #byte   portc = 0xf82
  12. #byte   portd = 0xf83
  13. #byte   porte = 0xf84
  14. #byte   t1con = 0xfcd
  15. #byte   latd = 0xf8c
  16. #byte   adcon0 = 0xfc2
  17. #byte   adcon1 = 0xfc1
  18. #byte   adcon2 = 0xfc0
  19. #byte   adresl = 0xfc3
  20. #byte   adresh = 0xfc4
  21. #use fast_io (D)
  22. #byte PORTD= 0XF83
  23.  
  24.  
  25.  
  26. void main() {
  27.    struct rx_stat rxstat;
  28.    int32 rx_id;
  29.    int buffer[8];
  30.    int i,rx_len,lectura;
  31.  
  32.    set_tris_d(0x01);
  33.    setup_spi(SPI_MASTER | SPI_H_TO_L|spi_clk_div_4);
  34.    rx_id=0x01;
  35.    buffer[0]=0x08;
  36.  
  37.  
  38.  //setup_timer_2(T2_DIV_BY_4,79,16); //setup up timer2 to interrupt every 1ms if using //20Mhz clock
  39.    can_init();
  40.   //enable_interrupts(INT_TIMER2);
  41.    enable_interrupts(GLOBAL);
  42.  
  43.  
  44.  
  45.  
  46.  
  47.  
  48. while(TRUE){
  49.  
  50.   output_high(pin_d1);
  51.   //si diera probelmas por SLEEP,moifico aqui el byte para configurar a que no lo esté
  52.   output_low(pin_a5);
  53.   spi_write(0x02);// orden escribir
  54.   spi_write(0x0f); //direc. de mem. donde hacerlo CANCTRL -CAN CONTROL REGISTER //(ADDRESS: XFh)
  55.   spi_write(0x00); // data a escribir
  56.  
  57. // NOTA: tb he hecho esta prueba abajo en data, ya que leyendo datasheet pone cuidado con...
  58.      //spi_write(0xe0) -->he modificado 0x00 por 0xe0 para ver resultado.
  59.  
  60.   output_high(pin_a5);
  61.  
  62.  
  63.  
  64.   //configurar pines recepcion no interrupcion
  65.  
  66.   output_low(pin_a5);
  67.   spi_write(0x02); //orden escribir
  68.   spi_write(0x0c); //direccion de memmoria de BFPCTRL - RXNBF PIN CONTROL AND //STATUS REGISTER
  69.   spi_write(0x20); //data -configuracion de pines-
  70.   output_high(pin_a5);
  71.  
  72.   //configurar pins enviament, cap sense int ( i/o solament)
  73.  
  74.   output_low(pin_a5);
  75.   spi_write(0x02); //orden escribir
  76.   spi_write(0x0c); //direccion de memoria de TXRTSCTRL - TXNRTS PIN CONTROL AND //STATUS REGISTER
  77.   spi_write(0x00); //data -configuracion de pines-
  78.   output_high(pin_a5);
  79.  
  80.  
  81.  
  82.  
  83.  //prueba escribir
  84.   output_low(pin_a5);
  85.   spi_write(0x02);// orden escribir
  86.   spi_write(0x36); //direccion de memoria donde hacerlo
  87.   spi_write(0x07); // data a escribir
  88.   output_high(pin_a5);
  89.  
  90.   //prueba leer
  91.  
  92.   output_low(pin_a5);
  93.   spi_write(0x03);   // orden leer
  94.   spi_write(0x36);  // direccion de memoria donde hacerlo
  95.   spi_write(0x00);//relleno
  96.   output_high(pin_a5);
  97.      /*if ( can_tbe()){
  98.      can_putd(0x01,&buffer[0],8,1,TRUE,0);
  99.      }*/
  100. }
  101. }
  102.  

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #678 en: 28 de Diciembre de 2009, 12:34:50 »
/////  2  /////////////////////

librerías que uso pero no modifico ( las enumero, no la spongo porque no da cabida el mensaje)


a) 18f4550.h
b) stdlib.h
c) stddef.h
d) string.h
e) ctype.h

Y las que si modifico, son can-mcp2510.c y can-mcp2510.h, que cambio como spi-can-mcp2510.c y can-mcp2510.h ( ésta última se modifica, pero no he cambiado nombre).
Razón de modificación : usar SPI lectura y escritura) por Hardware, ya que mi pic dispone de SPI, al menos la lectura/escritura no ha de simularla. Las demas opciones, es decir, uso de interrupciones y registros si son por SW, es decir, no uso los pines específicos del MCP2510 para interrupciones:



2) spi-can-mcp2510.c
Código: C
  1.  
  2.  
  3. #include <can-mcp2510.h>
  4.  
  5.  
  6.  
  7. //IO pins connected to MCP2510
  8. #ifndef EXT_CAN_CS
  9.    //#define EXT_CAN_CS   PIN_B1 //por defecto estos
  10.    //#define EXT_CAN_SI   PIN_C1
  11.    //#define EXT_CAN_SO   PIN_C0
  12.    //#define EXT_CAN_SCK  PIN_C3
  13.  
  14.    // cambio para usar en PIC18F4550 modo HW
  15.    #define EXT_CAN_CS   PIN_A5
  16.    #define EXT_CAN_SI   PIN_B0
  17.    #define EXT_CAN_SO   PIN_C7
  18.    #define EXT_CAN_SCK  PIN_B1
  19.  
  20. //   #define EXT_CAN_RESET   PIN_B5 //CCS library does not use this pin by default
  21. //   #define EXT_CAN_TX0RTS  PIN_C4 //CCS library does not use this pin by default
  22. //   #define EXT_CAN_TX1RTS  PIN_B4 //CCS library does not use this pin by default
  23. //   #define EXT_CAN_TX2RTS  PIN_C2 //CCS library does not use this pin by default
  24. #endif
  25.  
  26. #if CAN_DO_DEBUG
  27.  #define can_debug printf
  28. #else
  29.  #define can_debug
  30. #endif
  31.  
  32.  
  33.  
  34.  
  35. int  prescaler;
  36. int1 clkenable;
  37.  
  38.  
  39. ////////////////////////////////////////////////////////////////////////
  40. //
  41. // can_init()
  42. //
  43. // Initializes MCP2510 CAN peripheral.  Sets the RX filter and masks so the
  44. // CAN peripheral will receive all incoming IDs.  Configures both RX buffers
  45. // to only accept valid valid messages (as opposed to all messages, or all
  46. // extended message, or all standard messages).
  47. //
  48. // The constants (CAN_USE_RX_DOUBLE_BUFFER, CAN_ENABLE_DRIVE_HIGH,
  49. // CAN_ENABLE_CAN_CAPTURE, etc) are given a default define in the can-mcp2510.h file.
  50. // These default values can be overwritten in the main code, but most
  51. // applications will be fine with these defaults.
  52. //
  53. //////////////////////////////////////////////////////////////////////////////
  54. void can_init(void) {
  55.    struct struct_RXB0CTRL b_rxb0ctrl;
  56.  
  57.    mcp2510_init();
  58.  
  59.    can_set_mode(CAN_OP_CONFIG);   //must be in config mode before params can be set
  60.    can_set_baud();
  61.  
  62.    b_rxb0ctrl=0;
  63.    b_rxb0ctrl.rxm=CAN_RX_VALID;
  64.    b_rxb0ctrl.bukt=CAN_USE_RX_DOUBLE_BUFFER;
  65.    mcp2510_write(RXB0CTRL, (int)b_rxb0ctrl);
  66.    mcp2510_write(RXB1CTRL, (int)b_rxb0ctrl);
  67.  
  68.    //if you want to configure the TXnRTS pins, do it here.  default is off
  69.  
  70.    can_set_id(RX0MASK, CAN_MASK_ACCEPT_ALL, CAN_USE_EXTENDED_ID);  //set mask 0 (RX BUFFER 0)
  71.    can_set_id(RX0FILTER0, 0, CAN_USE_EXTENDED_ID);  //set filter 0 of mask 0 (RX BUFFER 0)
  72.    can_set_id(RX0FILTER1, 0, CAN_USE_EXTENDED_ID);  //set filter 1 of mask 0 (RX BUFFER 0)
  73.  
  74.    can_set_id(RX1MASK, CAN_MASK_ACCEPT_ALL, CAN_USE_EXTENDED_ID);  //set mask 1 (RX BUFFER 1)
  75.    can_set_id(RX1FILTER2, 0, CAN_USE_EXTENDED_ID);  //set filter 0 of mask 1 (RX BUFFER 1)
  76.    can_set_id(RX1FILTER3, 0, CAN_USE_EXTENDED_ID);  //set filter 1 of mask 1 (RX BUFFER 1)
  77.    can_set_id(RX1FILTER4, 0, CAN_USE_EXTENDED_ID);  //set filter 2 of mask 1 (RX BUFFER 1)
  78.    can_set_id(RX1FILTER5, 0, CAN_USE_EXTENDED_ID);  //set filter 3 of mask 1 (RX BUFFER 1)
  79.  
  80.    can_set_mode(CAN_OP_NORMAL);
  81. }
  82.  
  83. ////////////////////////////////////////////////////////////////////////
  84. //
  85. // can_set_baud()
  86. //
  87. // Configures the baud rate control registers.  All the defines here
  88. // are defaulted in the can-mcp2510.h file.  These defaults can, and
  89. // probably should, be overwritten in the main code.
  90. //
  91. // Current defaults are set to work with CCS's CAN Prototype board and
  92. // Microchip's MCP250xxx CAN Developers Kit if this PIC is running at 20Mhz.
  93. //
  94. ////////////////////////////////////////////////////////////////////////
  95.  
  96. /* void can_set_baud(void) {   // modificada abajo
  97.    struct struct_CNF1 new_CNF1;
  98.    struct struct_CNF2 new_CNF2;
  99.    struct struct_CNF3 new_CNF3;
  100.  
  101.  
  102.    new_CNF1.brp=CAN_BRG_PRESCALAR;
  103.    new_CNF1.sjw=CAN_BRG_SYNCH_JUMP_WIDTH;
  104.  
  105.    new_CNF2.prseg=CAN_BRG_PROPAGATION_TIME;
  106.    new_CNF2.phseg1=CAN_BRG_PHASE_SEGMENT_1;
  107.    new_CNF2.sam=CAN_BRG_SAM;
  108.    new_CNF2.btlmode=CAN_BRG_SEG_2_PHASE_TS;
  109.  
  110.    new_CNF3.phseg2=CAN_BRG_PHASE_SEGMENT_2;
  111.    new_CNF3.wakfil=CAN_BRG_WAKE_FILTER;
  112.  
  113.    mcp2510_write(CNF1, (int)new_CNF1);
  114.    mcp2510_write(CNF2, (int)new_CNF2);
  115.    mcp2510_write(CNF3, (int)new_CNF3);
  116. }*/
  117.  
  118. void can_set_baud(void) {
  119.  /*# ifdef Set_125K_Baud {
  120.      BRGCON1 = 0x01;
  121.      BRGCON2 = 0xBA;      //modificado 5/11/07 para usar CAN a 125 KBps
  122.      BRGCON3 = 0x07;      //con reloj a 10 MHz
  123.   }
  124.   #endif */
  125.  
  126.   #ifdef Set_250K_Baud {
  127.      BRGCON1 = 0x00;
  128.      BRGCON2 = 0xBA;      //modificado 5/11/07 para usar CAN a 250 KBps
  129.      BRGCON3 = 0x07;      //con reloj a 10 MHz
  130.   }
  131.   #endif
  132.   #ifdef Set_500K_Baud {
  133.      BRGCON1 = 0x00;
  134.      BRGCON2 = 0x92;      //modificado 5/11/07 para usar CAN a 500 KBps
  135.      BRGCON3 = 0x02;      //con reloj a 10 MHz
  136.   }
  137.   #endif
  138. #ifdef Set_125_Baud {
  139.      BRGCON1 = 0x07;
  140.      BRGCON2 = 0xBE;      //modificado 7/12/09 para usar CAN a 125 KBps
  141.      BRGCON3 = 0x07;      //con reloj a 48 MHz
  142.    }
  143.   #endif
  144. /*
  145. #ifdef Set_125_Baud {
  146.      BRGCON1 = 0x03;
  147.      BRGCON2 = 0xBA;      //modificado 7/12/09 para usar CAN a 125 KBps
  148.      BRGCON3 = 0x07;      //con cristal a 20 MHz
  149.    }
  150.  #endif
  151. */
  152.  
  153. }
  154.  
  155. void can_set_mode(CAN_OP_MODE mode) {
  156.    struct struct_CANCTRL old_CANCTRL;
  157.  
  158.    old_CANCTRL=mcp2510_read(CANCTRL);
  159.  
  160.    old_CANCTRL.reqop=mode;
  161.  
  162.    mcp2510_write(CANCTRL, (int)old_CANCTRL);
  163.  
  164.    do {
  165.       old_CANCTRL=mcp2510_read(CANCTRL);
  166.    } while (old_CANCTRL.reqop != mode);
  167.  
  168.  }
  169.  
  170.  
  171. ///// void can_set_clk(CAN_OP_MODE prescaler)//////////////////////////////////
  172. ////////////////////////////////////////////////////////////////////////////////
  173. //void can_set_clk(CAN_OP_MODE prescaler) {   // funcio pel presclaer del clock del MCP
  174. void can_set_clk(){     //cambio capçalera perque no vull que retorni res. Crida funcio i executa.
  175.   struct struct_CANCTRL old_CANCTRL;
  176.  
  177.    old_CANCTRL=mcp2510_read(CANCTRL);
  178.   // old_CANCTRL.clkpre=0; // modifica els 2 bits del registre CANCTRL per posar a 1 el escaler
  179.  
  180.   prescaler=0; // 0  es el valor que vull de presclaer (0b00)
  181.  
  182.    old_CANCTRL.clkpre=prescaler;     //********** falta activació del pin!!!!!!!!!!!!!!!!!!!!!!!!!!
  183.  
  184.    mcp2510_write(CANCTRL, (int)old_CANCTRL);
  185.  
  186.    do {
  187.       old_CANCTRL=mcp2510_read(CANCTRL);
  188.    } while (old_CANCTRL.clkpre != prescaler);
  189. }
  190.  
  191. ////////////////////////////////////////////////////////////////////////////////
  192. //void can_set_clken() {   // activar pin clckout del mcp2510
  193. void can_set_clken(int1 cambiaa){     //cambio capçalera perque no vull que retorni res. Crida funcio i executa.
  194.   struct struct_CANCTRL old_CANCTRL;
  195.  
  196.    old_CANCTRL=mcp2510_read(CANCTRL);
  197.  
  198.   //clkenable=0; // 0  es el valor que vull de presclaer (0b00)
  199.  
  200.    //old_CANCTRL.clken=clkenable;     //********** falta activació del pin!!!!!!!!!!!!!!!!!!!!!!!!!!
  201.      old_CANCTRL.clken=cambiaa;
  202.  
  203.    mcp2510_write(CANCTRL, (int)old_CANCTRL);
  204.  
  205.    do {
  206.       old_CANCTRL=mcp2510_read(CANCTRL);
  207.    } while (old_CANCTRL.clkpre != prescaler);
  208. }
  209.  
  210. ////////////////////////////////////////////////////////////////////////
  211. //
  212. // can_set_id()
  213. //
  214. // Configures the xxxxEIDL, xxxxEIDH, xxxxSIDL and xxxxSIDH registers to
  215. // configure the defined buffer to use the specified ID
  216. //
  217. //   Paramaters:
  218. //     addr - pointer to first byte of ID register, starting with xxxxEIDL.
  219. //            For example, a pointer to RXM1EIDL
  220. //     id - ID to set buffer to
  221. //     ext - Set to TRUE if this buffer uses an extended ID, FALSE if not
  222. //
  223. ////////////////////////////////////////////////////////////////////////
  224. void can_set_id(int addr, int32 id, int1 ext) {
  225.    int converted_id[4];
  226.    int *ptr;
  227.  
  228.    ptr=&converted_id[3];   //3=eidl, 2=eidh, 1=sidl, 0=sidh
  229.  
  230.    if (ext) {  //extended
  231.       //eidl
  232.       *ptr=make8(id,0); //0:7
  233.  
  234.       //eidh
  235.       ptr--;
  236.       *ptr=make8(id,1); //8:15
  237.  
  238.       //sidl
  239.       ptr--;
  240.       *ptr=make8(id,2) & 0x03;   //16:17
  241.       *ptr|=(make8(id,2) << 3) & 0xE0; //18:20
  242.       *ptr|=0x08;
  243.  
  244.  
  245.       //sidh
  246.       ptr--;
  247.       *ptr=((make8(id,2) >> 5) & 0x07 ); //21:23
  248.       *ptr|=((make8(id,3) << 3) & 0xF8);//24:28
  249.    }
  250.    else {   //standard
  251.       //eidl
  252.       *ptr=0;
  253.  
  254.       //eidh
  255.       ptr--;
  256.       *ptr=0;
  257.  
  258.       //sidl
  259.       ptr--;
  260.       *ptr=(make8(id,0) << 5) & 0xE0;
  261.  
  262.       //sidh
  263.       ptr--;
  264.       *ptr=(make8(id,0) >> 3) & 0x1F;
  265.       *ptr|=(make8(id,1) << 5) & 0xE0;
  266.    }
  267.  
  268.    //0=eidl, 1=eidh, 2=sidl, 3=sidh
  269.    mcp2510_write(addr--, converted_id[3]);
  270.    mcp2510_write(addr--, converted_id[2]);
  271.    mcp2510_write(addr--, converted_id[1]);
  272.    mcp2510_write(addr, converted_id[0]);
  273. }
  274.  
  275. ////////////////////////////////////////////////////////////////////////
  276. //
  277. // can_get_id()
  278. //
  279. // Returns the ID of the specified buffer.  (The opposite of can_set_id())
  280. // This is used after receiving a message, to see which ID sent the message.
  281. //
  282. //   Paramaters:
  283. //     addr - pointer to first byte of ID register, starting with xxxxEIDL.
  284. //            For example, a pointer to RXM1EIDL
  285. //     ext - Set to TRUE if this buffer uses an extended ID, FALSE if not
  286. //
  287. //   Returns:
  288. //     The ID of the buffer
  289. //
  290. ////////////////////////////////////////////////////////////////////////
  291. int32 can_get_id(int addr, int1 ext) {
  292.    int32 ret;
  293.    int * ptr;
  294.    int converted_id[4];
  295.  
  296.    ptr=&converted_id[3];   //3=eidl, 2=eidh, 1=sidl, 0=sidh
  297.  
  298.    converted_id[3]=mcp2510_read(addr--);
  299.    converted_id[2]=mcp2510_read(addr--);
  300.    converted_id[1]=mcp2510_read(addr--);
  301.    converted_id[0]=mcp2510_read(addr);
  302.  
  303.    ret=0;
  304.  
  305.  
  306.    if (ext) {
  307.       ret=*ptr;  //eidl
  308.  
  309.       ptr--;     //eidh
  310.       ret|=((int32)*ptr << 8);
  311.  
  312.       ptr--;     //sidl
  313.       ret|=((int32)*ptr & 0x03) << 16;
  314.       ret|=((int32)*ptr & 0xE0) << 13;
  315.  
  316.       ptr--;     //sidh
  317.       ret|=((int32)*ptr << 21);
  318.    }
  319.    else {
  320.       ptr-=2;    //sidl
  321.       ret=((int32)*ptr & 0xE0) >> 5;
  322.  
  323.       ptr--;     //sidh
  324.       ret|=((int32)*ptr << 3);
  325.    }
  326.  
  327.    return(ret);
  328. }
  329.  
  330. ////////////////////////////////////////////////////////////////////////
  331. //
  332. // can_putd()
  333. //
  334. // Puts data on a transmit buffer, at which time the CAN peripheral will
  335. // send when the CAN bus becomes available.
  336. //
  337. //    Paramaters:
  338. //       id - ID to transmit data as
  339. //       data - pointer to data to send
  340. //       len - length of data to send
  341. //       priority - priority of message.  The higher the number, the
  342. //                  sooner the CAN peripheral will send the message.
  343. //                  Numbers 0 through 3 are valid.
  344. //       ext - TRUE to use an extended ID, FALSE if not
  345. //       rtr - TRUE to set the RTR (request) bit in the ID, false if NOT
  346. //
  347. //    Returns:
  348. //       If successful, it will return TRUE
  349. //       If un-successful, will return FALSE
  350. //
  351. ////////////////////////////////////////////////////////////////////////
  352. int1 can_putd(int32 id, int * data, int len, int priority, int1 ext, int1 rtr) {
  353.    int i;
  354.    int port;
  355.  
  356.    int TXRXBaD0;
  357.    int TXBaCTRL;
  358.    int TXRXBaEIDL;
  359.    int TXBaDLC;
  360.  
  361.    struct txbNctrl_struct b_TXBaCTRL;
  362.    struct rxbNdlc_struct b_TXBaDLC;
  363.    struct txbNctrl_struct b_TXB0CTRL, b_TXB1CTRL, b_TXB2CTRL;
  364.  
  365.    b_TXB0CTRL=mcp2510_read(TXB0CTRL);
  366.    b_TXB1CTRL=mcp2510_read(TXB1CTRL);
  367.    b_TXB2CTRL=mcp2510_read(TXB2CTRL);
  368.  
  369.     // find emtpy transmitter
  370.     //map access bank addresses to empty transmitter
  371.    if (!b_TXB0CTRL.txreq) {
  372.       TXRXBaD0=TXB0D0;
  373.       TXBaCTRL=TXB0CTRL;
  374.       TXRXBaEIDL=TXB0EIDL;
  375.       TXBaDLC=TXB0DLC;
  376.       port=0;
  377.    }
  378.    else if (!b_TXB1CTRL.txreq) {
  379.       TXRXBaD0=TXB1D0;
  380.       TXBaCTRL=TXB1CTRL;
  381.       TXRXBaEIDL=TXB1EIDL;
  382.       TXBaDLC=TXB1DLC;
  383.       port=1;
  384.    }
  385.    else if (!b_TXB2CTRL.txreq) {
  386.       TXRXBaD0=TXB2D0;
  387.       TXBaCTRL=TXB2CTRL;
  388.       TXRXBaEIDL=TXB2EIDL;
  389.       TXBaDLC=TXB2DLC;
  390.       port=2;
  391.    }
  392.    else {
  393.       #if CAN_DO_DEBUG
  394.          can_debug("\r\nCAN_PUTD() FAIL: NO OPEN TX BUFFERS\r\n");
  395.       #endif
  396.       return(0);
  397.    }
  398.  
  399.    //set priority.
  400.    b_TXBaCTRL=mcp2510_read(TXBaCTRL);
  401.    b_TXBaCTRL.txpri=priority;
  402.    mcp2510_write(TXBaCTRL, (int)b_TXBaCTRL);
  403.  
  404.    //set tx mask
  405.    can_set_id(TXRXBaEIDL, id, ext);
  406.  
  407.    //set tx data count
  408.    b_TXBaDLC=len;
  409.    b_TXBaDLC.rtr=rtr;
  410.    mcp2510_write(TXBaDLC, (int)b_TXBaDLC);
  411.  
  412.    //write to buffer
  413.     for (i=TXRXBaD0; i<(TXRXBaD0 + len); i++) {
  414.       mcp2510_write(i,*data);
  415.       data++;
  416.     }
  417.  
  418.    //enable transmission
  419.    b_TXBaCTRL=mcp2510_read(TXBaCTRL);
  420.    b_TXBaCTRL.txreq=1;
  421.    mcp2510_write(TXBaCTRL, (int)b_TXBaCTRL);
  422.  
  423.    #if CAN_DO_DEBUG
  424.             can_debug("\r\nCAN_PUTD(): BUFF=%U ID=%LX LEN=%U PRI=%U EXT=%U RTR=%U\r\n", port, id, len, priority, ext, rtr);
  425.             if ((len)&&(!rtr)) {
  426.                data-=len;
  427.                can_debug("  DATA = ");
  428.                for (i=0;i<len;i++) {
  429.                   can_debug("%X ",*data);
  430.                   data++;
  431.                }
  432.                can_debug("\r\n");
  433.             }
  434.    #endif
  435.  
  436.    return(1);
  437. }
  438.  
  439. ////////////////////////////////////////////////////////////////////////
  440. //
  441. // can_getd()
  442. //
  443. // Gets data from a receive buffer, if the data exists
  444. //
  445. //    Returns:
  446. //      id - ID who sent message
  447. //      data - pointer to array of data
  448. //      len - length of received data
  449. //      stat - structure holding some information (such as which buffer
  450. //             recieved it, ext or standard, etc)
  451. //
  452. //    Returns:
  453. //      Function call returns a TRUE if there was data in a RX buffer, FALSE
  454. //      if there was none.
  455. //
  456. ////////////////////////////////////////////////////////////////////////
  457. int1 can_getd(int32 & id, int * data, int & len, struct rx_stat & stat)
  458. {
  459.     int i;
  460.  
  461.    struct struct_RXB0CTRL b_RXB0CTRL;
  462.    struct struct_RXB1CTRL b_RXB1CTRL;
  463.    struct struct_EFLG b_EFLG;
  464.  
  465.    int RXBaDLC;
  466.    struct rxbNdlc_struct b_RXBaDLC;
  467.  
  468.    int TXRXBaSIDL;
  469.    struct struct_TXRXBaSIDL b_TXRXBaSIDL;
  470.  
  471.  
  472.    int RXBaD0;
  473.    struct struct_CANINTF b_CANINTF;
  474.  
  475.    b_CANINTF=mcp2510_read(CANINTF);
  476.  
  477.    b_RXB0CTRL=mcp2510_read(RXB0CTRL);
  478.    b_RXB1CTRL=mcp2510_read(RXB1CTRL);
  479.    b_EFLG=mcp2510_read(EFLG);
  480.  
  481.     if (b_CANINTF.rx0if) {
  482.         stat.buffer=0;
  483.  
  484.         stat.err_ovfl=b_EFLG.rx0ovr;
  485.         b_EFLG.rx0ovr=0;
  486.         mcp2510_write(EFLG, (int)b_EFLG);
  487.  
  488.         if (b_RXB0CTRL.bukt) {
  489.          stat.filthit=b_RXB0CTRL.filhit0;
  490.         }
  491.  
  492.         RXBaDLC=RXB0DLC;
  493.         TXRXBaSIDL=RXB0SIDL;
  494.         RXBaD0=RXB0D0;
  495.     }
  496.     else if (b_CANINTF.rx1if)
  497.     {
  498.         stat.buffer=1;
  499.  
  500.         stat.err_ovfl=b_EFLG.rx1ovr;
  501.         b_EFLG.rx1ovr=0;
  502.         mcp2510_write(EFLG, (int)b_EFLG);
  503.  
  504.  
  505.         stat.filthit=b_RXB1CTRL.filhit0;
  506.         RXBaDLC=RXB1DLC;
  507.         TXRXBaSIDL=RXB1SIDL;
  508.         RXBaD0=RXB1D0;
  509.     }
  510.     else {
  511.       #if CAN_DO_DEBUG
  512.          can_debug("\r\nFAIL ON CAN_GETD(): NO MESSAGE IN BUFFER\r\n");
  513.       #endif
  514.       return (0);
  515.     }
  516.  
  517.    //get count
  518.     b_RXBaDLC=mcp2510_read(RXBaDLC);
  519.     len = b_RXBaDLC.dlc;
  520.     stat.rtr=b_RXBaDLC.rtr;
  521.  
  522.    //was it extended or standard?
  523.     b_TXRXBaSIDL=mcp2510_read(TXRXBaSIDL);
  524.     stat.ext=b_TXRXBaSIDL.ext;
  525.     id=can_get_id(TXRXBaSIDL + 2,stat.ext);
  526.  
  527.    //get data
  528.     for ( i = RXBaD0; i < (RXBaD0 + len); i++ ) {
  529.          *data=mcp2510_read(i);
  530.         data++;
  531.     }
  532.  
  533.     stat.inv=b_CANINTF.merrf;
  534.     if (b_CANINTF.merrf) {
  535.       b_CANINTF.merrf=0;
  536.     }
  537.  
  538.     if (stat.buffer) {
  539.       b_CANINTF.rx1if=0;
  540.     }
  541.     else {
  542.       b_CANINTF.rx0if=0;
  543.     }
  544.     mcp2510_write(CANINTF, (int)b_CANINTF);
  545.  
  546.     #if CAN_DO_DEBUG
  547.        can_debug("\r\nCAN_GETD(): BUFF=%U ID=%LX LEN=%U OVF=%U ", stat.buffer, id, len, stat.err_ovfl);
  548.        can_debug("FILT=%U RTR=%U EXT=%U INV=%U", stat.filthit, stat.rtr, stat.ext, stat.inv);
  549.        if ((len)&&(!stat.rtr)) {
  550.           data-=len;
  551.           can_debug("\r\n    DATA = ");
  552.           for (i=0;i<len;i++) {
  553.             can_debug("%X ",*data);
  554.             data++;
  555.           }
  556.        }
  557.        can_debug("\r\n");
  558.     #endif
  559.  
  560.     return(1);
  561. }
  562.  
  563. ////////////////////////////////////////////////////////////////////////
  564. //
  565. // can_kbhit()
  566. //
  567. // Returns TRUE if there is data in the receive buffers
  568. //
  569. //////////////////////////////////////////////////////////////////////////////
  570. int1 can_kbhit(void) {
  571.    struct struct_CANINTF b_CANINTF;
  572.  
  573.    b_CANINTF=mcp2510_read(CANINTF);
  574.    if (b_CANINTF.rx0if || b_CANINTF.rx1if)
  575.       {return(1);}
  576.  
  577.    return(0);
  578. }
  579.  
  580. ////////////////////////////////////////////////////////////////////////
  581. //
  582. // can_tbe()
  583. //
  584. // Returns TRUE if the transmit buffers are empty and ready to transmit data
  585. //
  586. //////////////////////////////////////////////////////////////////////////////
  587. int1 can_tbe(void) {
  588.    struct txbNctrl_struct b_TXB0CTRL, b_TXB1CTRL, b_TXB2CTRL;
  589.  
  590.    b_TXB0CTRL=mcp2510_read(TXB0CTRL);
  591.    b_TXB1CTRL=mcp2510_read(TXB1CTRL);
  592.    b_TXB2CTRL=mcp2510_read(TXB2CTRL);
  593.  
  594.    if (!b_TXB0CTRL.txreq || !b_TXB1CTRL.txreq || !b_TXB2CTRL.txreq)
  595.       {return(1);}
  596.  
  597.    return(0);
  598. }

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #679 en: 28 de Diciembre de 2009, 12:35:43 »
Código: [Seleccionar]
///// 3  /////////




////////////////////////////////////////////////////////////////////////
//
// can_abort()
//
// Aborts all pending tranmissions.
//
//////////////////////////////////////////////////////////////////////////////
void can_abort(void) {
   struct struct_CANCTRL b_CANCTRL;

   b_CANCTRL=mcp2510_read(CANCTRL);
   b_CANCTRL.abat=1;
   mcp2510_write(CANCTRL, (int)b_CANCTRL);

   delay_ms(5);
   b_CANCTRL.abat=0;
   mcp2510_write(CANCTRL, (int)b_CANCTRL);
}




///////////////////
///
//
// SPI CODE. Antes por sofware, cambiando funciones para usar SPI por HW.
//
///
//////////////////

//data clocked in on rising edge
//data driven out on falling edge

/*int mcp2510_read(int address) /////////  Esta es por software ////////
  {
   int command[2];
   int i;
   int data;

   command[1]=0x03;
   command[0]=address;


   output_low(EXT_CAN_CS);

   for (i=0;i<16;i++) {

    output_bit(EXT_CAN_SI, shift_left(&command[0],2,0));
        output_high(EXT_CAN_SCK);
        output_low(EXT_CAN_SCK);
        }
 
       for (i=0;i<8;i++) {
       shift_left(&data,1,input(EXT_CAN_SO));
       output_high(EXT_CAN_SCK);
       output_low(EXT_CAN_SCK);
       }


   output_high(EXT_CAN_CS);

   return(data);
}*/

   /////////////////////////////////////////////////

////////////////////////////////////  Esta es por hardware //////////////////////////////////
int mcp2510_read(int address)
{
//enviar ( o sea escribir) al MCP desde el PIC que se quiere hacer.PIC contesta a la peticion de
//lectura ( y el que hemos dicho) sobre data. Devuelve data
 
 int data;

      output_low(EXT_CAN_CS); // pic espera intsrucción. Primero mira cual es:
      spi_write(0x03);    // escribir instrucción 0x03 es instruccion leer.Va a instruccion leer->
      spi_write(address); //escribir dirección de donde se quiere leer
      spi_read(data);     // escribir dato enviado por el pic
      output_high(EXT_CAN_CS);
      return(data);       //devuelbe lo que queremos leer
}
 
   ////////////////////////////////////////////////




/*
int mcp2510_status(void) { //////////////////// por software////////////////////////////
   int command;
   int data;
   int i;

   command=0xA0;

   output_low(EXT_CAN_CS);

   for (i=0;i<8;i++) {
      output_bit(EXT_CAN_SI, shift_left(&command,1,0));
      output_high(EXT_CAN_SCK);
      output_low(EXT_CAN_SCK);
   }
   for (i=0;i<8;i++) {
      shift_left(&data,1,input(EXT_CAN_SO));
      output_high(EXT_CAN_SCK);
      output_low(EXT_CAN_SCK);
   }
   for (i=0;i<8;i++) {
      output_high(EXT_CAN_SCK);
      output_low(EXT_CAN_SCK);
   }

   output_high(EXT_CAN_CS);

   return(data);
}*/

/////////////////////////////////////////////////////
////////////////////////////////////  Esta es por hardware //////////////////////////////////
int mcp2510_status(void) {
   int data;

   
   output_low(EXT_CAN_CS);   //podriamos hacer algo par comrpbar error, si la 2a lectura!=1a lectura
   spi_write(0xA0);
   spi_read(data);
   spi_read();
   output_high(EXT_CAN_CS);
   return(data);   ///////////
}


////////////////////////////////////////////////////

/*
void mcp2510_write(int address, int data) { //////////////////// por software////////////////////////////
   int command[3];
   int i;

   command[2]=0x02;
   command[1]=address;
   command[0]=data;

   output_low(EXT_CAN_CS);

   for (i=0;i<24;i++) {
      output_bit(EXT_CAN_SI, shift_left(&command[0],3,0));
      output_high(EXT_CAN_SCK);
      output_low(EXT_CAN_SCK);
   }

   output_high(EXT_CAN_CS);
} */

///////////////////////////////////////////////////////////////////////

////////////////////////////////////  Esta es por hardware //////////////////////////////////
void mcp2510_write(int address, int data) {



   output_low(EXT_CAN_CS);
   spi_write(0x02);           //
   spi_write(address);        //estas 2 siempre es spi_write ya que se ha de decir desde el pic la fun.
   spi_write(data);
   output_high(EXT_CAN_CS);

}
   



////////////////////////////////////////////////////////////////////////
 /*

void mcp2510_command(int command) {    /////////// por software  //////////////////////////
   int i;

   output_low(EXT_CAN_CS);

   for (i=0;i<8;i++) {
      output_bit(EXT_CAN_SI, shift_left(&command,1,0));
      output_high(EXT_CAN_SCK);
      output_low(EXT_CAN_SCK);
   }

   output_high(EXT_CAN_CS);
}*/

////////////////////////////////////////////// /por Hardware //////////////////////////////
void mcp2510_command(int command){

output_low(EXT_CAN_CS);
spi_write(command);
output_high(EXT_CAN_CS);
}


////////////////////////////////////////




/*
void mcp2510_init(void) {    /////////////   por software  //////////////////////////
   output_high(EXT_CAN_CS);
   output_low(EXT_CAN_SCK);

   #ifdef EXT_CAN_TX0RTS
    output_high(EXT_CAN_TX0RTS);
   #endif
   #ifdef EXT_CAN_TX1RTS
    output_high(EXT_CAN_TX1RTS);
   #endif
   #ifdef EXT_CAN_TX2RTS
    output_high(EXT_CAN_TX2RTS);
   #endif

  #ifdef EXT_CAN_TX0RTS
   output_high(EXT_CAN_RESET);
   output_low(EXT_CAN_RESET);
   output_high(EXT_CAN_RESET);
   delay_ms(5);
  #endif

   mcp2510_command(0xC0);   //reset
   delay_ms(5);
}   */


/////////////////////////////////////////////////////////////////

/////////////////////////////// por harware  ////////////////////////////////////
void mcp2510_init(void) {
   output_high(EXT_CAN_CS);


   #ifdef EXT_CAN_TX0RTS
    output_high(EXT_CAN_TX0RTS);
   spi_write(); orden de escribir
   #endif
   #ifdef EXT_CAN_TX1RTS
    output_high(EXT_CAN_TX1RTS);
   #endif
   #ifdef EXT_CAN_TX2RTS
    output_high(EXT_CAN_TX2RTS);
   #endif

  #ifdef EXT_CAN_TX0RTS
   output_high(EXT_CAN_RESET);
   output_low(EXT_CAN_RESET);
   output_high(EXT_CAN_RESET);
   delay_ms(5);
  #endif

   mcp2510_command(0xC0);   //reset
   delay_ms(5);
}
/////////////////////////////////////////////////////////////////

3) can-mcp2510.h ( modificada también)
Código: C
  1. /////////////////////////////////////////////////////////////////////////
  2. ////                        can-mcp2510.h                            ////
  3. ////                                                                 ////
  4. //// Prototypes, definitions, defines and macros used for and with   ////
  5. //// the CCS CAN library for the MCP2510 (and compatable) CAN IO     ////
  6. //// expanders.                                                      ////
  7. ////                                                                 ////
  8. //// (see can-mcp2510.c)                                             ////
  9. ////                                                                 ////
  10. /////////////////////////////////////////////////////////////////////////
  11. ////                                                                 ////
  12. //// Version History                                                 ////
  13. ////                                                                 ////
  14. ////  Apr 20 04 - Fixed a compling problem                           ////
  15. ////                                                                 ////
  16. /////////////////////////////////////////////////////////////////////////
  17. ////        (C) Copyright 1996,2003 Custom Computer Services         ////
  18. //// This source code may only be used by licensed users of the CCS  ////
  19. //// C compiler.  This source code may only be distributed to other  ////
  20. //// licensed users of the CCS C compiler.  No other use,            ////
  21. //// reproduction or distribution is permitted without written       ////
  22. //// permission.  Derivative programs created using this software    ////
  23. //// in object code form are not restricted in any way.              ////
  24. /////////////////////////////////////////////////////////////////////////
  25.  
  26. #ifndef __CCS_CANMCP2510_LIB_DEFINES__
  27. #define __CCS_CANMCP2510_LIB_DEFINES__
  28.  
  29. #ifndef CAN_DO_DEBUG
  30.  #define CAN_DO_DEBUG FALSE
  31. #endif
  32.  
  33. #IFNDEF CAN_USE_EXTENDED_ID
  34.   #define CAN_USE_EXTENDED_ID         TRUE
  35. #ENDIF
  36.  
  37. #IFNDEF CAN_BRG_SYNCH_JUMP_WIDTH
  38.   #define CAN_BRG_SYNCH_JUMP_WIDTH  0  //synchronized jump width (def: 1 x Tq)
  39. #ENDIF
  40.  
  41. #IFNDEF CAN_BRG_PRESCALAR
  42.   #define CAN_BRG_PRESCALAR  4  //baud rate generator prescalar (def: 4) ( Tq = (2 x (PRE + 1))/Fosc )
  43. #ENDIF
  44.  
  45. #ifndef CAN_BRG_SEG_2_PHASE_TS
  46.  #define CAN_BRG_SEG_2_PHASE_TS   TRUE //phase segment 2 time select bit (def: freely programmable)
  47. #endif
  48.  
  49. #ifndef CAN_BRG_SAM
  50.  #define CAN_BRG_SAM 0 //sample of the can bus line (def: bus line is sampled 1 times prior to sample point)
  51. #endif
  52.  
  53. #ifndef CAN_BRG_PHASE_SEGMENT_1
  54.  #define CAN_BRG_PHASE_SEGMENT_1  5 //phase segment 1 (def: 6 x Tq)
  55. #endif
  56.  
  57. #ifndef CAN_BRG_PROPAGATION_TIME
  58.  #define CAN_BRG_PROPAGATION_TIME 2 //propagation time select (def: 3 x Tq)
  59. #endif
  60.  
  61. #ifndef CAN_BRG_WAKE_FILTER
  62.  #define CAN_BRG_WAKE_FILTER FALSE   //selects can bus line filter for wake up bit
  63. #endif
  64.  
  65. #ifndef CAN_BRG_PHASE_SEGMENT_2
  66.  #define CAN_BRG_PHASE_SEGMENT_2 5 //phase segment 2 time select (def: 6 x Tq)
  67. #endif
  68.  
  69. #ifndef CAN_USE_RX_DOUBLE_BUFFER
  70.  #define CAN_USE_RX_DOUBLE_BUFFER TRUE   //if buffer 0 overflows, do NOT use buffer 1 to put buffer 0 data
  71. #endif
  72.  
  73. #ifndef CAN_ENABLE_DRIVE_HIGH
  74.  #define CAN_ENABLE_DRIVE_HIGH 0
  75. #endif
  76.  
  77. #ifndef CAN_ENABLE_CAN_CAPTURE
  78.  #define CAN_ENABLE_CAN_CAPTURE 0
  79. #endif
  80.  
  81. enum CAN_OP_MODE {CAN_OP_CONFIG=4, CAN_OP_LISTEN=3, CAN_OP_LOOPBACK=2, CAN_OP_SLEEP=1, CAN_OP_NORMAL=0};
  82.  
  83. //can control
  84. struct struct_CANCTRL {
  85.    int  clkpre:2; //0:1 //clkout pin prescalar
  86.    int1 clken; //2   //clkout pin enable
  87.    int1 void3; //3
  88.    int1 abat;  //4   //abort all pending transmissions
  89.    CAN_OP_MODE reqop:3; //5:7 //request operation mode
  90. };
  91. #define CANCTRL   0x0F  //or 1f, or 2f, or 3f ... or 7f
  92.  
  93. enum CAN_INT_CODE {CAN_INT_RX1=7, CAN_INT_RX0=6, CAN_INT_TX2=5, CAN_INT_TX1=4, CAN_INT_TX0=3, CAN_INT_WAKEUP=2, CAN_INT_ERROR=1, CAN_INT_NO=0};
  94.  
  95. //can status register READ-ONLY
  96. struct struct_CANSTAT {
  97.    int1 void0;   //0
  98.    CAN_INT_CODE icode:3;   //1:3   //interrupt code
  99.    int1 void4;   //4
  100.    CAN_OP_MODE opmode:3;   //5:7   //operation mode status
  101. };
  102. #define CANSTAT 0x0E //or 1e, or 2e ... or 7e
  103.  
  104. //error flag register
  105. struct struct_EFLG {
  106.    int1 ewarn;      //0 //error warning
  107.    int1 rxwar;      //1 //receiver warning
  108.    int1 txwar;      //2 //transmitter warning
  109.    int1 rxep;   //3 //receive error passive flag
  110.    int1 txep;   //4 //transmit error passive flag
  111.    int1 txbo;   //5   //bus off error flag
  112.    int1 rx0ovr;   //6   //receive buffer 0 overflow
  113.    int1 rx1ovr;   //7   //receive buffer 1 overflow
  114. };
  115. #define EFLG   0x2D
  116.  
  117. //interupt enable register
  118. struct struct_CANINTE {
  119.    int1 rx0ie; //0   //receive buffer 0 full interrupt enable
  120.    int1 rx1ie; //1   //receive buffer 1 full interrupt enable
  121.    int1 tx0ie; //2   //transmit buffer 0 embty interrupt enable
  122.    int1 tx1ie; //3   //transmit buffer 1 embty interrupt enable
  123.    int1 tx2ie; //4   //transmit buffer 2 embty interrupt enable
  124.    int1 errie; //5   //error interrupt enable
  125.    int1 wakie; //6   //wakeup interrupt  enable
  126.    int1 merre; //7   //message error interrupt enable
  127. };
  128. #define CANINTE   0x2B
  129.  
  130. //interupt enable register
  131. struct struct_CANINTF {
  132.    int1 rx0if; //0   //receive buffer 0 full interrupt flag
  133.    int1 rx1if; //1   //receive buffer 1 full interrupt flag
  134.    int1 tx0if; //2   //transmit buffer 0 embty interrupt flag
  135.    int1 tx1if; //3   //transmit buffer 1 embty interrupt flag
  136.    int1 tx2if; //4   //transmit buffer 2 embty interrupt flag
  137.    int1 errif; //5   //error interrupt flag
  138.    int1 wakif; //6   //wakeup interrupt flag
  139.    int1 merrf; //7   //message error interrupt flag
  140. };
  141. #define CANINTF   0x2C
  142.  
  143.  
  144. //error counters
  145. #define TEC    0x1C
  146. #define REC    0x1D
  147.  
  148. //baud rate control register 1
  149. struct struct_CNF1 {
  150.    int brp:6;   //0:5   //baud rate prescalar
  151.    int sjw:2;   //6:7   //synchronized jump width
  152. };
  153. #define CNF1   0x2A
  154.  
  155. //baud rate control register 2
  156. struct struct_CNF2 {
  157.    int prseg:3; //0:2 //propagation time select
  158.    int phseg1:3; //3:5 //phase segment 1
  159.    int1 sam; //6 //sample of the can bus line
  160.    int1 btlmode; //7 //phase segment 2 bit time length
  161. };
  162. #define CNF2   0x29
  163.  
  164. //baud rate control register 3
  165. struct struct_CNF3 {
  166.    int phseg2:3;   //0:2   //phase segment 2 time select
  167.    int void543:3;   //3:5
  168.    int1 wakfil;   //6 //selects can bus line filter for wake-up
  169.    int1 void7;   //7
  170. };
  171. #define CNF3   0x28
  172. //can i/o control register
  173.  
  174. //transmit buffer n control register
  175. struct txbNctrl_struct {
  176.    int  txpri:2;   //0:1   //transmit priority bits
  177.    int1 void2; //2
  178.    int1 txreq;   //3   //transmit request status (clear to request message abort)
  179.    int1 txerr;   //4   //transmission error detected
  180.    int1 mloa;   //5   //message lost arbitration
  181.    int1 abtf;   //6   //message was aborted / or transmitted succesfully
  182.    int1 void7;
  183. };
  184. #define TXB0CTRL  0x30
  185. #define TXB1CTRL  0x40
  186. #define TXB2CTRL  0x50
  187.  
  188. //TXnRTS pin control and status register
  189. struct struct_TXRTSCTRL {
  190.    int1 b0rtsm; //0  //1=request message trans, 0=digital
  191.    int1 b1rtsm; //1  //1=request message trans, 0=digital
  192.    int1 b2rtsm; //2  //1=request message trans, 0=digital
  193.    int1 b0rts; //3   //reads as tx2rts when in digital, 0 when in rts
  194.    int1 b1rts; //4   //reads as tx2rts when in digital, 0 when in rts mode
  195.    int1 b2rts; //5  //reads as tx2rts when in digital, 0 when in rts mode
  196.    int  void67:2; //6:7
  197. };
  198. #define TXRTSCTRL 0x0D
  199.  
  200. //transmit buffer n standard identifier
  201. #define TXB0SIDH 0x31
  202. #define TXB0SIDL 0x32
  203. #define TXB1SIDH 0x41
  204. #define TXB1SIDL 0x42
  205. #define TXB2SIDH 0x51
  206. #define TXB2SIDL 0x52
  207.  
  208. //transmit buffer n extended identifier
  209. #define TXB0EIDH 0x33
  210. #define TXB0EIDL 0x34
  211. #define TXB1EIDH 0x43
  212. #define TXB1EIDL 0x44
  213. #define TXB2EIDH 0x53
  214. #define TXB2EIDL 0x54
  215.  
  216. //transmit buffer n data byte m
  217. #define TXB0D0 0x36
  218. #define TXB0D7 0x3D
  219.  
  220. #define TXB1D0 0x46
  221. #define TXB1D7 0x4D
  222.  
  223. #define TXB2D0 0x56
  224. #define TXB2D7 0x5D
  225.  
  226. //transmit buffer n data length
  227. struct txbNdlc_struct {
  228.    int dlc:4;   //0:3
  229.    int void54:2; //4:5
  230.    int1 rtr; //6 //transmission frame remote tranmission
  231.    int1 void7; //7
  232. };
  233. #define TXB0DLC 0x35
  234. #define TXB1DLC 0x45
  235. #define TXB2DLC 0x55
  236.  
  237. //#byte TXBaDLC=0xF65  //txbXdlc when in the access bank
  238.  
  239.  
  240. //transmit error count register
  241. #byte TXERRCNT=0xF76
  242.  
  243.  
  244. enum CAN_RX_MODE {CAN_RX_ALL=3, CAN_RX_EXT=2, CAN_RX_STD=1, CAN_RX_VALID=0};
  245.  
  246. //receive buffer 0 control register
  247. struct struct_RXB0CTRL {
  248.    int1 filhit0;   //0 //filter hit
  249.    int1 bukt1;   //1 //read only copy of bukt bit (used internally by mcp2510)
  250.    int1 bukt;   //2 //rollover enable
  251.    int1 rxrtr;   //3 //receive remote transfer request
  252.    int1 void4;   //4
  253.    CAN_RX_MODE rxm:2;   //5:6 //receiver buffer mode
  254.    int1 void7;   //7 //receive full status
  255. };
  256. #define RXB0CTRL  0x60
  257.  
  258. //receive buffer 1 control register
  259. struct struct_RXB1CTRL {
  260.    int filhit0:3;   //0:2
  261.    int1 rxrtr;   //3 //receive remote transfer request
  262.    int1 void4;   //4
  263.    CAN_RX_MODE rxm:2;   //5:6 //receive buffer mode
  264.    int1 void7;   //7
  265. };
  266. #define RXB1CTRL 0x70
  267.  
  268. //RXnBF pint control and status register
  269. struct struct_BFPCTRL {
  270.    int1  b0bfm; //0   //1=pin is interrupt when message loaded into rxb0, 0=digital
  271.    int1  b1bfm; //1   //1=pin is interrupt when message loaded into rxb1, 0=digital
  272.    int1  b0bfe; //2   //rx0bf pin function enable
  273.    int1  b1bfe; //3   //rx1bf pin function enable
  274.    int1  b0bfs; //4   //rx0bf pin state
  275.    int1  b1bfs; //5   //rx1bf pin state
  276. };
  277.  
  278. //receive buffer n standard identifier
  279. #define   RXB0SIDH  0x61
  280. #define   RXB0SIDL  0x62
  281.  
  282. #define   RXB1SIDH  0x71
  283. #define   RXB1SIDL  0x72
  284.  
  285. //receive buffer n extended identifier
  286. #define   RXB0EID8  0x63
  287. #define   RXB0EID0  0x64
  288.  
  289. #define   RXB1EID8  0x73
  290. #define   RXB1EID0  0x74
  291.  
  292. struct struct_TXRXBaSIDL {
  293.    int void012:3; //0:2
  294.    int1 ext;      //3 //extendid id
  295.    int1 srr;      //4 //substitute remove request bit
  296.    int void567:3; //5:7
  297. };
  298.  
  299. //receive buffer n data length code register
  300. struct rxbNdlc_struct {
  301.    int dlc:4;   //0:3 //data length code
  302.    int1 rb0;   //4   //reserved
  303.    int1 rb1;   //5   //reserved
  304.    int1 rtr;   //6   //receiver remote transmission request bit
  305.    int1 void7;   //7
  306. };
  307. #define   RXB0DLC   0x65
  308. #define   RXB1DLC   0x75
  309.  
  310. //receive buffer n data field byte m register
  311. #define RXB0D0    0x66
  312. #define RXB0D7    0x6D
  313.  
  314. #define RXB1D0    0x76
  315. #define RXB1D7    0x7D
  316.  
  317.  
  318. //receive acceptance filter n standard indifier
  319. #define RXF0SIDH  0x00
  320. #define RXF0SIDL  0x01
  321. #define RXF1SIDH  0x04
  322. #define RXF1SIDL  0x05
  323. #define RXF2SIDH  0x08
  324. #define RXF2SIDL  0x09
  325. #define RXF3SIDH  0x10
  326. #define RXF3SIDL  0x11
  327. #define RXF4SIDH  0x14
  328. #define RXF4SIDL  0x15
  329. #define RXF5SIDH  0x18
  330. #define RXF5SIDL  0x19
  331.  
  332. //receive acceptance filter n extended indifier
  333. #define RXF0EIDH  0x02
  334. #define RXF0EIDL  0x03
  335. #define RXF1EIDH  0x06
  336. #define RXF1EIDL  0x07
  337. #define RXF2EIDH  0x0a
  338. #define RXF2EIDL  0x0b
  339. #define RXF3EIDH  0x12
  340. #define RXF3EIDL  0x13
  341. #define RXF4EIDH  0x16
  342. #define RXF4EIDL  0x17
  343. #define RXF5EIDH  0x1a
  344. #define RXF5EIDL  0x1b
  345.  
  346. //receive acceptance mask n standard identifer mask
  347. #define RXM0SIDH  0x20
  348. #define RXM0SIDL  0x21
  349. #define RXM1SIDH  0x24
  350. #define RXM1SIDL  0x25
  351.  
  352. //receive acceptance mask n extended identifer mask
  353. #define RXM0EIDH  0x22
  354. #define RXM0EIDL  0x23
  355. #define RXM1EIDH  0x26
  356. #define RXM1EIDL  0x27
  357.  
  358. #define RX0MASK       RXM0EIDL   //rxm0eidl
  359. #define RX1MASK       RXM1EIDL   //rxm1eidl
  360. #define RX0FILTER0    RXF0EIDL   //rxf0eidl
  361. #define RX0FILTER1    RXF1EIDL   //rxf1eidl
  362. #define RX1FILTER2    RXF2EIDL   //rxf2eidl
  363. #define RX1FILTER3    RXF3EIDL   //rxf3eidl
  364. #define RX1FILTER4    RXF4EIDL   //rxf4eidl
  365. #define RX1FILTER5    RXF5EIDL   //rxf5eidl
  366. #define RXB0ID        RXB0EIDL   //rxb0eidl
  367. #define RXB1ID        RXB1EIDL   //rxb1eidl
  368. #define TXB0ID        TXB0EIDL   //txb0eidl
  369. #define TXB1ID        TXB1EIDL   //txb1eidl
  370. #define TXB2ID        TXB2EIDL   //tsb2eidl
  371.  
  372. //value to put in mask field to accept all incoming id's
  373. #define CAN_MASK_ACCEPT_ALL   0
  374.  
  375.  
  376. //PROTOTYPES and MACROS
  377.  
  378. struct rx_stat {
  379.    int1 err_ovfl;
  380.    int filthit:3;
  381.    int1 buffer;
  382.    int1 rtr;
  383.    int1 ext;
  384.    int1 inv;
  385. };
  386.  
  387. void  can_init(void);
  388. void  can_set_baud(void);
  389. void  can_set_mode(CAN_OP_MODE mode);
  390. void can_set_id(int addr, int32 id, int1 ext);
  391. int32 can_get_id(int addr, int1 ext);
  392. int   can_putd(int32 id, int * data, int len, int priority, int1 ext, int1 rtr);
  393. int1  can_getd(int32 & id, int * data, int & len, struct rx_stat & stat);
  394.  
  395. void mcp2510_init();
  396. void mcp2510_command(int command);
  397. void mcp2510_write(int address, int data);
  398. int mcp2510_status(void);
  399. int mcp2510_read(int address);
  400.  
  401. #endif
  402.  

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #680 en: 28 de Diciembre de 2009, 12:37:16 »
 /////////  4   /////////////////////

3) can-mcp2510.h ( modificada también)
Código: C
  1. /////////////////////////////////////////////////////////////////////////
  2. ////                        can-mcp2510.h                            ////
  3. ////                                                                 ////
  4. //// Prototypes, definitions, defines and macros used for and with   ////
  5. //// the CCS CAN library for the MCP2510 (and compatable) CAN IO     ////
  6. //// expanders.                                                      ////
  7. ////                                                                 ////
  8. //// (see can-mcp2510.c)                                             ////
  9. ////                                                                 ////
  10. /////////////////////////////////////////////////////////////////////////
  11. ////                                                                 ////
  12. //// Version History                                                 ////
  13. ////                                                                 ////
  14. ////  Apr 20 04 - Fixed a compling problem                           ////
  15. ////                                                                 ////
  16. /////////////////////////////////////////////////////////////////////////
  17. ////        (C) Copyright 1996,2003 Custom Computer Services         ////
  18. //// This source code may only be used by licensed users of the CCS  ////
  19. //// C compiler.  This source code may only be distributed to other  ////
  20. //// licensed users of the CCS C compiler.  No other use,            ////
  21. //// reproduction or distribution is permitted without written       ////
  22. //// permission.  Derivative programs created using this software    ////
  23. //// in object code form are not restricted in any way.              ////
  24. /////////////////////////////////////////////////////////////////////////
  25.  
  26. #ifndef __CCS_CANMCP2510_LIB_DEFINES__
  27. #define __CCS_CANMCP2510_LIB_DEFINES__
  28.  
  29. #ifndef CAN_DO_DEBUG
  30.  #define CAN_DO_DEBUG FALSE
  31. #endif
  32.  
  33. #IFNDEF CAN_USE_EXTENDED_ID
  34.   #define CAN_USE_EXTENDED_ID         TRUE
  35. #ENDIF
  36.  
  37. #IFNDEF CAN_BRG_SYNCH_JUMP_WIDTH
  38.   #define CAN_BRG_SYNCH_JUMP_WIDTH  0  //synchronized jump width (def: 1 x Tq)
  39. #ENDIF
  40.  
  41. #IFNDEF CAN_BRG_PRESCALAR
  42.   #define CAN_BRG_PRESCALAR  4  //baud rate generator prescalar (def: 4) ( Tq = (2 x (PRE + 1))/Fosc )
  43. #ENDIF
  44.  
  45. #ifndef CAN_BRG_SEG_2_PHASE_TS
  46.  #define CAN_BRG_SEG_2_PHASE_TS   TRUE //phase segment 2 time select bit (def: freely programmable)
  47. #endif
  48.  
  49. #ifndef CAN_BRG_SAM
  50.  #define CAN_BRG_SAM 0 //sample of the can bus line (def: bus line is sampled 1 times prior to sample point)
  51. #endif
  52.  
  53. #ifndef CAN_BRG_PHASE_SEGMENT_1
  54.  #define CAN_BRG_PHASE_SEGMENT_1  5 //phase segment 1 (def: 6 x Tq)
  55. #endif
  56.  
  57. #ifndef CAN_BRG_PROPAGATION_TIME
  58.  #define CAN_BRG_PROPAGATION_TIME 2 //propagation time select (def: 3 x Tq)
  59. #endif
  60.  
  61. #ifndef CAN_BRG_WAKE_FILTER
  62.  #define CAN_BRG_WAKE_FILTER FALSE   //selects can bus line filter for wake up bit
  63. #endif
  64.  
  65. #ifndef CAN_BRG_PHASE_SEGMENT_2
  66.  #define CAN_BRG_PHASE_SEGMENT_2 5 //phase segment 2 time select (def: 6 x Tq)
  67. #endif
  68.  
  69. #ifndef CAN_USE_RX_DOUBLE_BUFFER
  70.  #define CAN_USE_RX_DOUBLE_BUFFER TRUE   //if buffer 0 overflows, do NOT use buffer 1 to put buffer 0 data
  71. #endif
  72.  
  73. #ifndef CAN_ENABLE_DRIVE_HIGH
  74.  #define CAN_ENABLE_DRIVE_HIGH 0
  75. #endif
  76.  
  77. #ifndef CAN_ENABLE_CAN_CAPTURE
  78.  #define CAN_ENABLE_CAN_CAPTURE 0
  79. #endif
  80.  
  81. enum CAN_OP_MODE {CAN_OP_CONFIG=4, CAN_OP_LISTEN=3, CAN_OP_LOOPBACK=2, CAN_OP_SLEEP=1, CAN_OP_NORMAL=0};
  82.  
  83. //can control
  84. struct struct_CANCTRL {
  85.    int  clkpre:2; //0:1 //clkout pin prescalar
  86.    int1 clken; //2   //clkout pin enable
  87.    int1 void3; //3
  88.    int1 abat;  //4   //abort all pending transmissions
  89.    CAN_OP_MODE reqop:3; //5:7 //request operation mode
  90. };
  91. #define CANCTRL   0x0F  //or 1f, or 2f, or 3f ... or 7f
  92.  
  93. enum CAN_INT_CODE {CAN_INT_RX1=7, CAN_INT_RX0=6, CAN_INT_TX2=5, CAN_INT_TX1=4, CAN_INT_TX0=3, CAN_INT_WAKEUP=2, CAN_INT_ERROR=1, CAN_INT_NO=0};
  94.  
  95. //can status register READ-ONLY
  96. struct struct_CANSTAT {
  97.    int1 void0;   //0
  98.    CAN_INT_CODE icode:3;   //1:3   //interrupt code
  99.    int1 void4;   //4
  100.    CAN_OP_MODE opmode:3;   //5:7   //operation mode status
  101. };
  102. #define CANSTAT 0x0E //or 1e, or 2e ... or 7e
  103.  
  104. //error flag register
  105. struct struct_EFLG {
  106.    int1 ewarn;      //0 //error warning
  107.    int1 rxwar;      //1 //receiver warning
  108.    int1 txwar;      //2 //transmitter warning
  109.    int1 rxep;   //3 //receive error passive flag
  110.    int1 txep;   //4 //transmit error passive flag
  111.    int1 txbo;   //5   //bus off error flag
  112.    int1 rx0ovr;   //6   //receive buffer 0 overflow
  113.    int1 rx1ovr;   //7   //receive buffer 1 overflow
  114. };
  115. #define EFLG   0x2D
  116.  
  117. //interupt enable register
  118. struct struct_CANINTE {
  119.    int1 rx0ie; //0   //receive buffer 0 full interrupt enable
  120.    int1 rx1ie; //1   //receive buffer 1 full interrupt enable
  121.    int1 tx0ie; //2   //transmit buffer 0 embty interrupt enable
  122.    int1 tx1ie; //3   //transmit buffer 1 embty interrupt enable
  123.    int1 tx2ie; //4   //transmit buffer 2 embty interrupt enable
  124.    int1 errie; //5   //error interrupt enable
  125.    int1 wakie; //6   //wakeup interrupt  enable
  126.    int1 merre; //7   //message error interrupt enable
  127. };
  128. #define CANINTE   0x2B
  129.  
  130. //interupt enable register
  131. struct struct_CANINTF {
  132.    int1 rx0if; //0   //receive buffer 0 full interrupt flag
  133.    int1 rx1if; //1   //receive buffer 1 full interrupt flag
  134.    int1 tx0if; //2   //transmit buffer 0 embty interrupt flag
  135.    int1 tx1if; //3   //transmit buffer 1 embty interrupt flag
  136.    int1 tx2if; //4   //transmit buffer 2 embty interrupt flag
  137.    int1 errif; //5   //error interrupt flag
  138.    int1 wakif; //6   //wakeup interrupt flag
  139.    int1 merrf; //7   //message error interrupt flag
  140. };
  141. #define CANINTF   0x2C
  142.  
  143.  
  144. //error counters
  145. #define TEC    0x1C
  146. #define REC    0x1D
  147.  
  148. //baud rate control register 1
  149. struct struct_CNF1 {
  150.    int brp:6;   //0:5   //baud rate prescalar
  151.    int sjw:2;   //6:7   //synchronized jump width
  152. };
  153. #define CNF1   0x2A
  154.  
  155. //baud rate control register 2
  156. struct struct_CNF2 {
  157.    int prseg:3; //0:2 //propagation time select
  158.    int phseg1:3; //3:5 //phase segment 1
  159.    int1 sam; //6 //sample of the can bus line
  160.    int1 btlmode; //7 //phase segment 2 bit time length
  161. };
  162. #define CNF2   0x29
  163.  
  164. //baud rate control register 3
  165. struct struct_CNF3 {
  166.    int phseg2:3;   //0:2   //phase segment 2 time select
  167.    int void543:3;   //3:5
  168.    int1 wakfil;   //6 //selects can bus line filter for wake-up
  169.    int1 void7;   //7
  170. };
  171. #define CNF3   0x28
  172. //can i/o control register
  173.  
  174. //transmit buffer n control register
  175. struct txbNctrl_struct {
  176.    int  txpri:2;   //0:1   //transmit priority bits
  177.    int1 void2; //2
  178.    int1 txreq;   //3   //transmit request status (clear to request message abort)
  179.    int1 txerr;   //4   //transmission error detected
  180.    int1 mloa;   //5   //message lost arbitration
  181.    int1 abtf;   //6   //message was aborted / or transmitted succesfully
  182.    int1 void7;
  183. };
  184. #define TXB0CTRL  0x30
  185. #define TXB1CTRL  0x40
  186. #define TXB2CTRL  0x50
  187.  
  188. //TXnRTS pin control and status register
  189. struct struct_TXRTSCTRL {
  190.    int1 b0rtsm; //0  //1=request message trans, 0=digital
  191.    int1 b1rtsm; //1  //1=request message trans, 0=digital
  192.    int1 b2rtsm; //2  //1=request message trans, 0=digital
  193.    int1 b0rts; //3   //reads as tx2rts when in digital, 0 when in rts
  194.    int1 b1rts; //4   //reads as tx2rts when in digital, 0 when in rts mode
  195.    int1 b2rts; //5  //reads as tx2rts when in digital, 0 when in rts mode
  196.    int  void67:2; //6:7
  197. };
  198. #define TXRTSCTRL 0x0D
  199.  
  200. //transmit buffer n standard identifier
  201. #define TXB0SIDH 0x31
  202. #define TXB0SIDL 0x32
  203. #define TXB1SIDH 0x41
  204. #define TXB1SIDL 0x42
  205. #define TXB2SIDH 0x51
  206. #define TXB2SIDL 0x52
  207.  
  208. //transmit buffer n extended identifier
  209. #define TXB0EIDH 0x33
  210. #define TXB0EIDL 0x34
  211. #define TXB1EIDH 0x43
  212. #define TXB1EIDL 0x44
  213. #define TXB2EIDH 0x53
  214. #define TXB2EIDL 0x54
  215.  
  216. //transmit buffer n data byte m
  217. #define TXB0D0 0x36
  218. #define TXB0D7 0x3D
  219.  
  220. #define TXB1D0 0x46
  221. #define TXB1D7 0x4D
  222.  
  223. #define TXB2D0 0x56
  224. #define TXB2D7 0x5D
  225.  
  226. //transmit buffer n data length
  227. struct txbNdlc_struct {
  228.    int dlc:4;   //0:3
  229.    int void54:2; //4:5
  230.    int1 rtr; //6 //transmission frame remote tranmission
  231.    int1 void7; //7
  232. };
  233. #define TXB0DLC 0x35
  234. #define TXB1DLC 0x45
  235. #define TXB2DLC 0x55
  236.  
  237. //#byte TXBaDLC=0xF65  //txbXdlc when in the access bank
  238.  
  239.  
  240. //transmit error count register
  241. #byte TXERRCNT=0xF76
  242.  
  243.  
  244. enum CAN_RX_MODE {CAN_RX_ALL=3, CAN_RX_EXT=2, CAN_RX_STD=1, CAN_RX_VALID=0};
  245.  
  246. //receive buffer 0 control register
  247. struct struct_RXB0CTRL {
  248.    int1 filhit0;   //0 //filter hit
  249.    int1 bukt1;   //1 //read only copy of bukt bit (used internally by mcp2510)
  250.    int1 bukt;   //2 //rollover enable
  251.    int1 rxrtr;   //3 //receive remote transfer request
  252.    int1 void4;   //4
  253.    CAN_RX_MODE rxm:2;   //5:6 //receiver buffer mode
  254.    int1 void7;   //7 //receive full status
  255. };
  256. #define RXB0CTRL  0x60
  257.  
  258. //receive buffer 1 control register
  259. struct struct_RXB1CTRL {
  260.    int filhit0:3;   //0:2
  261.    int1 rxrtr;   //3 //receive remote transfer request
  262.    int1 void4;   //4
  263.    CAN_RX_MODE rxm:2;   //5:6 //receive buffer mode
  264.    int1 void7;   //7
  265. };
  266. #define RXB1CTRL 0x70
  267.  
  268. //RXnBF pint control and status register
  269. struct struct_BFPCTRL {
  270.    int1  b0bfm; //0   //1=pin is interrupt when message loaded into rxb0, 0=digital
  271.    int1  b1bfm; //1   //1=pin is interrupt when message loaded into rxb1, 0=digital
  272.    int1  b0bfe; //2   //rx0bf pin function enable
  273.    int1  b1bfe; //3   //rx1bf pin function enable
  274.    int1  b0bfs; //4   //rx0bf pin state
  275.    int1  b1bfs; //5   //rx1bf pin state
  276. };
  277.  
  278. //receive buffer n standard identifier
  279. #define   RXB0SIDH  0x61
  280. #define   RXB0SIDL  0x62
  281.  
  282. #define   RXB1SIDH  0x71
  283. #define   RXB1SIDL  0x72
  284.  
  285. //receive buffer n extended identifier
  286. #define   RXB0EID8  0x63
  287. #define   RXB0EID0  0x64
  288.  
  289. #define   RXB1EID8  0x73
  290. #define   RXB1EID0  0x74
  291.  
  292. struct struct_TXRXBaSIDL {
  293.    int void012:3; //0:2
  294.    int1 ext;      //3 //extendid id
  295.    int1 srr;      //4 //substitute remove request bit
  296.    int void567:3; //5:7
  297. };
  298.  
  299. //receive buffer n data length code register
  300. struct rxbNdlc_struct {
  301.    int dlc:4;   //0:3 //data length code
  302.    int1 rb0;   //4   //reserved
  303.    int1 rb1;   //5   //reserved
  304.    int1 rtr;   //6   //receiver remote transmission request bit
  305.    int1 void7;   //7
  306. };
  307. #define   RXB0DLC   0x65
  308. #define   RXB1DLC   0x75
  309.  
  310. //receive buffer n data field byte m register
  311. #define RXB0D0    0x66
  312. #define RXB0D7    0x6D
  313.  
  314. #define RXB1D0    0x76
  315. #define RXB1D7    0x7D
  316.  
  317.  
  318. //receive acceptance filter n standard indifier
  319. #define RXF0SIDH  0x00
  320. #define RXF0SIDL  0x01
  321. #define RXF1SIDH  0x04
  322. #define RXF1SIDL  0x05
  323. #define RXF2SIDH  0x08
  324. #define RXF2SIDL  0x09
  325. #define RXF3SIDH  0x10
  326. #define RXF3SIDL  0x11
  327. #define RXF4SIDH  0x14
  328. #define RXF4SIDL  0x15
  329. #define RXF5SIDH  0x18
  330. #define RXF5SIDL  0x19
  331.  
  332. //receive acceptance filter n extended indifier
  333. #define RXF0EIDH  0x02
  334. #define RXF0EIDL  0x03
  335. #define RXF1EIDH  0x06
  336. #define RXF1EIDL  0x07
  337. #define RXF2EIDH  0x0a
  338. #define RXF2EIDL  0x0b
  339. #define RXF3EIDH  0x12
  340. #define RXF3EIDL  0x13
  341. #define RXF4EIDH  0x16
  342. #define RXF4EIDL  0x17
  343. #define RXF5EIDH  0x1a
  344. #define RXF5EIDL  0x1b
  345.  
  346. //receive acceptance mask n standard identifer mask
  347. #define RXM0SIDH  0x20
  348. #define RXM0SIDL  0x21
  349. #define RXM1SIDH  0x24
  350. #define RXM1SIDL  0x25
  351.  
  352. //receive acceptance mask n extended identifer mask
  353. #define RXM0EIDH  0x22
  354. #define RXM0EIDL  0x23
  355. #define RXM1EIDH  0x26
  356. #define RXM1EIDL  0x27
  357.  
  358. #define RX0MASK       RXM0EIDL   //rxm0eidl
  359. #define RX1MASK       RXM1EIDL   //rxm1eidl
  360. #define RX0FILTER0    RXF0EIDL   //rxf0eidl
  361. #define RX0FILTER1    RXF1EIDL   //rxf1eidl
  362. #define RX1FILTER2    RXF2EIDL   //rxf2eidl
  363. #define RX1FILTER3    RXF3EIDL   //rxf3eidl
  364. #define RX1FILTER4    RXF4EIDL   //rxf4eidl
  365. #define RX1FILTER5    RXF5EIDL   //rxf5eidl
  366. #define RXB0ID        RXB0EIDL   //rxb0eidl
  367. #define RXB1ID        RXB1EIDL   //rxb1eidl
  368. #define TXB0ID        TXB0EIDL   //txb0eidl
  369. #define TXB1ID        TXB1EIDL   //txb1eidl
  370. #define TXB2ID        TXB2EIDL   //tsb2eidl
  371.  
  372. //value to put in mask field to accept all incoming id's
  373. #define CAN_MASK_ACCEPT_ALL   0
  374.  
  375.  
  376. //PROTOTYPES and MACROS
  377.  
  378. struct rx_stat {
  379.    int1 err_ovfl;
  380.    int filthit:3;
  381.    int1 buffer;
  382.    int1 rtr;
  383.    int1 ext;
  384.    int1 inv;
  385. };
  386.  
  387. void  can_init(void);
  388. void  can_set_baud(void);
  389. void  can_set_mode(CAN_OP_MODE mode);
  390. void can_set_id(int addr, int32 id, int1 ext);
  391. int32 can_get_id(int addr, int1 ext);
  392. int   can_putd(int32 id, int * data, int len, int priority, int1 ext, int1 rtr);
  393. int1  can_getd(int32 & id, int * data, int & len, struct rx_stat & stat);
  394.  
  395. void mcp2510_init();
  396. void mcp2510_command(int command);
  397. void mcp2510_write(int address, int data);
  398. int mcp2510_status(void);
  399. int mcp2510_read(int address);
  400.  
  401. #endif
  402.  

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #681 en: 28 de Diciembre de 2009, 15:13:04 »
Te paso el ejecutable despues de hacer algunos cambios en los diferentes archivos, pruebalo en tu hardware y dime como va.
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #682 en: 29 de Diciembre de 2009, 17:11:40 »
Lo has podido probar??
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #683 en: 30 de Diciembre de 2009, 05:11:31 »
Hola!
Perdona, hoy mismo pruebo y te digo el resultado de ello ( no disponia de programador ayer).

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #684 en: 30 de Diciembre de 2009, 08:42:30 »


Buenas, como va todo?
Notificación:prueba fallida. De nuevo por SPO (del modulo CAN) hay algo parecido a una señal, si, de 0.2 voltios... no era mas que ruido, de nuevo.

PD: he leido datsheet, pero no he encontrado nada al respecto, pero esta es mi pergunta pues : los pines TXORTS y demás han de estar fisicamente conectados a masa? O Vdd?

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #685 en: 30 de Diciembre de 2009, 09:52:40 »
Bueno Penguin.
Hora de barajar y dar de nuevo.

Recomendacion asi no terminamos todos con camisa de fuerza:
  • Usa las librerias originales por software, solamente cambiando el pin C7 que es RX del Usart (cablealo por fuera o algo asi)
  • Usa un ejemplo original de CCS, solamente cambiando el PIC y declarando cristal HS y nada mas (fuera preescalers y otras yerbas)
  • Declara todos los pines del puerto analogico como digitales (de otra forma RA5 no respondera a tus llamados)

Luego nos cuentas.
Una vez obtenido resultados de esta forma recien ahi recomiendo empezar a mudar el uso SPI por software a hardware (solo comenta las instrucciones del hardware).

La unica forma de encontrar tu problema es tomarlo por partes, y esta es la unica forma que conozco de hacerlo.

Feliz año nuevo!! :mrgreen: :mrgreen:
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

penguin

  • Visitante
Re: Mis experiencias con el BUS CAN
« Respuesta #686 en: 31 de Diciembre de 2009, 09:50:56 »


ok, entiendo lo de cambiar todos los puertos a digitales como
Código: C
  1. #define NO_ANALOGS
  2. SETUP_ADC_PORTS( NO_ANALOGS );
  3.  
Hecho.
Tambien lo de usar de momento ( y si me va... ya veremos si lo cambio...) por software , usando la librería original.Ok. Pero lo que no capto muy bien es eso de cambiar C7 que es la Rx?
O sea, a ver si me entiendo, para hacer la prueba por soft, ya no uso SPI en HW claro, entonces, cambiar los pines de SI SO por los de Rx Tx en el pic?

Pero si modifiqué para que saliera datos desde SO, por que no harçia lo msimo por entrada de datos por SI ?

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #687 en: 31 de Diciembre de 2009, 10:04:49 »
Si miras en tu esquema, el hecho de usar SPI por hardware implica que ya no podras utilizar la Usart del micro, porque el pin C7 es compartido con el SPI, en ese caso usas uno u otro.
Ahora ya tienes cableado en tu placa ese pin para usarlo en el bus SPI.
El problema que se presenta es que la libreria usa ese pin como puerto serie, por esa razon usan SPI por software y dejan la Usart por hardware, para hacer Debug del programa.
Por eso recomiendo que lo cablees a otro pin y liberes ese pin (C7) para dejarlo como va, de ese modo no toqueteas nuevamente la libreria, y declaras el pin que realmente conectaste al SPI.
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado MGLSOFT

  • Moderador Local
  • DsPIC33
  • *****
  • Mensajes: 7842
Re: Mis experiencias con el BUS CAN
« Respuesta #688 en: 05 de Enero de 2010, 10:35:30 »
Algun avance, Penguin??
Todos los dias aprendo algo nuevo, el ultimo día de mi vida aprenderé a morir....
Mi Abuelo.

Desconectado Kid_Bengala

  • Colaborador
  • PIC18
  • *****
  • Mensajes: 410
Re: Mis experiencias con el BUS CAN
« Respuesta #689 en: 08 de Enero de 2010, 20:02:07 »
hola

a mi hace un tiempo cuando empece con el can bus un amigo me enseño a averiguar la velocidad con el osciloscopio(no solo para el can bus) pero ahora tengo una duda,si quiero hacer un circuito para un bus can y no tengo los datos de esta red,puedo averiguar la velocidad,pero ¿el protocolo? gracias

saludos de antonio