PIC18 LaurTec Library  3.1
Open Source C Library for PIC18 Microcontrollers based on C18 - XC8 Compilers
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
CANlib.h
Go to the documentation of this file.
1 /*******************************************************
2 
3 Author : Mauro Laurenti
4 Version : 1.0
5 Date : 4/11/2007
6 
7 CopyRight 2007 all rights are reserved
8 
9 
10 ********************************************************
11 SOFTWARE LICENSE AGREEMENT
12 ********************************************************
13 
14 The usage of the supplied software imply the acceptance of the following license.
15 
16 The software supplied herewith by Mauro Laurenti (the Author)
17 is intended for use solely and exclusively on Microchip PIC Microcontroller (registered mark).
18 The software is owned by the Author, and is protected under applicable copyright laws.
19 All rights are reserved.
20 Any use in violation of the foregoing restrictions may subject the
21 user to criminal sanctions under applicable laws (Italian or International ones), as well as to
22 civil liability for the breach of the terms and conditions of this license.
23 Commercial use is forbidden without a written acknowledgment with the Author.
24 Personal or educational use is allowed if the application containing the following
25 software doesn't aim to commercial use or monetary earning of any kind.
26 
27 THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES,
28 WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
29 TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
30 PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE AUTHOR SHALL NOT,
31 IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
32 CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
33 
34 ********************************************************
35 PURPOSES
36 ********************************************************
37 
38 This library is supposed to be used for CAN bus
39 application. All the basic functions are included.
40 Standard and Extended messages are supported
41 
42 *******************************************************
43 *******************************************************/
44 
45 #ifndef CAN_FLAG //it allows to include the library in multiple points
46 #define CAN_FLAG
47 
48 
49 typedef unsigned char BYTE;
50 
51 
52 typedef struct
53 {
54  unsigned long identifier;
55  BYTE data[8];
56  BYTE type; //1 = IDE 0=standard
57  BYTE length; // data length
58  BYTE RTR; //Remote flag. 1 it means remote frame
59 
60 } CANmessage;
61 
62 
63 //************************************************************************
64 // constants used for CANOperationMode function
65 //************************************************************************
66 
68 {
69  CAN_OP_MODE_NORMAL = 0b00000000,
70  CAN_OP_MODE_SLEEP = 0b00100000,
71  CAN_OP_MODE_LOOP = 0b01000000,
72  CAN_OP_MODE_LISTEN = 0b01100000,
73  CAN_OP_MODE_CONFIG = 0b10000000
74 };
75 
76 //************************************************************************
77 // constants used for CANInitialize function
78 //************************************************************************
79 
81 {
82  CAN_CONFIG_DEFAULT = 0b11111111, // 11111111
83 
85  CAN_CONFIG_PHSEG2_PRG_ON = 0b11111111, // XXXXXXX1
86  CAN_CONFIG_PHSEG2_PRG_OFF = 0b11111110, // XXXXXXX0
87 
89  CAN_CONFIG_LINE_FILTER_ON = 0b11111111, // XXXXXX1X
90  CAN_CONFIG_LINE_FILTER_OFF = 0b11111101, // XXXXXX0X
91 
92  CAN_CONFIG_SAMPLE_BIT = 0b00000100,
93  CAN_CONFIG_SAMPLE_ONCE = 0b11111111, // XXXXX1XX
94  CAN_CONFIG_SAMPLE_THRICE = 0b11111011, // XXXXX0XX
95 
97  CAN_CONFIG_STD_MSG = 0b11111111, // XXXX1XXX
98  CAN_CONFIG_XTD_MSG = 0b11110111, // XXXX0XXX
99 
101  CAN_CONFIG_DBL_BUFFER_ON = 0b11111111, // XXX1XXXX
102  CAN_CONFIG_DBL_BUFFER_OFF = 0b11101111, // XXX0XXXX
103 
104  CAN_CONFIG_MSG_BITS = 0b01100000,
105  CAN_CONFIG_ALL_MSG = 0b11111111, // X11XXXXX
106  CAN_CONFIG_VALID_XTD_MSG = 0b11011111, // X10XXXXX
107  CAN_CONFIG_VALID_STD_MSG = 0b10111111, // X01XXXXX
108  CAN_CONFIG_ALL_VALID_MSG = 0b10011111 // X00XXXXX
109 };
110 
111 
112 //************************************************************************
113 // constants used for CANsendMessage function
114 //************************************************************************
115 
117  {
118  CAN_TX_PRIORITY_MASK= 0b00000011, // bit mask
119  CAN_TX_PRIORITY_0 = 0b11111100, // XXXXXX00
120  CAN_TX_PRIORITY_1 = 0b11111101, // XXXXXX01
121  CAN_TX_PRIORITY_2 = 0b11111110, // XXXXXX10
122  CAN_TX_PRIORITY_3 = 0b11111111, // XXXXXX11
123 
124  CAN_TX_FRAME_MASK = 0b00001000, // bit mask
125  CAN_TX_STD_FRAME = 0b11110111, // XXXX0XXX
126  CAN_TX_XTD_FRAME = 0b11111111, // XXXX1XXX
127 
128  CAN_TX_RTR_MASK = 0b01000000, // bit mask
129  CAN_REMOTE_TX_FRAME = 0b11111111, // X1XXXXXX
130  CAN_NORMAL_TX_FRAME = 0b10111111 // X0XXXXXX
131 
132 };
133 
134 //************************************************************************
135 // constants used for MASK function
136 //************************************************************************
137 
139 {
142 };
143 
144 //************************************************************************
145 // constants used for Filter function
146 //************************************************************************
147 
149 {
156 };
157 
158 //************************************************************************
159 // constants used for RX errors
160 //************************************************************************
161 
163 {
164  CAN_RX_BUFFER_1_OVFL = 0b00000001,
165  CAN_RX_BUFFER_2_OVFL = 0b00000010
166 };
167 
168 //************************************************************************
169 // Functions Prototypes
170 //************************************************************************
171 
172 
173 void CANOperationMode (enum CAN_OP_MODE mode);
174 void CANInitialize (BYTE propSeg, BYTE phaseSeg1, BYTE phaseSeg2,BYTE SJW, BYTE BRP, enum CAN_CONFIG_FLAGS flags);
175 
176 void CANsendMessage (unsigned long identifier, BYTE *data, BYTE dataLength, enum CAN_TX_MSG_FLAGS flags);
178 
179 void CANSetMask(enum CAN_MASK code, unsigned long val, enum CAN_CONFIG_FLAGS type);
180 void CANSetFilter(enum CAN_FILTER code, unsigned long val, enum CAN_CONFIG_FLAGS type);
181 
182 BYTE CANisTxReady (void);
183 BYTE CANisRxReady (void);
184 
185 BYTE CANisTXpassive (void);
186 BYTE CANisRXpassive (void);
187 BYTE CANisTXwarningON (void);
188 BYTE CANisRXwarningON (void);
189 BYTE CANgetTXerrorCount (void);
190 BYTE CANgetRXerrorCount (void);
191 
192 BYTE CANisBusOFF (void);
193 void CANAbortMessages (void);
194 
195 
196 //************************************************************************
197 // Functions Implementation
198 //************************************************************************
199 
200 
201 //*********************************************
202 //Set the CAN engine mode
203 //*********************************************
204 
205 
207 {
208  CANCON = mode;
209 
210  while((CANSTAT & 0b11100000) != mode );
211 }
212 
213 
214 //*********************************************
215 //Initialize the CAN bus
216 //*********************************************
217 
218 void CANInitialize (BYTE propSeg, BYTE phaseSeg1, BYTE phaseSeg2,BYTE SJW, BYTE BRP, enum CAN_CONFIG_FLAGS flags)
219 {
220  BYTE FilterConfig1;
221  BYTE FilterConfig2;
222 
223  CANOperationMode(CAN_OP_MODE_CONFIG); //setting configuration mode
224 
225  BRGCON1 = 0x00; //cleaning the value
226  BRGCON2 = 0x00; //cleaning the value
227  BRGCON3 = 0x00; //cleaning the value
228 
229  SJW= SJW << 6;
230  BRGCON1 |= SJW;
231  BRGCON1 |= BRP;
232 
233  BRGCON2 |= propSeg;
234  phaseSeg1 = phaseSeg1 <<3;
235  BRGCON2 |= phaseSeg1;
236 
237  if ( !(flags & CAN_CONFIG_SAMPLE_BIT) ) //SAM
238  BRGCON2bits.SAM= 1;
239 
240  if ( flags & CAN_CONFIG_PHSEG2_PRG_BIT )
241  BRGCON2bits.SEG2PHTS = 1;
242 
243  BRGCON3 |= phaseSeg2;
244 
245  if ( flags & CAN_CONFIG_LINE_FILTER_BIT )
246  BRGCON3bits.WAKFIL = 1;
247 
248 
249  //Receiver Settings
250 
251  RXB0CON = flags & CAN_CONFIG_MSG_BITS;
253  RXB0CONbits.RXB0DBEN = 1;
254 
255  RXB1CON = RXB0CON;
256 
257  //Setting the mask to receive all the messages
258 
261 
262 
263  switch( (flags & CAN_CONFIG_MSG_BITS) | ~CAN_CONFIG_MSG_BITS )
264  {
266  FilterConfig1 = CAN_CONFIG_XTD_MSG;
267  FilterConfig2 = CAN_CONFIG_XTD_MSG;
268  break;
269 
271  FilterConfig1 = CAN_CONFIG_STD_MSG;
272  FilterConfig2 = CAN_CONFIG_STD_MSG;
273  break;
274  default:
275  FilterConfig1 = CAN_CONFIG_STD_MSG; //Buffer 1 will receive the Standard messages
276  FilterConfig2 = CAN_CONFIG_XTD_MSG; //Buffer 2 will receive the Extended messages
277  break;
278  }
279 
280  CANSetFilter(CAN_FILTER_B1_F1, 0, FilterConfig1);
281  CANSetFilter(CAN_FILTER_B1_F2, 0, FilterConfig1);
282  CANSetFilter(CAN_FILTER_B2_F1, 0, FilterConfig2);
283  CANSetFilter(CAN_FILTER_B2_F2, 0, FilterConfig2);
284  CANSetFilter(CAN_FILTER_B2_F3, 0, FilterConfig2);
285  CANSetFilter(CAN_FILTER_B2_F4, 0, FilterConfig2);
286 
287  CANOperationMode(CAN_OP_MODE_NORMAL); //setting normal mode
288 
289 }
290 
291 //*********************************************
292 // Send a message
293 //*********************************************
294 void CANsendMessage (unsigned long identifier, BYTE *data, BYTE dataLength, enum CAN_TX_MSG_FLAGS flags)
295 {
296  unsigned long tamp; //used as a tamp to set the identifier
297 
298  if (TXB0CONbits.TXREQ == 0)
299  { TXB0DLC = dataLength; // set the data length
300  if (0b01000000 & flags) //set the RTR bit
301  TXB0DLCbits.TXRTR = 0x01;
302  else
303  TXB0DLCbits.TXRTR = 0x00;
304 
305  if (CAN_TX_FRAME_MASK & flags)
306  {
307 
308  tamp = identifier & 0x000000FF; //EID0 - EID7 setting
309  TXB0EIDL = (unsigned char) tamp;
310 
311  tamp = identifier & 0x0000FF00; //EID8 - EID15 setting
312  tamp = tamp >> 8;
313  TXB0EIDH = (unsigned char) tamp;
314 
315  TXB0SIDL = 0x00;
316  TXB0SIDLbits.EXIDE = 0x01;
317 
318  if (identifier & 0x00010000)
319  TXB0SIDLbits.EID16 = 0x01;
320  if (identifier & 0x00020000)
321  TXB0SIDLbits.EID17 = 0x01;
322  if (identifier & 0x00040000)
323  TXB0SIDLbits.SID0 = 0x01;
324  if (identifier & 0x00080000)
325  TXB0SIDLbits.SID1 = 0x01;
326  if (identifier & 0x00100000)
327  TXB0SIDLbits.SID2 = 0x01;
328 
329  tamp = (identifier >> 21);
330  tamp = tamp & 0x000000FF;
331  TXB0SIDH = (unsigned char) tamp;
332  }
333 
334  else
335 
336  {
337  TXB0SIDLbits.EXIDE = 0x00; //enable standard messages
338 
339  tamp = (identifier >> 3);
340  tamp = tamp & 0x000000FF;
341  TXB0SIDH = (unsigned char) tamp;
342 
343  tamp = identifier & 0x00000007;
344  tamp = tamp << 5;
345  TXB0SIDL = TXB0SIDL & 0b00011111;
346  TXB0SIDL = (unsigned char) tamp;
347  }
348 
349  if (0b00000001 & flags) //set transmission priority
350  TXB0CONbits.TXPRI0 = 0x01;
351  else
352  TXB0CONbits.TXPRI0 = 0x00;
353  if (0b00000010 & flags)
354  TXB0CONbits.TXPRI1 = 0x01;
355  else
356  TXB0CONbits.TXPRI1 = 0x00;
357 
358  TXB0D0 = data[0];
359  TXB0D1 = data[1];
360  TXB0D2 = data[2];
361  TXB0D3 = data[3];
362  TXB0D4 = data[4];
363  TXB0D5 = data[5];
364  TXB0D6 = data[6];
365  TXB0D7 = data[7];
366 
367  TXB0CONbits.TXREQ = 0x01; //enable trasmission
368  return;
369  }
370 
371 // Second TX Buffer setting
372 
373  if (TXB1CONbits.TXREQ == 0)
374  { TXB1DLC = dataLength; // set the data length
375 
376  if (0b01000000 & flags) //set the RTR bit
377  TXB1DLCbits.TXRTR = 0x01;
378  else
379  TXB1DLCbits.TXRTR = 0x00;
380 
381  if (CAN_TX_FRAME_MASK & flags)
382  {
383  tamp = identifier & 0x000000FF; //EID0 - EID7 setting
384  TXB1EIDL = (unsigned char) tamp;
385 
386  tamp = identifier & 0x0000FF00; //EID8 - EID15 setting
387  tamp = tamp >> 8;
388  TXB1EIDH = (unsigned char) tamp;
389 
390  TXB1SIDL = 0x00;
391  TXB1SIDLbits.EXIDE = 0x01;
392 
393  if (identifier & 0x00010000)
394  TXB1SIDLbits.EID16 = 0x01;
395  if (identifier & 0x00020000)
396  TXB1SIDLbits.EID17 = 0x01;
397  if (identifier & 0x00040000)
398  TXB1SIDLbits.SID0 = 0x01;
399  if (identifier & 0x00080000)
400  TXB1SIDLbits.SID1 = 0x01;
401  if (identifier & 0x00100000)
402  TXB1SIDLbits.SID2 = 0x01;
403 
404  tamp = (identifier >> 21);
405  tamp = tamp & 0x000000FF;
406  TXB1SIDH = (unsigned char) tamp;
407  }
408 
409  else
410 
411  {
412  TXB1SIDLbits.EXIDE = 0x00; //enable standard messages
413 
414  tamp = (identifier >> 3);
415  tamp = tamp & 0x000000FF;
416  TXB1SIDH = (unsigned char) tamp;
417 
418  tamp = identifier & 0x00000007;
419  tamp = tamp << 5;
420  TXB1SIDL = TXB1SIDL & 0b00011111;
421  TXB1SIDL = (unsigned char) tamp;
422  }
423 
424  if (0b00000001 & flags) //set transmission priority
425  TXB1CONbits.TXPRI0 = 0x01;
426  else
427  TXB1CONbits.TXPRI0 = 0x00;
428  if (0b00000010 & flags)
429  TXB1CONbits.TXPRI1 = 0x01;
430  else
431  TXB1CONbits.TXPRI1 = 0x00;
432 
433  TXB1D0 = data[0];
434  TXB1D1 = data[1];
435  TXB1D2 = data[2];
436  TXB1D3 = data[3];
437  TXB1D4 = data[4];
438  TXB1D5 = data[5];
439  TXB1D6 = data[6];
440  TXB1D7 = data[7];
441 
442  TXB1CONbits.TXREQ = 0x01; //enable trasmission
443 
444  return;
445  }
446 
447 // Third TX Buffer setting
448 
449  if (TXB2CONbits.TXREQ == 0)
450  { TXB2DLC = dataLength; // set the data length
451 
452  if (0b01000000 & flags) //set the RTR bit
453  TXB2DLCbits.TXRTR = 0x01;
454  else
455  TXB2DLCbits.TXRTR = 0x00;
456 
457  if (CAN_TX_FRAME_MASK & flags)
458  {
459  tamp = identifier & 0x000000FF; //EID0 - EID7 setting
460  TXB2EIDL = (unsigned char) tamp;
461 
462  tamp = identifier & 0x0000FF00; //EID8 - EID15 setting
463  tamp = tamp >> 8;
464  TXB2EIDH = (unsigned char) tamp;
465 
466  TXB2SIDL = 0x00;
467  TXB2SIDLbits.EXIDE = 0x01;
468 
469  if (identifier & 0x00010000)
470  TXB2SIDLbits.EID16 = 0x01;
471  if (identifier & 0x00020000)
472  TXB2SIDLbits.EID17 = 0x01;
473  if (identifier & 0x00040000)
474  TXB2SIDLbits.SID0 = 0x01;
475  if (identifier & 0x00080000)
476  TXB2SIDLbits.SID1 = 0x01;
477  if (identifier & 0x00100000)
478  TXB2SIDLbits.SID2 = 0x01;
479 
480  tamp = (identifier >> 21);
481  tamp = tamp & 0x000000FF;
482  TXB2SIDH = (unsigned char) tamp;
483  }
484 
485  else
486 
487  {
488  TXB2SIDLbits.EXIDE = 0x00; //enable standard messages
489 
490  tamp = (identifier >> 3);
491  tamp = tamp & 0x000000FF;
492  TXB2SIDH = (unsigned char) tamp;
493 
494  tamp = identifier & 0x00000007;
495  tamp = tamp << 5;
496  TXB2SIDL = TXB2SIDL & 0b00011111;
497  TXB2SIDL = (unsigned char) tamp;
498  }
499 
500  if (0b00000001 & flags) //set transmission priority
501  TXB2CONbits.TXPRI0 = 0x01;
502  else
503  TXB2CONbits.TXPRI0 = 0x00;
504  if (0b00000010 & flags)
505  TXB2CONbits.TXPRI1 = 0x01;
506  else
507  TXB2CONbits.TXPRI1 = 0x00;
508 
509  TXB2D0 = data[0];
510  TXB2D1 = data[1];
511  TXB2D2 = data[2];
512  TXB2D3 = data[3];
513  TXB2D4 = data[4];
514  TXB2D5 = data[5];
515  TXB2D6 = data[6];
516  TXB2D7 = data[7];
517 
518  TXB2CONbits.TXREQ = 0x01; //enable trasmission
519 
520  return;
521  }
522 }
523 
524 //*********************************************
525 // Read the message from the RX buffer
526 //*********************************************
527 
529 {
530  BYTE tamp;
531  BYTE error = 0;
532 
533  if (COMSTATbits.RXB0OVFL == 0x01) //check for buffers overflows
534  error |= CAN_RX_BUFFER_1_OVFL;
535 
536  if (COMSTATbits.RXB1OVFL == 0x01)
537  error |= CAN_RX_BUFFER_2_OVFL;
538 
539 
540  if (RXB1CONbits.RXFUL ==0x01) //RX Buffer 1 is read
541  {
542  msg->identifier = 0;
543  msg->data[0] =RXB1D0; //retrieve the data
544  msg->data[1] =RXB1D1;
545  msg->data[2] =RXB1D2;
546  msg->data[3] =RXB1D3;
547  msg->data[4] =RXB1D4;
548  msg->data[5] =RXB1D5;
549  msg->data[6] =RXB1D6;
550  msg->data[7] =RXB1D7;
551 
552  msg->RTR = RXB1DLCbits.RXRTR; //retrieve the RTR bit
553 
554  msg->length = RXB1DLC & 0x0F; //retrieve the lenght
555 
556  msg->type = RXB1SIDLbits.EXID; //retrieve the format (standard or extended)
557 
558  if (RXB1SIDLbits.EXID == 0) //reading the identifier standard format
559  {
560  msg->identifier = ((unsigned long)RXB1SIDH)<< 3;
561  tamp = (RXB1SIDL >> 5 ) & 0x07;
562  msg->identifier = msg->identifier + tamp;
563  }
564  else // reading the identifier extended format
565  {
566  msg->identifier = (unsigned long) RXB1EIDL; //retrieve EID0-EID7
567  msg->identifier += ((unsigned long) RXB1EIDH) << 8; //retrieve EID8-EID15
568 
569  if (RXB1SIDLbits.EID16)
570  msg->identifier |= 0x00010000;
571  if (RXB1SIDLbits.EID17)
572  msg->identifier |= 0x00020000;
573  if (RXB1SIDLbits.SID0)
574  msg->identifier |= 0x00040000;
575  if (RXB1SIDLbits.SID1)
576  msg->identifier |= 0x00080000;
577  if (RXB1SIDLbits.SID2)
578  msg->identifier |= 0x00100000;
579 
580  msg->identifier |= ((unsigned long) RXB1SIDH) << 21;
581  }
582 
583  RXB1CONbits.RXFUL = 0x00; //release the RX buffer for new messages
584  return (error);
585  }
586 
587  if (RXB0CONbits.RXFUL ==0x01) //RX Buffer 0 is read
588  {
589  msg->identifier = 0;
590  msg->data[0] =RXB0D0; //retrieve the data
591  msg->data[1] =RXB0D1;
592  msg->data[2] =RXB0D2;
593  msg->data[3] =RXB0D3;
594  msg->data[4] =RXB0D4;
595  msg->data[5] =RXB0D5;
596  msg->data[6] =RXB0D6;
597  msg->data[7] =RXB0D7;
598 
599  msg->RTR = RXB0DLCbits.RXRTR; //retrieve the RTR bit
600 
601  msg->length = RXB0DLC & 0x0F; //retrieve the lenght
602 
603  msg->type = RXB0SIDLbits.EXID; //retrieve the format (standard or extended)
604 
605  if (RXB0SIDLbits.EXID == 0) //reading the identifier standard format
606  {
607  msg->identifier = ((unsigned long)RXB0SIDH)<< 3;
608  tamp = (RXB0SIDL >> 5 ) & 0x07;
609  msg->identifier = msg->identifier + tamp;
610  }
611  else // reading the identifier extended format
612  {
613  msg->identifier = (unsigned long) RXB0EIDL; //retrieve EID0-EID7
614  msg->identifier += ((unsigned long) RXB0EIDH) << 8; //retrieve EID8-EID15
615 
616  if (RXB0SIDLbits.EID16)
617  msg->identifier |= 0x00010000;
618  if (RXB0SIDLbits.EID17)
619  msg->identifier |= 0x00020000;
620  if (RXB0SIDLbits.SID0)
621  msg->identifier |= 0x00040000;
622  if (RXB0SIDLbits.SID1)
623  msg->identifier |= 0x00080000;
624  if (RXB0SIDLbits.SID2)
625  msg->identifier |= 0x00100000;
626 
627  msg->identifier |= ((unsigned long) RXB0SIDH) << 21;
628 
629  }
630  RXB0CONbits.RXFUL = 0x00; //release the RX buffer for new messages
631 
632  return (error);
633  }
634 }
635 
636 //*********************************************
637 // Set the RX MASK
638 //*********************************************
639 
640 void CANSetMask(enum CAN_MASK numBuffer, unsigned long mask, enum CAN_CONFIG_FLAGS type)
641 { unsigned long tamp; //used as a tamp to set the identifier
642 
643  if ((numBuffer ==CAN_MASK_B1) && (type == CAN_CONFIG_STD_MSG)) //Standard MASK RX BUFFER 1
644  {
645  tamp = (mask >> 3);
646  tamp = tamp & 0x000000FF;
647  RXM0SIDH = (unsigned char) tamp;
648 
649  tamp = mask & 0x00000007;
650  tamp = tamp << 5;
651  RXM0SIDL = (unsigned char) tamp;
652  }
653 
654  if ((numBuffer ==CAN_MASK_B2) && (type == CAN_CONFIG_STD_MSG)) //Standard MASK RX BUFFER2
655  {
656  tamp = (mask >> 3);
657  tamp = tamp & 0x000000FF;
658  RXM1SIDH = (unsigned char) tamp;
659 
660  tamp = mask & 0x00000007;
661  tamp = tamp << 5;
662  RXM1SIDL = (unsigned char) tamp;
663  }
664 
665  if ((numBuffer ==CAN_MASK_B1) && (type == CAN_CONFIG_XTD_MSG)) //Extended MASK RX BUFFER 1
666  {
667  tamp = mask & 0x000000FF; //EID0 - EID7 setting
668  RXM0EIDL = (unsigned char) tamp;
669 
670  tamp = mask & 0x0000FF00; //EID8 - EID15 setting
671  tamp = tamp >> 8;
672  RXM0EIDH = (unsigned char) tamp;
673 
674  if (mask & 0x00010000)
675  RXM0SIDLbits.EID16 = 0x01;
676  else
677  RXM0SIDLbits.EID16 = 0x00;
678 
679  if (mask & 0x00020000)
680  RXM0SIDLbits.EID17 = 0x01;
681  else
682  RXM0SIDLbits.EID17 = 0x00;
683 
684  if (mask & 0x00040000)
685  RXM0SIDLbits.SID0 = 0x01;
686  else
687  RXM0SIDLbits.SID0 = 0x00;
688 
689  if (mask & 0x00080000)
690  RXM0SIDLbits.SID1 = 0x01;
691  else
692  RXM0SIDLbits.SID1 = 0x00;
693 
694  if (mask & 0x00100000)
695  RXM0SIDLbits.SID2 = 0x01 ;
696  else
697  RXM0SIDLbits.SID2 = 0x00 ;
698 
699  tamp = (mask >> 21);
700  tamp = tamp & 0x000000FF;
701  RXM0SIDH = (unsigned char) tamp;
702  }
703 
704  if ((numBuffer ==CAN_MASK_B2) && (type == CAN_CONFIG_XTD_MSG)) //Extended MASK BUFFER 2
705  {
706  tamp = mask & 0x000000FF; //EID0 - EID7 setting
707  RXM1EIDL = (unsigned char) tamp;
708 
709  tamp = mask & 0x0000FF00; //EID8 - EID15 setting
710  tamp = tamp >> 8;
711  RXM1EIDH = (unsigned char) tamp;
712 
713  if (mask & 0x00010000)
714  RXM1SIDLbits.EID16 = 0x01;
715  else
716  RXM1SIDLbits.EID16 = 0x00;
717 
718  if (mask & 0x00020000)
719  RXM1SIDLbits.EID17 = 0x01;
720  else
721  RXM1SIDLbits.EID17 = 0x00;
722 
723  if (mask & 0x00040000)
724  RXM1SIDLbits.SID0 = 0x01;
725  else
726  RXM1SIDLbits.SID0 = 0x00;
727 
728  if (mask & 0x00080000)
729  RXM1SIDLbits.SID1 = 0x01;
730  else
731  RXM1SIDLbits.SID1 = 0x00;
732 
733  if (mask & 0x00100000)
734  RXM1SIDLbits.SID2 = 0x01 ;
735  else
736  RXM1SIDLbits.SID2 = 0x00 ;
737 
738  tamp = (mask >> 21);
739  tamp = tamp & 0x000000FF;
740  RXM1SIDH = (unsigned char) tamp;
741  }
742 }
743 
744 //*********************************************
745 // Set the RX Filters
746 //*********************************************
747 
748 void CANSetFilter(enum CAN_FILTER numBuffer, unsigned long filter, enum CAN_CONFIG_FLAGS type)
749 {
750  unsigned long tamp;
751 
752  if ((numBuffer ==CAN_FILTER_B1_F1) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 1 BUFFER 1
753  {
754  RXF0SIDLbits.EXIDEN = 0x00; //standard filter
755 
756  tamp = (filter >> 3);
757  tamp = tamp & 0x000000FF;
758  RXF0SIDH = (unsigned char) tamp;
759 
760  tamp = filter & 0x00000007;
761  tamp = tamp << 5;
762  RXF0SIDL = (unsigned char) tamp;
763  }
764 
765  if ((numBuffer ==CAN_FILTER_B1_F2) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 2 BUFFER 1
766  {
767  RXF1SIDLbits.EXIDEN = 0x00; //standard filter
768 
769  tamp = (filter >> 3);
770  tamp = tamp & 0x000000FF;
771  RXF1SIDH = (unsigned char) tamp;
772 
773  tamp = filter & 0x00000007;
774  tamp = tamp << 5;
775  RXF1SIDL = (unsigned char) tamp;
776  }
777 
778  if ((numBuffer ==CAN_FILTER_B2_F1) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 1 BUFFER 2
779  {
780  RXF2SIDLbits.EXIDEN = 0x00; //standard filter
781 
782  tamp = (filter >> 3);
783  tamp = tamp & 0x000000FF;
784  RXF2SIDH = (unsigned char) tamp;
785 
786  tamp = filter & 0x00000007;
787  tamp = tamp << 5;
788  RXF2SIDL = (unsigned char) tamp;
789  }
790 
791  if ((numBuffer ==CAN_FILTER_B2_F2) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 2 BUFFER 2
792  {
793  RXF3SIDLbits.EXIDEN = 0x00; //standard filter
794 
795  tamp = (filter >> 3);
796  tamp = tamp & 0x000000FF;
797  RXF3SIDH = (unsigned char) tamp;
798 
799  tamp = filter & 0x00000007;
800  tamp = tamp << 5;
801  RXF3SIDL = (unsigned char) tamp;
802  }
803 
804  if ((numBuffer ==CAN_FILTER_B2_F3) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 3 BUFFER 2
805  {
806  RXF4SIDLbits.EXIDEN = 0x00; //standard filter
807 
808  tamp = (filter >> 3);
809  tamp = tamp & 0x000000FF;
810  RXF4SIDH = (unsigned char) tamp;
811 
812  tamp = filter & 0x00000007;
813  tamp = tamp << 5;
814  RXF4SIDL = (unsigned char) tamp;
815  }
816 
817  if ((numBuffer ==CAN_FILTER_B2_F4) && (type == CAN_CONFIG_STD_MSG)) // STANDARD FILTER 4 BUFFER 2
818  {
819  RXF5SIDLbits.EXIDEN = 0x00; //standard filter
820 
821  tamp = (filter >> 3);
822  tamp = tamp & 0x000000FF;
823  RXF5SIDH = (unsigned char) tamp;
824 
825  tamp = filter & 0x00000007;
826  tamp = tamp << 5;
827  RXF5SIDL = (unsigned char) tamp;
828  }
829 
830 
831  if ((numBuffer ==CAN_FILTER_B1_F1) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 1 BUFFER 1
832  {
833  RXF0SIDLbits.EXIDEN = 0x01; //standard filter
834 
835  tamp = filter & 0x000000FF; //EID0 - EID7 setting
836  RXF0EIDL = (unsigned char) tamp;
837 
838  tamp = filter & 0x0000FF00; //EID8 - EID15 setting
839  tamp = tamp >> 8;
840  RXF0EIDH = (unsigned char) tamp;
841 
842  if (filter & 0x00010000)
843  RXF0SIDLbits.EID16 = 0x01;
844  else
845  RXF0SIDLbits.EID16 = 0x00;
846 
847  if (filter & 0x00020000)
848  RXF0SIDLbits.EID17 = 0x01;
849  else
850  RXF0SIDLbits.EID17 = 0x00;
851 
852  if (filter & 0x00040000)
853  RXF0SIDLbits.SID0 = 0x01;
854  else
855  RXF0SIDLbits.SID0 = 0x00;
856 
857  if (filter & 0x00080000)
858  RXF0SIDLbits.SID1 = 0x01;
859  else
860  RXF0SIDLbits.SID1 = 0x00;
861 
862  if (filter & 0x00100000)
863  RXF0SIDLbits.SID2 = 0x01 ;
864  else
865  RXF0SIDLbits.SID2 = 0x00 ;
866 
867  tamp = (filter >> 21);
868  tamp = tamp & 0x000000FF;
869  RXF0SIDH = (unsigned char) tamp;
870  }
871 
872  if ((numBuffer ==CAN_FILTER_B1_F2) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 2 BUFFER 1
873  {
874  RXF1SIDLbits.EXIDEN = 0x01; //standard filter
875 
876  tamp = filter & 0x000000FF; //EID0 - EID7 setting
877  RXF1EIDL = (unsigned char) tamp;
878 
879  tamp = filter & 0x0000FF00; //EID8 - EID15 setting
880  tamp = tamp >> 8;
881  RXF1EIDH = (unsigned char) tamp;
882 
883  if (filter & 0x00010000)
884  RXF1SIDLbits.EID16 = 0x01;
885  else
886  RXF1SIDLbits.EID16 = 0x00;
887 
888  if (filter & 0x00020000)
889  RXF1SIDLbits.EID17 = 0x01;
890  else
891  RXF1SIDLbits.EID17 = 0x00;
892 
893  if (filter & 0x00040000)
894  RXF1SIDLbits.SID0 = 0x01;
895  else
896  RXF1SIDLbits.SID0 = 0x00;
897 
898  if (filter & 0x00080000)
899  RXF1SIDLbits.SID1 = 0x01;
900  else
901  RXF1SIDLbits.SID1 = 0x00;
902 
903  if (filter & 0x00100000)
904  RXF1SIDLbits.SID2 = 0x01 ;
905  else
906  RXF1SIDLbits.SID2 = 0x00 ;
907 
908  tamp = (filter >> 21);
909  tamp = tamp & 0x000000FF;
910  RXF1SIDH = (unsigned char) tamp;
911  }
912 
913 
914  if ((numBuffer ==CAN_FILTER_B2_F1) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 1 BUFFER 2
915  {
916  RXF2SIDLbits.EXIDEN = 0x01; //standard filter
917 
918  tamp = filter & 0x000000FF; //EID0 - EID7 setting
919  RXF2EIDL = (unsigned char) tamp;
920 
921  tamp = filter & 0x0000FF00; //EID8 - EID15 setting
922  tamp = tamp >> 8;
923  RXF2EIDH = (unsigned char) tamp;
924 
925  if (filter & 0x00010000)
926  RXF2SIDLbits.EID16 = 0x01;
927  else
928  RXF2SIDLbits.EID16 = 0x00;
929 
930  if (filter & 0x00020000)
931  RXF2SIDLbits.EID17 = 0x01;
932  else
933  RXF2SIDLbits.EID17 = 0x00;
934 
935  if (filter & 0x00040000)
936  RXF2SIDLbits.SID0 = 0x01;
937  else
938  RXF2SIDLbits.SID0 = 0x00;
939 
940  if (filter & 0x00080000)
941  RXF2SIDLbits.SID1 = 0x01;
942  else
943  RXF2SIDLbits.SID1 = 0x00;
944 
945  if (filter & 0x00100000)
946  RXF2SIDLbits.SID2 = 0x01 ;
947  else
948  RXF2SIDLbits.SID2 = 0x00 ;
949 
950  tamp = (filter >> 21);
951  tamp = tamp & 0x000000FF;
952  RXF2SIDH = (unsigned char) tamp;
953  }
954 
955  if ((numBuffer ==CAN_FILTER_B2_F2) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 2 BUFFER 2
956  {
957  RXF3SIDLbits.EXIDEN = 0x01; //standard filter
958 
959  tamp = filter & 0x000000FF; //EID0 - EID7 setting
960  RXF3EIDL = (unsigned char) tamp;
961 
962  tamp = filter & 0x0000FF00; //EID8 - EID15 setting
963  tamp = tamp >> 8;
964  RXF3EIDH = (unsigned char) tamp;
965 
966  if (filter & 0x00010000)
967  RXF3SIDLbits.EID16 = 0x01;
968  else
969  RXF3SIDLbits.EID16 = 0x00;
970 
971  if (filter & 0x00020000)
972  RXF3SIDLbits.EID17 = 0x01;
973  else
974  RXF3SIDLbits.EID17 = 0x00;
975 
976  if (filter & 0x00040000)
977  RXF3SIDLbits.SID0 = 0x01;
978  else
979  RXF3SIDLbits.SID0 = 0x00;
980 
981  if (filter & 0x00080000)
982  RXF3SIDLbits.SID1 = 0x01;
983  else
984  RXF3SIDLbits.SID1 = 0x00;
985 
986  if (filter & 0x00100000)
987  RXF3SIDLbits.SID2 = 0x01 ;
988  else
989  RXF3SIDLbits.SID2 = 0x00 ;
990 
991  tamp = (filter >> 21);
992  tamp = tamp & 0x000000FF;
993  RXF3SIDH = (unsigned char) tamp;
994  }
995 
996  if ((numBuffer ==CAN_FILTER_B2_F3) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 3 BUFFER 2
997  {
998  RXF4SIDLbits.EXIDEN = 0x01; //standard filter
999 
1000  tamp = filter & 0x000000FF; //EID0 - EID7 setting
1001  RXF4EIDL = (unsigned char) tamp;
1002 
1003  tamp = filter & 0x0000FF00; //EID8 - EID15 setting
1004  tamp = tamp >> 8;
1005  RXF4EIDH = (unsigned char) tamp;
1006 
1007  if (filter & 0x00010000)
1008  RXF4SIDLbits.EID16 = 0x01;
1009  else
1010  RXF4SIDLbits.EID16 = 0x00;
1011 
1012  if (filter & 0x00020000)
1013  RXF4SIDLbits.EID17 = 0x01;
1014  else
1015  RXF4SIDLbits.EID17 = 0x00;
1016 
1017  if (filter & 0x00040000)
1018  RXF4SIDLbits.SID0 = 0x01;
1019  else
1020  RXF4SIDLbits.SID0 = 0x00;
1021 
1022  if (filter & 0x00080000)
1023  RXF4SIDLbits.SID1 = 0x01;
1024  else
1025  RXF4SIDLbits.SID1 = 0x00;
1026 
1027  if (filter & 0x00100000)
1028  RXF4SIDLbits.SID2 = 0x01 ;
1029  else
1030  RXF4SIDLbits.SID2 = 0x00 ;
1031 
1032  tamp = (filter >> 21);
1033  tamp = tamp & 0x000000FF;
1034  RXF4SIDH = (unsigned char) tamp;
1035  }
1036 
1037  if ((numBuffer ==CAN_FILTER_B2_F4) && (type == CAN_CONFIG_XTD_MSG))// EXTENDED FILTER 4 BUFFER 2
1038  {
1039  RXF5SIDLbits.EXIDEN = 0x01; //standard filter
1040 
1041  tamp = filter & 0x000000FF; //EID0 - EID7 setting
1042  RXF5EIDL = (unsigned char) tamp;
1043 
1044  tamp = filter & 0x0000FF00; //EID8 - EID15 setting
1045  tamp = tamp >> 8;
1046  RXF5EIDH = (unsigned char) tamp;
1047 
1048  if (filter & 0x00010000)
1049  RXF5SIDLbits.EID16 = 0x01;
1050  else
1051  RXF5SIDLbits.EID16 = 0x00;
1052 
1053  if (filter & 0x00020000)
1054  RXF5SIDLbits.EID17 = 0x01;
1055  else
1056  RXF5SIDLbits.EID17 = 0x00;
1057 
1058  if (filter & 0x00040000)
1059  RXF5SIDLbits.SID0 = 0x01;
1060  else
1061  RXF5SIDLbits.SID0 = 0x00;
1062 
1063  if (filter & 0x00080000)
1064  RXF5SIDLbits.SID1 = 0x01;
1065  else
1066  RXF5SIDLbits.SID1 = 0x00;
1067 
1068  if (filter & 0x00100000)
1069  RXF5SIDLbits.SID2 = 0x01 ;
1070  else
1071  RXF5SIDLbits.SID2 = 0x00 ;
1072 
1073  tamp = (filter >> 21);
1074  tamp = tamp & 0x000000FF;
1075  RXF5SIDH = (unsigned char) tamp;
1076  }
1077 
1078 }
1079 
1080 
1081 //*********************************************
1082 // Abort all the pending messages
1083 //*********************************************
1084 
1085 void CANAbortMessages (void)
1086 {
1087  CANCONbits.ABAT = 1;
1088 }
1089 
1090 
1091 //*********************************************
1092 // Return 1 if the Bus is OFF
1093 //*********************************************
1095 {
1096  return (COMSTATbits.TXBO);
1097 }
1098 
1099 //*********************************************
1100 // Return 1 if there is a TX passive status
1101 //*********************************************
1103 {
1104  return (COMSTATbits.TXBP);
1105 }
1106 
1107 
1108 //*********************************************
1109 // Return 1 if there is a TX passive status
1110 //*********************************************
1112 {
1113  return (COMSTATbits.RXBP);
1114 }
1115 
1116 //*********************************************
1117 // Return 1 if TX warning is ON
1118 //*********************************************
1120 {
1121  return (COMSTATbits.TXWARN);
1122 }
1123 
1124 //*********************************************
1125 // Return 1 if RX warning is ON
1126 //*********************************************
1128 {
1129  return (COMSTATbits.RXWARN);
1130 }
1131 
1132 //*********************************************
1133 // Return TX error Count
1134 //*********************************************
1135 
1137 {
1138  return (TXERRCNT);
1139 }
1140 
1141 //*********************************************
1142 // Return RX error Count
1143 //*********************************************
1144 
1146 {
1147  return (RXERRCNT);
1148 }
1149 
1150 //*********************************************
1151 // Return 1 if at least 1 TX buffer is empty
1152 //*********************************************
1153 
1155 {
1156  return (!TXB0CONbits.TXREQ || !TXB1CONbits.TXREQ || !TXB2CONbits.TXREQ); //if at least one flag is 0, it returns return 1
1157 }
1158 
1159 //*********************************************
1160 // Return 1 if one or more RX buffer are full
1161 //*********************************************
1162 
1164 {
1165  return (RXB0CONbits.RXFUL || RXB1CONbits.RXFUL);
1166 }
1167 
1168 #endif