C18 LaurTec Library
2.5
Open Source C Library for PIC18 Microcontrollers
|
00001 /******************************************************* 00002 00003 Author : Mauro Laurenti 00004 Version : 1.0 00005 Date : 4/11/2007 00006 00007 CopyRight 2007 all rights are reserved 00008 00009 00010 ******************************************************** 00011 SOFTWARE LICENSE AGREEMENT 00012 ******************************************************** 00013 00014 The usage of the supplied software imply the acceptance of the following license. 00015 00016 The software supplied herewith by Mauro Laurenti (the Author) 00017 is intended for use solely and exclusively on Microchip PIC Microcontroller (registered mark). 00018 The software is owned by the Author, and is protected under applicable copyright laws. 00019 All rights are reserved. 00020 Any use in violation of the foregoing restrictions may subject the 00021 user to criminal sanctions under applicable laws (Italian or International ones), as well as to 00022 civil liability for the breach of the terms and conditions of this license. 00023 Commercial use is forbidden without a written acknowledgment with the Author. 00024 Personal or educational use is allowed if the application containing the following 00025 software doesn't aim to commercial use or monetary earning of any kind. 00026 00027 THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES, 00028 WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED 00029 TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 00030 PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE AUTHOR SHALL NOT, 00031 IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR 00032 CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER. 00033 00034 ******************************************************** 00035 PURPOSES 00036 ******************************************************** 00037 00038 This library is supposed to be used for CAN bus 00039 application. All the basic functions are included. 00040 Standard and Extended messages are supported 00041 00042 ******************************************************* 00043 *******************************************************/ 00044 00045 #ifndef CAN_FLAG //it allows to include the library in multiple points 00046 #define CAN_FLAG 00047 00048 00049 typedef unsigned char BYTE; 00050 00051 00052 typedef struct 00053 { 00054 unsigned long identifier; 00055 BYTE data[8]; 00056 BYTE type; //1 = IDE 0=standard 00057 BYTE length; // data length 00058 BYTE RTR; //Remote flag. 1 it means remote frame 00059 00060 } CANmessage; 00061 00062 00063 //************************************************************************ 00064 // constants used for CANOperationMode function 00065 //************************************************************************ 00066 00067 enum CAN_OP_MODE 00068 { 00069 CAN_OP_MODE_NORMAL = 0b00000000, 00070 CAN_OP_MODE_SLEEP = 0b00100000, 00071 CAN_OP_MODE_LOOP = 0b01000000, 00072 CAN_OP_MODE_LISTEN = 0b01100000, 00073 CAN_OP_MODE_CONFIG = 0b10000000 00074 }; 00075 00076 //************************************************************************ 00077 // constants used for CANInitialize function 00078 //************************************************************************ 00079 00080 enum CAN_CONFIG_FLAGS 00081 { 00082 CAN_CONFIG_DEFAULT = 0b11111111, // 11111111 00083 00084 CAN_CONFIG_PHSEG2_PRG_BIT = 0b00000001, 00085 CAN_CONFIG_PHSEG2_PRG_ON = 0b11111111, // XXXXXXX1 00086 CAN_CONFIG_PHSEG2_PRG_OFF = 0b11111110, // XXXXXXX0 00087 00088 CAN_CONFIG_LINE_FILTER_BIT = 0b00000010, 00089 CAN_CONFIG_LINE_FILTER_ON = 0b11111111, // XXXXXX1X 00090 CAN_CONFIG_LINE_FILTER_OFF = 0b11111101, // XXXXXX0X 00091 00092 CAN_CONFIG_SAMPLE_BIT = 0b00000100, 00093 CAN_CONFIG_SAMPLE_ONCE = 0b11111111, // XXXXX1XX 00094 CAN_CONFIG_SAMPLE_THRICE = 0b11111011, // XXXXX0XX 00095 00096 CAN_CONFIG_MSG_TYPE_BIT = 0b00001000, 00097 CAN_CONFIG_STD_MSG = 0b11111111, // XXXX1XXX 00098 CAN_CONFIG_XTD_MSG = 0b11110111, // XXXX0XXX 00099 00100 CAN_CONFIG_DBL_BUFFER_BIT = 0b00010000, 00101 CAN_CONFIG_DBL_BUFFER_ON = 0b11111111, // XXX1XXXX 00102 CAN_CONFIG_DBL_BUFFER_OFF = 0b11101111, // XXX0XXXX 00103 00104 CAN_CONFIG_MSG_BITS = 0b01100000, 00105 CAN_CONFIG_ALL_MSG = 0b11111111, // X11XXXXX 00106 CAN_CONFIG_VALID_XTD_MSG = 0b11011111, // X10XXXXX 00107 CAN_CONFIG_VALID_STD_MSG = 0b10111111, // X01XXXXX 00108 CAN_CONFIG_ALL_VALID_MSG = 0b10011111 // X00XXXXX 00109 }; 00110 00111 00112 //************************************************************************ 00113 // constants used for CANsendMessage function 00114 //************************************************************************ 00115 00116 enum CAN_TX_MSG_FLAGS 00117 { 00118 CAN_TX_PRIORITY_MASK= 0b00000011, // bit mask 00119 CAN_TX_PRIORITY_0 = 0b11111100, // XXXXXX00 00120 CAN_TX_PRIORITY_1 = 0b11111101, // XXXXXX01 00121 CAN_TX_PRIORITY_2 = 0b11111110, // XXXXXX10 00122 CAN_TX_PRIORITY_3 = 0b11111111, // XXXXXX11 00123 00124 CAN_TX_FRAME_MASK = 0b00001000, // bit mask 00125 CAN_TX_STD_FRAME = 0b11110111, // XXXX0XXX 00126 CAN_TX_XTD_FRAME = 0b11111111, // XXXX1XXX 00127 00128 CAN_TX_RTR_MASK = 0b01000000, // bit mask 00129 CAN_REMOTE_TX_FRAME = 0b11111111, // X1XXXXXX 00130 CAN_NORMAL_TX_FRAME = 0b10111111 // X0XXXXXX 00131 00132 }; 00133 00134 //************************************************************************ 00135 // constants used for MASK function 00136 //************************************************************************ 00137 00138 enum CAN_MASK 00139 { 00140 CAN_MASK_B1 = 1, 00141 CAN_MASK_B2 = 2, 00142 }; 00143 00144 //************************************************************************ 00145 // constants used for Filter function 00146 //************************************************************************ 00147 00148 enum CAN_FILTER 00149 { 00150 CAN_FILTER_B1_F1, 00151 CAN_FILTER_B1_F2, 00152 CAN_FILTER_B2_F1, 00153 CAN_FILTER_B2_F2, 00154 CAN_FILTER_B2_F3, 00155 CAN_FILTER_B2_F4 00156 }; 00157 00158 //************************************************************************ 00159 // constants used for RX errors 00160 //************************************************************************ 00161 00162 enum CAN_RX_ERRORS 00163 { 00164 CAN_RX_BUFFER_1_OVFL = 0b00000001, 00165 CAN_RX_BUFFER_2_OVFL = 0b00000010 00166 }; 00167 00168 //************************************************************************ 00169 // Functions Prototypes 00170 //************************************************************************ 00171 00172 00173 void CANOperationMode (enum CAN_OP_MODE mode); 00174 void CANInitialize (BYTE propSeg, BYTE phaseSeg1, BYTE phaseSeg2,BYTE SJW, BYTE BRP, enum CAN_CONFIG_FLAGS flags); 00175 00176 void CANsendMessage (unsigned long identifier, BYTE *data, BYTE dataLength, enum CAN_TX_MSG_FLAGS flags); 00177 BYTE CANreceiveMessage (CANmessage *msg); 00178 00179 void CANSetMask(enum CAN_MASK code, unsigned long val, enum CAN_CONFIG_FLAGS type); 00180 void CANSetFilter(enum CAN_FILTER code, unsigned long val, enum CAN_CONFIG_FLAGS type); 00181 00182 BYTE CANisTxReady (void); 00183 BYTE CANisRxReady (void); 00184 00185 BYTE CANisTXpassive (void); 00186 BYTE CANisRXpassive (void); 00187 BYTE CANisTXwarningON (void); 00188 BYTE CANisRXwarningON (void); 00189 BYTE CANgetTXerrorCount (void); 00190 BYTE CANgetRXerrorCount (void); 00191 00192 BYTE CANisBusOFF (void); 00193 void CANAbortMessages (void); 00194 00195 00196 //************************************************************************ 00197 // Functions Implementation 00198 //************************************************************************ 00199 00200 00201 //********************************************* 00202 //Set the CAN engine mode 00203 //********************************************* 00204 00205 00206 void CANOperationMode (enum CAN_OP_MODE mode) 00207 { 00208 CANCON = mode; 00209 00210 while((CANSTAT & 0b11100000) != mode ); 00211 } 00212 00213 00214 //********************************************* 00215 //Initialize the CAN bus 00216 //********************************************* 00217 00218 void CANInitialize (BYTE propSeg, BYTE phaseSeg1, BYTE phaseSeg2,BYTE SJW, BYTE BRP, enum CAN_CONFIG_FLAGS flags) 00219 { 00220 BYTE FilterConfig1; 00221 BYTE FilterConfig2; 00222 00223 CANOperationMode(CAN_OP_MODE_CONFIG); //setting configuration mode 00224 00225 BRGCON1 = 0x00; //cleaning the value 00226 BRGCON2 = 0x00; //cleaning the value 00227 BRGCON3 = 0x00; //cleaning the value 00228 00229 SJW= SJW << 6; 00230 BRGCON1 |= SJW; 00231 BRGCON1 |= BRP; 00232 00233 BRGCON2 |= propSeg; 00234 phaseSeg1 = phaseSeg1 <<3; 00235 BRGCON2 |= phaseSeg1; 00236 00237 if ( !(flags & CAN_CONFIG_SAMPLE_BIT) ) //SAM 00238 BRGCON2bits.SAM= 1; 00239 00240 if ( flags & CAN_CONFIG_PHSEG2_PRG_BIT ) 00241 BRGCON2bits.SEG2PHTS = 1; 00242 00243 BRGCON3 |= phaseSeg2; 00244 00245 if ( flags & CAN_CONFIG_LINE_FILTER_BIT ) 00246 BRGCON3bits.WAKFIL = 1; 00247 00248 00249 //Receiver Settings 00250 00251 RXB0CON = flags & CAN_CONFIG_MSG_BITS; 00252 if ( (flags & CAN_CONFIG_DBL_BUFFER_BIT)== CAN_CONFIG_DBL_BUFFER_ON ) 00253 RXB0CONbits.RXB0DBEN = 1; 00254 00255 RXB1CON = RXB0CON; 00256 00257 //Setting the mask to receive all the messages 00258 00259 CANSetMask (CAN_MASK_B1, 0x00000000, CAN_CONFIG_XTD_MSG); 00260 CANSetMask (CAN_MASK_B2, 0x00000000, CAN_CONFIG_XTD_MSG); 00261 00262 00263 switch( (flags & CAN_CONFIG_MSG_BITS) | ~CAN_CONFIG_MSG_BITS ) 00264 { 00265 case CAN_CONFIG_VALID_XTD_MSG: 00266 FilterConfig1 = CAN_CONFIG_XTD_MSG; 00267 FilterConfig2 = CAN_CONFIG_XTD_MSG; 00268 break; 00269 00270 case CAN_CONFIG_VALID_STD_MSG: 00271 FilterConfig1 = CAN_CONFIG_STD_MSG; 00272 FilterConfig2 = CAN_CONFIG_STD_MSG; 00273 break; 00274 default: 00275 FilterConfig1 = CAN_CONFIG_STD_MSG; //Buffer 1 will receive the Standard messages 00276 FilterConfig2 = CAN_CONFIG_XTD_MSG; //Buffer 2 will receive the Extended messages 00277 break; 00278 } 00279 00280 CANSetFilter(CAN_FILTER_B1_F1, 0, FilterConfig1); 00281 CANSetFilter(CAN_FILTER_B1_F2, 0, FilterConfig1); 00282 CANSetFilter(CAN_FILTER_B2_F1, 0, FilterConfig2); 00283 CANSetFilter(CAN_FILTER_B2_F2, 0, FilterConfig2); 00284 CANSetFilter(CAN_FILTER_B2_F3, 0, FilterConfig2); 00285 CANSetFilter(CAN_FILTER_B2_F4, 0, FilterConfig2); 00286 00287 CANOperationMode(CAN_OP_MODE_NORMAL); //setting normal mode 00288 00289 } 00290 00291 //********************************************* 00292 // Send a message 00293 //********************************************* 00294 void CANsendMessage (unsigned long identifier, BYTE *data, BYTE dataLength, enum CAN_TX_MSG_FLAGS flags) 00295 { 00296 unsigned long tamp; //used as a tamp to set the identifier 00297 00298 if (TXB0CONbits.TXREQ == 0) 00299 { TXB0DLC = dataLength; // set the data length 00300 if (0b01000000 & flags) //set the RTR bit 00301 TXB0DLCbits.TXRTR = 0x01; 00302 else 00303 TXB0DLCbits.TXRTR = 0x00; 00304 00305 if (CAN_TX_FRAME_MASK & flags) 00306 { 00307 00308 tamp = identifier & 0x000000FF; //EID0 - EID7 setting 00309 TXB0EIDL = (unsigned char) tamp; 00310 00311 tamp = identifier & 0x0000FF00; //EID8 - EID15 setting 00312 tamp = tamp >> 8; 00313 TXB0EIDH = (unsigned char) tamp; 00314 00315 TXB0SIDL = 0x00; 00316 TXB0SIDLbits.EXIDE = 0x01; 00317 00318 if (identifier & 0x00010000) 00319 TXB0SIDLbits.EID16 = 0x01; 00320 if (identifier & 0x00020000) 00321 TXB0SIDLbits.EID17 = 0x01; 00322 if (identifier & 0x00040000) 00323 TXB0SIDLbits.SID0 = 0x01; 00324 if (identifier & 0x00080000) 00325 TXB0SIDLbits.SID1 = 0x01; 00326 if (identifier & 0x00100000) 00327 TXB0SIDLbits.SID2 = 0x01; 00328 00329 tamp = (identifier >> 21); 00330 tamp = tamp & 0x000000FF; 00331 TXB0SIDH = (unsigned char) tamp; 00332 } 00333 00334 else 00335 00336 { 00337 TXB0SIDLbits.EXIDE = 0x00; //enable standard messages 00338 00339 tamp = (identifier >> 3); 00340 tamp = tamp & 0x000000FF; 00341 TXB0SIDH = (unsigned char) tamp; 00342 00343 tamp = identifier & 0x00000007; 00344 tamp = tamp << 5; 00345 TXB0SIDL = TXB0SIDL & 0b00011111; 00346 TXB0SIDL = (unsigned char) tamp; 00347 } 00348 00349 if (0b00000001 & flags) //set transmission priority 00350 TXB0CONbits.TXPRI0 = 0x01; 00351 else 00352 TXB0CONbits.TXPRI0 = 0x00; 00353 if (0b00000010 & flags) 00354 TXB0CONbits.TXPRI1 = 0x01; 00355 else 00356 TXB0CONbits.TXPRI1 = 0x00; 00357 00358 TXB0D0 = data[0]; 00359 TXB0D1 = data[1]; 00360 TXB0D2 = data[2]; 00361 TXB0D3 = data[3]; 00362 TXB0D4 = data[4]; 00363 TXB0D5 = data[5]; 00364 TXB0D6 = data[6]; 00365 TXB0D7 = data[7]; 00366 00367 TXB0CONbits.TXREQ = 0x01; //enable trasmission 00368 return; 00369 } 00370 00371 // Second TX Buffer setting 00372 00373 if (TXB1CONbits.TXREQ == 0) 00374 { TXB1DLC = dataLength; // set the data length 00375 00376 if (0b01000000 & flags) //set the RTR bit 00377 TXB1DLCbits.TXRTR = 0x01; 00378 else 00379 TXB1DLCbits.TXRTR = 0x00; 00380 00381 if (CAN_TX_FRAME_MASK & flags) 00382 { 00383 tamp = identifier & 0x000000FF; //EID0 - EID7 setting 00384 TXB1EIDL = (unsigned char) tamp; 00385 00386 tamp = identifier & 0x0000FF00; //EID8 - EID15 setting 00387 tamp = tamp >> 8; 00388 TXB1EIDH = (unsigned char) tamp; 00389 00390 TXB1SIDL = 0x00; 00391 TXB1SIDLbits.EXIDE = 0x01; 00392 00393 if (identifier & 0x00010000) 00394 TXB1SIDLbits.EID16 = 0x01; 00395 if (identifier & 0x00020000) 00396 TXB1SIDLbits.EID17 = 0x01; 00397 if (identifier & 0x00040000) 00398 TXB1SIDLbits.SID0 = 0x01; 00399 if (identifier & 0x00080000) 00400 TXB1SIDLbits.SID1 = 0x01; 00401 if (identifier & 0x00100000) 00402 TXB1SIDLbits.SID2 = 0x01; 00403 00404 tamp = (identifier >> 21); 00405 tamp = tamp & 0x000000FF; 00406 TXB1SIDH = (unsigned char) tamp; 00407 } 00408 00409 else 00410 00411 { 00412 TXB1SIDLbits.EXIDE = 0x00; //enable standard messages 00413 00414 tamp = (identifier >> 3); 00415 tamp = tamp & 0x000000FF; 00416 TXB1SIDH = (unsigned char) tamp; 00417 00418 tamp = identifier & 0x00000007; 00419 tamp = tamp << 5; 00420 TXB1SIDL = TXB1SIDL & 0b00011111; 00421 TXB1SIDL = (unsigned char) tamp; 00422 } 00423 00424 if (0b00000001 & flags) //set transmission priority 00425 TXB1CONbits.TXPRI0 = 0x01; 00426 else 00427 TXB1CONbits.TXPRI0 = 0x00; 00428 if (0b00000010 & flags) 00429 TXB1CONbits.TXPRI1 = 0x01; 00430 else 00431 TXB1CONbits.TXPRI1 = 0x00; 00432 00433 TXB1D0 = data[0]; 00434 TXB1D1 = data[1]; 00435 TXB1D2 = data[2]; 00436 TXB1D3 = data[3]; 00437 TXB1D4 = data[4]; 00438 TXB1D5 = data[5]; 00439 TXB1D6 = data[6]; 00440 TXB1D7 = data[7]; 00441 00442 TXB1CONbits.TXREQ = 0x01; //enable trasmission 00443 00444 return; 00445 } 00446 00447 // Third TX Buffer setting 00448 00449 if (TXB2CONbits.TXREQ == 0) 00450 { TXB2DLC = dataLength; // set the data length 00451 00452 if (0b01000000 & flags) //set the RTR bit 00453 TXB2DLCbits.TXRTR = 0x01; 00454 else 00455 TXB2DLCbits.TXRTR = 0x00; 00456 00457 if (CAN_TX_FRAME_MASK & flags) 00458 { 00459 tamp = identifier & 0x000000FF; //EID0 - EID7 setting 00460 TXB2EIDL = (unsigned char) tamp; 00461 00462 tamp = identifier & 0x0000FF00; //EID8 - EID15 setting 00463 tamp = tamp >> 8; 00464 TXB2EIDH = (unsigned char) tamp; 00465 00466 TXB2SIDL = 0x00; 00467 TXB2SIDLbits.EXIDE = 0x01; 00468 00469 if (identifier & 0x00010000) 00470 TXB2SIDLbits.EID16 = 0x01; 00471 if (identifier & 0x00020000) 00472 TXB2SIDLbits.EID17 = 0x01; 00473 if (identifier & 0x00040000) 00474 TXB2SIDLbits.SID0 = 0x01; 00475 if (identifier & 0x00080000) 00476 TXB2SIDLbits.SID1 = 0x01; 00477 if (identifier & 0x00100000) 00478 TXB2SIDLbits.SID2 = 0x01; 00479 00480 tamp = (identifier >> 21); 00481 tamp = tamp & 0x000000FF; 00482 TXB2SIDH = (unsigned char) tamp; 00483 } 00484 00485 else 00486 00487 { 00488 TXB2SIDLbits.EXIDE = 0x00; //enable standard messages 00489 00490 tamp = (identifier >> 3); 00491 tamp = tamp & 0x000000FF; 00492 TXB2SIDH = (unsigned char) tamp; 00493 00494 tamp = identifier & 0x00000007; 00495 tamp = tamp << 5; 00496 TXB2SIDL = TXB2SIDL & 0b00011111; 00497 TXB2SIDL = (unsigned char) tamp; 00498 } 00499 00500 if (0b00000001 & flags) //set transmission priority 00501 TXB2CONbits.TXPRI0 = 0x01; 00502 else 00503 TXB2CONbits.TXPRI0 = 0x00; 00504 if (0b00000010 & flags) 00505 TXB2CONbits.TXPRI1 = 0x01; 00506 else 00507 TXB2CONbits.TXPRI1 = 0x00; 00508 00509 TXB2D0 = data[0]; 00510 TXB2D1 = data[1]; 00511 TXB2D2 = data[2]; 00512 TXB2D3 = data[3]; 00513 TXB2D4 = data[4]; 00514 TXB2D5 = data[5]; 00515 TXB2D6 = data[6]; 00516 TXB2D7 = data[7]; 00517 00518 TXB2CONbits.TXREQ = 0x01; //enable trasmission 00519 00520 return; 00521 } 00522 } 00523 00524 //********************************************* 00525 // Read the message from the RX buffer 00526 //********************************************* 00527 00528 BYTE CANreceiveMessage (CANmessage *msg) 00529 { 00530 BYTE tamp; 00531 BYTE error = 0; 00532 00533 if (COMSTATbits.RXB0OVFL == 0x01) //check for buffers overflows 00534 error |= CAN_RX_BUFFER_1_OVFL; 00535 00536 if (COMSTATbits.RXB1OVFL == 0x01) 00537 error |= CAN_RX_BUFFER_2_OVFL; 00538 00539 00540 if (RXB1CONbits.RXFUL ==0x01) //RX Buffer 1 is read 00541 { 00542 msg->identifier = 0; 00543 msg->data[0] =RXB1D0; //retrieve the data 00544 msg->data[1] =RXB1D1; 00545 msg->data[2] =RXB1D2; 00546 msg->data[3] =RXB1D3; 00547 msg->data[4] =RXB1D4; 00548 msg->data[5] =RXB1D5; 00549 msg->data[6] =RXB1D6; 00550 msg->data[7] =RXB1D7; 00551 00552 msg->RTR = RXB1DLCbits.RXRTR; //retrieve the RTR bit 00553 00554 msg->length = RXB1DLC & 0x0F; //retrieve the lenght 00555 00556 msg->type = RXB1SIDLbits.EXID; //retrieve the format (standard or extended) 00557 00558 if (RXB1SIDLbits.EXID == 0) //reading the identifier standard format 00559 { 00560 msg->identifier = ((unsigned long)RXB1SIDH)<< 3; 00561 tamp = (RXB1SIDL >> 5 ) & 0x07; 00562 msg->identifier = msg->identifier + tamp; 00563 } 00564 else // reading the identifier extended format 00565 { 00566 msg->identifier = (unsigned long) RXB1EIDL; //retrieve EID0-EID7 00567 msg->identifier += ((unsigned long) RXB1EIDH) << 8; //retrieve EID8-EID15 00568 00569 if (RXB1SIDLbits.EID16) 00570 msg->identifier |= 0x00010000; 00571 if (RXB1SIDLbits.EID17) 00572 msg->identifier |= 0x00020000; 00573 if (RXB1SIDLbits.SID0) 00574 msg->identifier |= 0x00040000; 00575 if (RXB1SIDLbits.SID1) 00576 msg->identifier |= 0x00080000; 00577 if (RXB1SIDLbits.SID2) 00578 msg->identifier |= 0x00100000; 00579 00580 msg->identifier |= ((unsigned long) RXB1SIDH) << 21; 00581 } 00582 00583 RXB1CONbits.RXFUL = 0x00; //release the RX buffer for new messages 00584 return (error); 00585 } 00586 00587 if (RXB0CONbits.RXFUL ==0x01) //RX Buffer 0 is read 00588 { 00589 msg->identifier = 0; 00590 msg->data[0] =RXB0D0; //retrieve the data 00591 msg->data[1] =RXB0D1; 00592 msg->data[2] =RXB0D2; 00593 msg->data[3] =RXB0D3; 00594 msg->data[4] =RXB0D4; 00595 msg->data[5] =RXB0D5; 00596 msg->data[6] =RXB0D6; 00597 msg->data[7] =RXB0D7; 00598 00599 msg->RTR = RXB0DLCbits.RXRTR; //retrieve the RTR bit 00600 00601 msg->length = RXB0DLC & 0x0F; //retrieve the lenght 00602 00603 msg->type = RXB0SIDLbits.EXID; //retrieve the format (standard or extended) 00604 00605 if (RXB0SIDLbits.EXID == 0) //reading the identifier standard format 00606 { 00607 msg->identifier = ((unsigned long)RXB0SIDH)<< 3; 00608 tamp = (RXB0SIDL >> 5 ) & 0x07; 00609 msg->identifier = msg->identifier + tamp; 00610 } 00611 else // reading the identifier extended format 00612 { 00613 msg->identifier = (unsigned long) RXB0EIDL; //retrieve EID0-EID7 00614 msg->identifier += ((unsigned long) RXB0EIDH) << 8; //retrieve EID8-EID15 00615 00616 if (RXB0SIDLbits.EID16) 00617 msg->identifier |= 0x00010000; 00618 if (RXB0SIDLbits.EID17) 00619 msg->identifier |= 0x00020000; 00620 if (RXB0SIDLbits.SID0) 00621 msg->identifier |= 0x00040000; 00622 if (RXB0SIDLbits.SID1) 00623 msg->identifier |= 0x00080000; 00624 if (RXB0SIDLbits.SID2) 00625 msg->identifier |= 0x00100000; 00626 00627 msg->identifier |= ((unsigned long) RXB0SIDH) << 21; 00628 00629 } 00630 RXB0CONbits.RXFUL = 0x00; //release the RX buffer for new messages 00631 00632 return (error); 00633 } 00634 } 00635 00636 //********************************************* 00637 // Set the RX MASK 00638 //********************************************* 00639 00640 void CANSetMask(enum CAN_MASK numBuffer, unsigned long mask, enum CAN_CONFIG_FLAGS type) 00641 { unsigned long tamp; //used as a tamp to set the identifier 00642 00643 if ((numBuffer ==CAN_MASK_B1) && (type == CAN_CONFIG_STD_MSG)) //Standard MASK RX BUFFER 1 00644 { 00645 tamp = (mask >> 3); 00646 tamp = tamp & 0x000000FF; 00647 RXM0SIDH = (unsigned char) tamp; 00648 00649 tamp = mask & 0x00000007; 00650 tamp = tamp << 5; 00651 RXM0SIDL = (unsigned char) tamp; 00652 } 00653 00654 if ((numBuffer ==CAN_MASK_B2) && (type == CAN_CONFIG_STD_MSG)) //Standard MASK RX BUFFER2 00655 { 00656 tamp = (mask >> 3); 00657 tamp = tamp & 0x000000FF; 00658 RXM1SIDH = (unsigned char) tamp; 00659 00660 tamp = mask & 0x00000007; 00661 tamp = tamp << 5; 00662 RXM1SIDL = (unsigned char) tamp; 00663 } 00664 00665 if ((numBuffer ==CAN_MASK_B1) && (type == CAN_CONFIG_XTD_MSG)) //Extended MASK RX BUFFER 1 00666 { 00667 tamp = mask & 0x000000FF; //EID0 - EID7 setting 00668 RXM0EIDL = (unsigned char) tamp; 00669 00670 tamp = mask & 0x0000FF00; //EID8 - EID15 setting 00671 tamp = tamp >> 8; 00672 RXM0EIDH = (unsigned char) tamp; 00673 00674 if (mask & 0x00010000) 00675 RXM0SIDLbits.EID16 = 0x01; 00676 else 00677 RXM0SIDLbits.EID16 = 0x00; 00678 00679 if (mask & 0x00020000) 00680 RXM0SIDLbits.EID17 = 0x01; 00681 else 00682 RXM0SIDLbits.EID17 = 0x00; 00683 00684 if (mask & 0x00040000) 00685 RXM0SIDLbits.SID0 = 0x01; 00686 else 00687 RXM0SIDLbits.SID0 = 0x00; 00688 00689 if (mask & 0x00080000) 00690 RXM0SIDLbits.SID1 = 0x01; 00691 else 00692 RXM0SIDLbits.SID1 = 0x00; 00693 00694 if (mask & 0x00100000) 00695 RXM0SIDLbits.SID2 = 0x01 ; 00696 else 00697 RXM0SIDLbits.SID2 = 0x00 ; 00698 00699 tamp = (mask >> 21); 00700 tamp = tamp & 0x000000FF; 00701 RXM0SIDH = (unsigned char) tamp; 00702 } 00703 00704 if ((numBuffer ==CAN_MASK_B2) && (type == CAN_CONFIG_XTD_MSG)) //Extended MASK BUFFER 2 00705 { 00706 tamp = mask & 0x000000FF; //EID0 - EID7 setting 00707 RXM1EIDL = (unsigned char) tamp; 00708 00709 tamp = mask & 0x0000FF00; //EID8 - EID15 setting 00710 tamp = tamp >> 8; 00711 RXM1EIDH = (unsigned char) tamp; 00712 00713 if (mask & 0x00010000) 00714 RXM1SIDLbits.EID16 = 0x01; 00715 else 00716 RXM1SIDLbits.EID16 = 0x00; 00717 00718 if (mask & 0x00020000) 00719 RXM1SIDLbits.EID17 = 0x01; 00720 else 00721 RXM1SIDLbits.EID17 = 0x00; 00722 00723 if (mask & 0x00040000) 00724 RXM1SIDLbits.SID0 = 0x01; 00725 else 00726 RXM1SIDLbits.SID0 = 0x00; 00727 00728 if (mask & 0x00080000) 00729 RXM1SIDLbits.SID1 = 0x01; 00730 else 00731 RXM1SIDLbits.SID1 = 0x00; 00732 00733 if (mask & 0x00100000) 00734 RXM1SIDLbits.SID2 = 0x01 ; 00735 else 00736 RXM1SIDLbits.SID2 = 0x00 ; 00737 00738 tamp = (mask >> 21); 00739 tamp = tamp & 0x000000FF; 00740 RXM1SIDH = (unsigned char) tamp; 00741 } 00742 } 00743 00744 //********************************************* 00745 // Set the RX Filters 00746 //********************************************* 00747 00748 void CANSetFilter(enum CAN_FILTER numBuffer, unsigned long filter, enum CAN_CONFIG_FLAGS type) 00749 { 00750 unsigned long tamp; 00751 00752 if ((numBuffer ==CAN_FILTER_B1_F1) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 1 BUFFER 1 00753 { 00754 RXF0SIDLbits.EXIDEN = 0x00; //standard filter 00755 00756 tamp = (filter >> 3); 00757 tamp = tamp & 0x000000FF; 00758 RXF0SIDH = (unsigned char) tamp; 00759 00760 tamp = filter & 0x00000007; 00761 tamp = tamp << 5; 00762 RXF0SIDL = (unsigned char) tamp; 00763 } 00764 00765 if ((numBuffer ==CAN_FILTER_B1_F2) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 2 BUFFER 1 00766 { 00767 RXF1SIDLbits.EXIDEN = 0x00; //standard filter 00768 00769 tamp = (filter >> 3); 00770 tamp = tamp & 0x000000FF; 00771 RXF1SIDH = (unsigned char) tamp; 00772 00773 tamp = filter & 0x00000007; 00774 tamp = tamp << 5; 00775 RXF1SIDL = (unsigned char) tamp; 00776 } 00777 00778 if ((numBuffer ==CAN_FILTER_B2_F1) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 1 BUFFER 2 00779 { 00780 RXF2SIDLbits.EXIDEN = 0x00; //standard filter 00781 00782 tamp = (filter >> 3); 00783 tamp = tamp & 0x000000FF; 00784 RXF2SIDH = (unsigned char) tamp; 00785 00786 tamp = filter & 0x00000007; 00787 tamp = tamp << 5; 00788 RXF2SIDL = (unsigned char) tamp; 00789 } 00790 00791 if ((numBuffer ==CAN_FILTER_B2_F2) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 2 BUFFER 2 00792 { 00793 RXF3SIDLbits.EXIDEN = 0x00; //standard filter 00794 00795 tamp = (filter >> 3); 00796 tamp = tamp & 0x000000FF; 00797 RXF3SIDH = (unsigned char) tamp; 00798 00799 tamp = filter & 0x00000007; 00800 tamp = tamp << 5; 00801 RXF3SIDL = (unsigned char) tamp; 00802 } 00803 00804 if ((numBuffer ==CAN_FILTER_B2_F3) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 3 BUFFER 2 00805 { 00806 RXF4SIDLbits.EXIDEN = 0x00; //standard filter 00807 00808 tamp = (filter >> 3); 00809 tamp = tamp & 0x000000FF; 00810 RXF4SIDH = (unsigned char) tamp; 00811 00812 tamp = filter & 0x00000007; 00813 tamp = tamp << 5; 00814 RXF4SIDL = (unsigned char) tamp; 00815 } 00816 00817 if ((numBuffer ==CAN_FILTER_B2_F4) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 4 BUFFER 2 00818 { 00819 RXF5SIDLbits.EXIDEN = 0x00; //standard filter 00820 00821 tamp = (filter >> 3); 00822 tamp = tamp & 0x000000FF; 00823 RXF5SIDH = (unsigned char) tamp; 00824 00825 tamp = filter & 0x00000007; 00826 tamp = tamp << 5; 00827 RXF5SIDL = (unsigned char) tamp; 00828 } 00829 00830 00831 if ((numBuffer ==CAN_FILTER_B1_F1) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 1 BUFFER 1 00832 { 00833 RXF0SIDLbits.EXIDEN = 0x01; //standard filter 00834 00835 tamp = filter & 0x000000FF; //EID0 - EID7 setting 00836 RXF0EIDL = (unsigned char) tamp; 00837 00838 tamp = filter & 0x0000FF00; //EID8 - EID15 setting 00839 tamp = tamp >> 8; 00840 RXF0EIDH = (unsigned char) tamp; 00841 00842 if (filter & 0x00010000) 00843 RXF0SIDLbits.EID16 = 0x01; 00844 else 00845 RXF0SIDLbits.EID16 = 0x00; 00846 00847 if (filter & 0x00020000) 00848 RXF0SIDLbits.EID17 = 0x01; 00849 else 00850 RXF0SIDLbits.EID17 = 0x00; 00851 00852 if (filter & 0x00040000) 00853 RXF0SIDLbits.SID0 = 0x01; 00854 else 00855 RXF0SIDLbits.SID0 = 0x00; 00856 00857 if (filter & 0x00080000) 00858 RXF0SIDLbits.SID1 = 0x01; 00859 else 00860 RXF0SIDLbits.SID1 = 0x00; 00861 00862 if (filter & 0x00100000) 00863 RXF0SIDLbits.SID2 = 0x01 ; 00864 else 00865 RXF0SIDLbits.SID2 = 0x00 ; 00866 00867 tamp = (filter >> 21); 00868 tamp = tamp & 0x000000FF; 00869 RXF0SIDH = (unsigned char) tamp; 00870 } 00871 00872 if ((numBuffer ==CAN_FILTER_B1_F2) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 2 BUFFER 1 00873 { 00874 RXF1SIDLbits.EXIDEN = 0x01; //standard filter 00875 00876 tamp = filter & 0x000000FF; //EID0 - EID7 setting 00877 RXF1EIDL = (unsigned char) tamp; 00878 00879 tamp = filter & 0x0000FF00; //EID8 - EID15 setting 00880 tamp = tamp >> 8; 00881 RXF1EIDH = (unsigned char) tamp; 00882 00883 if (filter & 0x00010000) 00884 RXF1SIDLbits.EID16 = 0x01; 00885 else 00886 RXF1SIDLbits.EID16 = 0x00; 00887 00888 if (filter & 0x00020000) 00889 RXF1SIDLbits.EID17 = 0x01; 00890 else 00891 RXF1SIDLbits.EID17 = 0x00; 00892 00893 if (filter & 0x00040000) 00894 RXF1SIDLbits.SID0 = 0x01; 00895 else 00896 RXF1SIDLbits.SID0 = 0x00; 00897 00898 if (filter & 0x00080000) 00899 RXF1SIDLbits.SID1 = 0x01; 00900 else 00901 RXF1SIDLbits.SID1 = 0x00; 00902 00903 if (filter & 0x00100000) 00904 RXF1SIDLbits.SID2 = 0x01 ; 00905 else 00906 RXF1SIDLbits.SID2 = 0x00 ; 00907 00908 tamp = (filter >> 21); 00909 tamp = tamp & 0x000000FF; 00910 RXF1SIDH = (unsigned char) tamp; 00911 } 00912 00913 00914 if ((numBuffer ==CAN_FILTER_B2_F1) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 1 BUFFER 2 00915 { 00916 RXF2SIDLbits.EXIDEN = 0x01; //standard filter 00917 00918 tamp = filter & 0x000000FF; //EID0 - EID7 setting 00919 RXF2EIDL = (unsigned char) tamp; 00920 00921 tamp = filter & 0x0000FF00; //EID8 - EID15 setting 00922 tamp = tamp >> 8; 00923 RXF2EIDH = (unsigned char) tamp; 00924 00925 if (filter & 0x00010000) 00926 RXF2SIDLbits.EID16 = 0x01; 00927 else 00928 RXF2SIDLbits.EID16 = 0x00; 00929 00930 if (filter & 0x00020000) 00931 RXF2SIDLbits.EID17 = 0x01; 00932 else 00933 RXF2SIDLbits.EID17 = 0x00; 00934 00935 if (filter & 0x00040000) 00936 RXF2SIDLbits.SID0 = 0x01; 00937 else 00938 RXF2SIDLbits.SID0 = 0x00; 00939 00940 if (filter & 0x00080000) 00941 RXF2SIDLbits.SID1 = 0x01; 00942 else 00943 RXF2SIDLbits.SID1 = 0x00; 00944 00945 if (filter & 0x00100000) 00946 RXF2SIDLbits.SID2 = 0x01 ; 00947 else 00948 RXF2SIDLbits.SID2 = 0x00 ; 00949 00950 tamp = (filter >> 21); 00951 tamp = tamp & 0x000000FF; 00952 RXF2SIDH = (unsigned char) tamp; 00953 } 00954 00955 if ((numBuffer ==CAN_FILTER_B2_F2) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 2 BUFFER 2 00956 { 00957 RXF3SIDLbits.EXIDEN = 0x01; //standard filter 00958 00959 tamp = filter & 0x000000FF; //EID0 - EID7 setting 00960 RXF3EIDL = (unsigned char) tamp; 00961 00962 tamp = filter & 0x0000FF00; //EID8 - EID15 setting 00963 tamp = tamp >> 8; 00964 RXF3EIDH = (unsigned char) tamp; 00965 00966 if (filter & 0x00010000) 00967 RXF3SIDLbits.EID16 = 0x01; 00968 else 00969 RXF3SIDLbits.EID16 = 0x00; 00970 00971 if (filter & 0x00020000) 00972 RXF3SIDLbits.EID17 = 0x01; 00973 else 00974 RXF3SIDLbits.EID17 = 0x00; 00975 00976 if (filter & 0x00040000) 00977 RXF3SIDLbits.SID0 = 0x01; 00978 else 00979 RXF3SIDLbits.SID0 = 0x00; 00980 00981 if (filter & 0x00080000) 00982 RXF3SIDLbits.SID1 = 0x01; 00983 else 00984 RXF3SIDLbits.SID1 = 0x00; 00985 00986 if (filter & 0x00100000) 00987 RXF3SIDLbits.SID2 = 0x01 ; 00988 else 00989 RXF3SIDLbits.SID2 = 0x00 ; 00990 00991 tamp = (filter >> 21); 00992 tamp = tamp & 0x000000FF; 00993 RXF3SIDH = (unsigned char) tamp; 00994 } 00995 00996 if ((numBuffer ==CAN_FILTER_B2_F3) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 3 BUFFER 2 00997 { 00998 RXF4SIDLbits.EXIDEN = 0x01; //standard filter 00999 01000 tamp = filter & 0x000000FF; //EID0 - EID7 setting 01001 RXF4EIDL = (unsigned char) tamp; 01002 01003 tamp = filter & 0x0000FF00; //EID8 - EID15 setting 01004 tamp = tamp >> 8; 01005 RXF4EIDH = (unsigned char) tamp; 01006 01007 if (filter & 0x00010000) 01008 RXF4SIDLbits.EID16 = 0x01; 01009 else 01010 RXF4SIDLbits.EID16 = 0x00; 01011 01012 if (filter & 0x00020000) 01013 RXF4SIDLbits.EID17 = 0x01; 01014 else 01015 RXF4SIDLbits.EID17 = 0x00; 01016 01017 if (filter & 0x00040000) 01018 RXF4SIDLbits.SID0 = 0x01; 01019 else 01020 RXF4SIDLbits.SID0 = 0x00; 01021 01022 if (filter & 0x00080000) 01023 RXF4SIDLbits.SID1 = 0x01; 01024 else 01025 RXF4SIDLbits.SID1 = 0x00; 01026 01027 if (filter & 0x00100000) 01028 RXF4SIDLbits.SID2 = 0x01 ; 01029 else 01030 RXF4SIDLbits.SID2 = 0x00 ; 01031 01032 tamp = (filter >> 21); 01033 tamp = tamp & 0x000000FF; 01034 RXF4SIDH = (unsigned char) tamp; 01035 } 01036 01037 if ((numBuffer ==CAN_FILTER_B2_F4) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 4 BUFFER 2 01038 { 01039 RXF5SIDLbits.EXIDEN = 0x01; //standard filter 01040 01041 tamp = filter & 0x000000FF; //EID0 - EID7 setting 01042 RXF5EIDL = (unsigned char) tamp; 01043 01044 tamp = filter & 0x0000FF00; //EID8 - EID15 setting 01045 tamp = tamp >> 8; 01046 RXF5EIDH = (unsigned char) tamp; 01047 01048 if (filter & 0x00010000) 01049 RXF5SIDLbits.EID16 = 0x01; 01050 else 01051 RXF5SIDLbits.EID16 = 0x00; 01052 01053 if (filter & 0x00020000) 01054 RXF5SIDLbits.EID17 = 0x01; 01055 else 01056 RXF5SIDLbits.EID17 = 0x00; 01057 01058 if (filter & 0x00040000) 01059 RXF5SIDLbits.SID0 = 0x01; 01060 else 01061 RXF5SIDLbits.SID0 = 0x00; 01062 01063 if (filter & 0x00080000) 01064 RXF5SIDLbits.SID1 = 0x01; 01065 else 01066 RXF5SIDLbits.SID1 = 0x00; 01067 01068 if (filter & 0x00100000) 01069 RXF5SIDLbits.SID2 = 0x01 ; 01070 else 01071 RXF5SIDLbits.SID2 = 0x00 ; 01072 01073 tamp = (filter >> 21); 01074 tamp = tamp & 0x000000FF; 01075 RXF5SIDH = (unsigned char) tamp; 01076 } 01077 01078 } 01079 01080 01081 //********************************************* 01082 // Abort all the pending messages 01083 //********************************************* 01084 01085 void CANAbortMessages (void) 01086 { 01087 CANCONbits.ABAT = 1; 01088 } 01089 01090 01091 //********************************************* 01092 // Return 1 if the Bus is OFF 01093 //********************************************* 01094 BYTE CANisBusOFF (void) 01095 { 01096 return (COMSTATbits.TXBO); 01097 } 01098 01099 //********************************************* 01100 // Return 1 if there is a TX passive status 01101 //********************************************* 01102 BYTE CANisTXpassive (void) 01103 { 01104 return (COMSTATbits.TXBP); 01105 } 01106 01107 01108 //********************************************* 01109 // Return 1 if there is a TX passive status 01110 //********************************************* 01111 BYTE CANisRXpassive (void) 01112 { 01113 return (COMSTATbits.RXBP); 01114 } 01115 01116 //********************************************* 01117 // Return 1 if TX warning is ON 01118 //********************************************* 01119 BYTE CANisTXwarningON (void) 01120 { 01121 return (COMSTATbits.TXWARN); 01122 } 01123 01124 //********************************************* 01125 // Return 1 if RX warning is ON 01126 //********************************************* 01127 BYTE CANisRXwarningON (void) 01128 { 01129 return (COMSTATbits.RXWARN); 01130 } 01131 01132 //********************************************* 01133 // Return TX error Count 01134 //********************************************* 01135 01136 BYTE CANgetTXerrorCount (void) 01137 { 01138 return (TXERRCNT); 01139 } 01140 01141 //********************************************* 01142 // Return RX error Count 01143 //********************************************* 01144 01145 BYTE CANgetRXerrorCount (void) 01146 { 01147 return (RXERRCNT); 01148 } 01149 01150 //********************************************* 01151 // Return 1 if at least 1 TX buffer is empty 01152 //********************************************* 01153 01154 BYTE CANisTxReady (void) 01155 { 01156 return (!TXB0CONbits.TXREQ || !TXB1CONbits.TXREQ || !TXB2CONbits.TXREQ); //if at least one flag is 0, it returns return 1 01157 } 01158 01159 //********************************************* 01160 // Return 1 if one or more RX buffer are full 01161 //********************************************* 01162 01163 BYTE CANisRxReady (void) 01164 { 01165 return (RXB0CONbits.RXFUL || RXB1CONbits.RXFUL); 01166 } 01167 01168 #endif