C18 LaurTec Library  2.5
Open Source C Library for PIC18 Microcontrollers
LaurTec_c18_libraries_v_2.5/inc/CANlib.h
Go to the documentation of this file.
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
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines