WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/PIC/canBase/Source/CAN.c


/*********************************************************************
 *
 *                  CAN module
 *
 *********************************************************************
 * FileName:        $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canBase/Source/CAN.c $
 * Last changed:    $LastChangedDate: 2006-11-14 21:11:28 +0100 (Tue, 14 Nov 2006) $
 * By:              $LastChangedBy: johboh $
 * Revision:        $Revision: 95 $
 ********************************************************************/
 
#include <CANdefs.h>
#include <stackTasks.h>
#include <CAN.h>
 
static void canGetPacket(void);
 
#ifdef USE_CAN
 
 
/*
*   Function: canInit
*
*   Input:  none
*   Output: none
*   Pre-conditions: none
*   Affects: Changes can registers.
*   Depends: none.
*/
void canInit()
{
    CANCON = 0x80; //request config mode
    while ((CANSTAT & 0xE0) != 0x80 ); //wait for config mode request
 
    // BAUD AND TQS
 
    BRGCON1=0;
   
    // Sync_Seq = 2 x TQ = 1
    BRGCON1bits.SJW1=0;
    BRGCON1bits.SJW0=1;
   
    // Setting BRP.
    BRGCON1=BRGCON1|CAN_BRP;
   
    // Maximum PHEG1
    BRGCON2bits.SEG2PHTS = 1;
   
    // Phase_Seg1 = 2 x TQ = 1
    BRGCON2bits.SEG1PH2 = 0;
    BRGCON2bits.SEG1PH1 = 0;
    BRGCON2bits.SEG1PH0 = 1;
   
    // Prop_Seq = 2 x TQ = 1
    BRGCON2bits.PRSEG2 = 0;
    BRGCON2bits.PRSEG1 = 0;
    BRGCON2bits.PRSEG0 = 1;
   
    //  Enableing bus wake-up
    BRGCON3bits.WAKDIS = 0;
   
    // Dont use filter when wakeup
    BRGCON3bits.WAKFIL = 0;
   
    // Phase_Seg2 = 2 x TQ = 1
    BRGCON3bits.SEG2PH2 = 0;
    BRGCON3bits.SEG2PH1 = 0;
    BRGCON3bits.SEG2PH0 = 1;
 
    ECANCON=0;
    ECANCONbits.MDSEL1 = 1; // 0  For mode 1 
    ECANCONbits.MDSEL0 = 0; // 1  For mode 1 
 
 
    // FILTERS AND MASKS
    RXB0CONbits.RXM1=1;
    RXB0CONbits.RXM0=0;
 
 
    // INTERRUPTS
   
    // Diable transmit interrupt
    TXBIE = 0;
 
    //rx any interrupt
    PIR3 = 0;
    PIE3 = 0b00000011;
 
    // High interrupt
    IPR3 =0b00000011;
 
    // Programmable buffers interrupt
    BIE0  = 0xFF;  
 
 
    //loopback mode or not
    #ifdef CAN_LOOPBACK_MODE
        CANCON = 0x40;//request loopback mode
        while ((CANSTAT & 0xE0) != 0x40 );//wait for loopback mode
    #else
        CANCON = 0x00;//request normal mode
        while ((CANSTAT & 0xE0) != 0x00 );//wait for normal mode
    #endif
 
}
 
 
/*
*   Function: canISR
*
*   Input:  none
*   Output: none
*   Pre-conditions: a call to canInit()
*   Affects: interrupt registers and receive data buffers
*   Depends: ..
*/
void canISR()
{
 
 
    if (PIR3bits.RXBnIF || PIR3bits.RXB1IF || PIR3bits.RXB0IF)
    {
        ECANCON=(ECANCON&0b00000)|(0b10000|(CANCON&0x0F));
        if (RXB0CONbits.RXFUL) canGetPacket();
   
 
 
 
 
 
 
 
 
 
 
 
        if (PIR3bits.RXBnIF) {PIR3bits.RXBnIF = 0; return;}
        if (PIR3bits.RXB1IF) {PIR3bits.RXB1IF = 0; return;}
        if (PIR3bits.RXB0IF) {PIR3bits.RXB0IF = 0; return;}
 
    }
}
 
 
/*
*   Function: canGetPacket
*
*   Input:  none
*   Output: none
*   Pre-conditions: a call to canISR and an packet is available and banked to RXB0
*   Affects: Calls canParse() function in main for parsing received packet.
*   Depends: none.
*/
void canGetPacket()
{
        CAN_MESSAGE cm;
 
        //RXB0SIDH 28 27 26 25 24 23 22 21
        //RXB0SIDL 20 19 18 xx xx xx 17 16
        //RXB0EIDH 15 14 13 12 11 10 09 08
        //RXB0EIDL 07 06 05 04 03 02 01 00
 
        //funct xx xx xx xx 28 27 26 25
        //funcc xx xx xx xx xx xx 24 23 22 21 20 19 18 17 16 15 
        //nid   xx xx 14 13 12 11 10 09 
        //sid   xx xx xx xx xx xx xx 08 07 06 05 04 03 02 01 00
 
 
        cm.funct=((RXB0SIDH & 0xF0)>>4);
        cm.funcc=(((WORD)(RXB0SIDH & 0x0F))<<6)+(((WORD)(RXB0SIDL & 0xE0))>>2)+(((WORD)(RXB0SIDL & 0x03))<<1)+(((WORD)(RXB0EIDH & 0x80))>>7);
        cm.nid=((RXB0EIDH & 0x7E)>>1);
        cm.sid=(((WORD)(RXB0EIDH & 0x01))<<8)+RXB0EIDL;
 
 
        // Data length
        cm.data_length=(RXB0DLCbits.DLC3<<3)+(RXB0DLCbits.DLC2<<2)+(RXB0DLCbits.DLC1<<1)+RXB0DLCbits.DLC0;
 
        // Data one bye one, for speed
        cm.data[0]=RXB0D0;  cm.data[1]=RXB0D1;
        cm.data[2]=RXB0D2;  cm.data[3]=RXB0D3;
        cm.data[4]=RXB0D4;  cm.data[5]=RXB0D5;
        cm.data[6]=RXB0D6;  cm.data[7]=RXB0D7;
 
        // Clear ful status
        RXB0CONbits.RXFUL=0;
 
        //Call main parser
        canParse(cm);
}
 
 
/*
*   Function: canSendMessage
*
*   Input:  CAN_MESSAGE to send
*   Output: True if packet scheduled sucess, false otherwise.
*   Pre-conditions: canInit
*   Affects: ..
*   Depends: ..
*/
BOOL canSendMessage(CAN_MESSAGE cm,CAN_PRIORITY prio)
{
   
    if ( TXB0CONbits.TXREQ == 0 )  { ECANCON=(ECANCON&0b00000)|0b00011; }
    if ( TXB1CONbits.TXREQ == 0 )  { ECANCON=(ECANCON&0b00000)|0b00100; }
    if ( TXB2CONbits.TXREQ == 0 )  { ECANCON=(ECANCON&0b00000)|0b00101; }
    // None of the transmit buffers were empty. 
    else { return FALSE;}
 
    if (prio<0 || prio>3) prio = 0;
 
 
        //RXB0SIDH 28 27 26 25 24 23 22 21
        //RXB0SIDL 20 19 18 xx xx xx 17 16
        //RXB0EIDH 15 14 13 12 11 10 09 08
        //RXB0EIDL 07 06 05 04 03 02 01 00
 
        //funct xx xx xx xx 28 27 26 25
        //funcc xx xx xx xx xx xx 24 23 22 21 20 19 18 17 16 15 
        //nid   xx xx 14 13 12 11 10 09 
        //sid   xx xx xx xx xx xx xx 08 07 06 05 04 03 02 01 00
 
        RXB0SIDH = (BYTE)((cm.funct & 0x0F)<<4)+(BYTE)((cm.funcc & 0x03C0)>>6);
        RXB0SIDL = (BYTE)((cm.funcc & 0x003F)<<2)+(BYTE)((cm.funcc & 0x0006)>>1);
        RXB0EIDH = (BYTE)((cm.funcc & 0x0001)<<7)+(BYTE)((cm.nid & 0x3F)<<1)+(BYTE)((cm.sid & 0x0100)>>8);
        RXB0EIDL = (BYTE)((cm.sid & 0x00FF));
 
        // Data length
        RXB0DLC = 0;
        if (cm.data_length>8) RXB0DLC=8; else RXB0DLC=cm.data_length;
       
 
        // NOT Remote request
        _asm
            bcf RXB0DLC, 6, 0
        _endasm
       
 
        // Data one bye one, for speed
        RXB0D0=cm.data[0];  RXB0D1=cm.data[1];
        RXB0D2=cm.data[2];  RXB0D3=cm.data[3];
        RXB0D4=cm.data[4];  RXB0D5=cm.data[5];
        RXB0D6=cm.data[6];  RXB0D7=cm.data[7];
 
        // set extended
        RXB0SIDLbits.EXID=1;
 
        // Priority
        RXB0CON = (RXB0CON & 0b11111100) | prio;
 
        // mark as redy to transmit
        _asm
            bsf RXB0CON, 3, 0
        _endasm
 
        return TRUE;
 
}
 
 
 
#endif //USE_CAN
 

Rev 87	Rev 95
1	/*********************************************************************	1	/*********************************************************************
2	*	2	*
3	* CAN module	3	* CAN module
4	*	4	*
5	*********************************************************************	5	*********************************************************************
6	* FileName: $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canBase/Source/CAN.c $	6	* FileName: $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canBase/Source/CAN.c $
7	* Last changed: $LastChangedDate: 2006-11-14 11:20:48 +0100 (Tue, 14 Nov 2006) $	7	* Last changed: $LastChangedDate: 2006-11-14 21:11:28 +0100 (Tue, 14 Nov 2006) $
8	* By: $LastChangedBy: johboh $	8	* By: $LastChangedBy: johboh $
9	* Revision: $Revision: 87 $	9	* Revision: $Revision: 95 $
10	********************************************************************/	10	********************************************************************/
11		11
12	#include <CANdefs.h>	12	#include <CANdefs.h>
13	#include <stackTasks.h>	13	#include <stackTasks.h>
14	#include <CAN.h>	14	#include <CAN.h>
15		15
16	static void canGetPacket(void);	16	static void canGetPacket(void);
17		17
18	#ifdef USE_CAN	18	#ifdef USE_CAN
19		19
20		20
21	/*	21	/*
22	* Function: canInit	22	* Function: canInit
23	*	23	*
24	* Input: none	24	* Input: none
25	* Output: none	25	* Output: none
26	* Pre-conditions: none	26	* Pre-conditions: none
27	* Affects: Changes can registers.	27	* Affects: Changes can registers.
28	* Depends: none.	28	* Depends: none.
29	*/	29	*/
30	void canInit()	30	void canInit()
31	{	31	{
32	CANCON = 0x80; //request config mode	32	CANCON = 0x80; //request config mode
33	while ((CANSTAT & 0xE0) != 0x80 ); //wait for config mode request	33	while ((CANSTAT & 0xE0) != 0x80 ); //wait for config mode request
34		34
35	// BAUD AND TQS	35	// BAUD AND TQS
36		36
37	BRGCON1=0;	37	BRGCON1=0;
38		38
39	// Sync_Seq = 2 x TQ = 1	39	// Sync_Seq = 2 x TQ = 1
40	BRGCON1bits.SJW1=0;	40	BRGCON1bits.SJW1=0;
41	BRGCON1bits.SJW0=1;	41	BRGCON1bits.SJW0=1;
42		42
43	// Setting BRP.	43	// Setting BRP.
44	BRGCON1=BRGCON1\|CAN_BRP;	44	BRGCON1=BRGCON1\|CAN_BRP;
45		45
46	// Maximum PHEG1	46	// Maximum PHEG1
47	BRGCON2bits.SEG2PHTS = 1;	47	BRGCON2bits.SEG2PHTS = 1;
48		48
49	// Phase_Seg1 = 2 x TQ = 1	49	// Phase_Seg1 = 2 x TQ = 1
50	BRGCON2bits.SEG1PH2 = 0;	50	BRGCON2bits.SEG1PH2 = 0;
51	BRGCON2bits.SEG1PH1 = 0;	51	BRGCON2bits.SEG1PH1 = 0;
52	BRGCON2bits.SEG1PH0 = 1;	52	BRGCON2bits.SEG1PH0 = 1;
53		53
54	// Prop_Seq = 2 x TQ = 1	54	// Prop_Seq = 2 x TQ = 1
55	BRGCON2bits.PRSEG2 = 0;	55	BRGCON2bits.PRSEG2 = 0;
56	BRGCON2bits.PRSEG1 = 0;	56	BRGCON2bits.PRSEG1 = 0;
57	BRGCON2bits.PRSEG0 = 1;	57	BRGCON2bits.PRSEG0 = 1;
58		58
59	// Enableing bus wake-up	59	// Enableing bus wake-up
60	BRGCON3bits.WAKDIS = 0;	60	BRGCON3bits.WAKDIS = 0;
61		61
62	// Dont use filter when wakeup	62	// Dont use filter when wakeup
63	BRGCON3bits.WAKFIL = 0;	63	BRGCON3bits.WAKFIL = 0;
64		64
65	// Phase_Seg2 = 2 x TQ = 1	65	// Phase_Seg2 = 2 x TQ = 1
66	BRGCON3bits.SEG2PH2 = 0;	66	BRGCON3bits.SEG2PH2 = 0;
67	BRGCON3bits.SEG2PH1 = 0;	67	BRGCON3bits.SEG2PH1 = 0;
68	BRGCON3bits.SEG2PH0 = 1;	68	BRGCON3bits.SEG2PH0 = 1;
69		69
70	ECANCON=0;	70	ECANCON=0;
71	ECANCONbits.MDSEL1 = 0;	71	ECANCONbits.MDSEL1 = 1; // 0 For mode 1
72	ECANCONbits.MDSEL0 = 1;	72	ECANCONbits.MDSEL0 = 0; // 1 For mode 1
73		73
74		74
75	// FILTERS AND MASKS	75	// FILTERS AND MASKS
76	RXB0CONbits.RXM1=1;	76	RXB0CONbits.RXM1=1;
77	RXB0CONbits.RXM0=0;	77	RXB0CONbits.RXM0=0;
78		78
79		79
80	// INTERRUPTS	80	// INTERRUPTS
81		81
82	// Diable transmit interrupt	82	// Diable transmit interrupt
83	TXBIE = 0;	83	TXBIE = 0;
84		84
85	//rx any interrupt	85	//rx any interrupt
86	PIR3 = 0;	86	PIR3 = 0;
87	PIE3 = 0b00000011;	87	PIE3 = 0b00000011;
88		88
89	// High interrupt	89	// High interrupt
90	IPR3 =0b00000011;	90	IPR3 =0b00000011;
91		91
92	// Programmable buffers interrupt	92	// Programmable buffers interrupt
93	BIE0 = 0xFF;	93	BIE0 = 0xFF;
94		94
95		95
96	//loopback mode or not	96	//loopback mode or not
97	#ifdef CAN_LOOPBACK_MODE	97	#ifdef CAN_LOOPBACK_MODE
98	CANCON = 0x40;//request loopback mode	98	CANCON = 0x40;//request loopback mode
99	while ((CANSTAT & 0xE0) != 0x40 );//wait for loopback mode	99	while ((CANSTAT & 0xE0) != 0x40 );//wait for loopback mode
100	#else	100	#else
101	CANCON = 0x00;//request normal mode	101	CANCON = 0x00;//request normal mode
102	while ((CANSTAT & 0xE0) != 0x00 );//wait for normal mode	102	while ((CANSTAT & 0xE0) != 0x00 );//wait for normal mode
103	#endif	103	#endif
104		104
105	}	105	}
106		106
107		107
108	/*	108	/*
109	* Function: canISR	109	* Function: canISR
110	*	110	*
111	* Input: none	111	* Input: none
112	* Output: none	112	* Output: none
113	* Pre-conditions: a call to canInit()	113	* Pre-conditions: a call to canInit()
114	* Affects: interrupt registers and receive data buffers	114	* Affects: interrupt registers and receive data buffers
115	* Depends: ..	115	* Depends: ..
116	*/	116	*/
117	void canISR()	117	void canISR()
118	{	118	{
119		-
120		-
121	if (PIR3bits.RXBnIF \|\| PIR3bits.RXB1IF \|\| PIR3bits.RXB0IF)	119	if (PIR3bits.RXBnIF \|\| PIR3bits.RXB1IF \|\| PIR3bits.RXB0IF)
122	{	120	{
-		121	ECANCON=(ECANCON&0b00000)\|(0b10000\|(CANCON&0x0F));
-		122	if (RXB0CONbits.RXFUL) canGetPacket();
123		123
124		-
125	// Get which buffer that is ful.	-
126	if (RXB0CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10000; canGetPacket(); }	-
127	else if (RXB1CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10001; canGetPacket(); }	-
128	else if (B0CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10010; canGetPacket(); }	-
129	else if (B1CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10011; canGetPacket(); }	-
130	else if (B2CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10100; canGetPacket(); }	-
131	else if (B3CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10101; canGetPacket(); }	-
132	else if (B4CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10110; canGetPacket(); }	-
133	else if (B5CONbits.RXFUL) { ECANCON=(ECANCON&0b00000)\|0b10111; canGetPacket(); }	-
134		-
135	if (PIR3bits.RXBnIF) {PIR3bits.RXBnIF = 0;}	124	if (PIR3bits.RXBnIF) {PIR3bits.RXBnIF = 0; return;}
136	if (PIR3bits.RXB1IF) {PIR3bits.RXB1IF = 0;}	125	if (PIR3bits.RXB1IF) {PIR3bits.RXB1IF = 0; return;}
137	if (PIR3bits.RXB0IF) {PIR3bits.RXB0IF = 0;}	126	if (PIR3bits.RXB0IF) {PIR3bits.RXB0IF = 0; return;}
138		-
139	}	127	}
140	}	128	}
141		129
142		130
143	/*	131	/*
144	* Function: canGetPacket	132	* Function: canGetPacket
145	*	133	*
146	* Input: none	134	* Input: none
147	* Output: none	135	* Output: none
148	* Pre-conditions: a call to canISR and an packet is available and banked to RXB0	136	* Pre-conditions: a call to canISR and an packet is available and banked to RXB0
149	* Affects: Calls canParse() function in main for parsing received packet.	137	* Affects: Calls canParse() function in main for parsing received packet.
150	* Depends: none.	138	* Depends: none.
151	*/	139	*/
152	void canGetPacket()	140	void canGetPacket()
153	{	141	{
154	CAN_MESSAGE cm;	142	CAN_MESSAGE cm;
155		143
156	//RXB0SIDH 28 27 26 25 24 23 22 21	144	//RXB0SIDH 28 27 26 25 24 23 22 21
157	//RXB0SIDL 20 19 18 xx xx xx 17 16	145	//RXB0SIDL 20 19 18 xx xx xx 17 16
158	//RXB0EIDH 15 14 13 12 11 10 09 08	146	//RXB0EIDH 15 14 13 12 11 10 09 08
159	//RXB0EIDL 07 06 05 04 03 02 01 00	147	//RXB0EIDL 07 06 05 04 03 02 01 00
160		148
161	//funct xx xx xx xx 28 27 26 25	149	//funct xx xx xx xx 28 27 26 25
162	//funcc xx xx xx xx xx xx 24 23 22 21 20 19 18 17 16 15	150	//funcc xx xx xx xx xx xx 24 23 22 21 20 19 18 17 16 15
163	//nid xx xx 14 13 12 11 10 09	151	//nid xx xx 14 13 12 11 10 09
164	//sid xx xx xx xx xx xx xx 08 07 06 05 04 03 02 01 00	152	//sid xx xx xx xx xx xx xx 08 07 06 05 04 03 02 01 00
165		153
166		154
167	cm.funct=((RXB0SIDH & 0xF0)>>4);	155	cm.funct=((RXB0SIDH & 0xF0)>>4);
168	cm.funcc=(((WORD)(RXB0SIDH & 0x0F))<<6)+(((WORD)(RXB0SIDL & 0xE0))>>2)+(((WORD)(RXB0SIDL & 0x03))<<1)+(((WORD)(RXB0EIDH & 0x80))>>7);	156	cm.funcc=(((WORD)(RXB0SIDH & 0x0F))<<6)+(((WORD)(RXB0SIDL & 0xE0))>>2)+(((WORD)(RXB0SIDL & 0x03))<<1)+(((WORD)(RXB0EIDH & 0x80))>>7);
169	cm.nid=((RXB0EIDH & 0x7E)>>1);	157	cm.nid=((RXB0EIDH & 0x7E)>>1);
170	cm.sid=(((WORD)(RXB0EIDH & 0x01))<<8)+RXB0EIDL;	158	cm.sid=(((WORD)(RXB0EIDH & 0x01))<<8)+RXB0EIDL;
171		159
172		160
173	// Data length	161	// Data length
174	cm.data_length=(RXB0DLCbits.DLC3<<3)+(RXB0DLCbits.DLC2<<2)+(RXB0DLCbits.DLC1<<1)+RXB0DLCbits.DLC0;	162	cm.data_length=(RXB0DLCbits.DLC3<<3)+(RXB0DLCbits.DLC2<<2)+(RXB0DLCbits.DLC1<<1)+RXB0DLCbits.DLC0;
175		163
176	// Data one bye one, for speed	164	// Data one bye one, for speed
177	cm.data[0]=RXB0D0; cm.data[1]=RXB0D1;	165	cm.data[0]=RXB0D0; cm.data[1]=RXB0D1;
178	cm.data[2]=RXB0D2; cm.data[3]=RXB0D3;	166	cm.data[2]=RXB0D2; cm.data[3]=RXB0D3;
179	cm.data[4]=RXB0D4; cm.data[5]=RXB0D5;	167	cm.data[4]=RXB0D4; cm.data[5]=RXB0D5;
180	cm.data[6]=RXB0D6; cm.data[7]=RXB0D7;	168	cm.data[6]=RXB0D6; cm.data[7]=RXB0D7;
181		169
182	// Clear ful status	170	// Clear ful status
183	RXB0CONbits.RXFUL=0;	171	RXB0CONbits.RXFUL=0;
184		172
185	//Call main parser	173	//Call main parser
186	canParse(cm);	174	canParse(cm);
187	}	175	}
188		176
189		177
190	/*	178	/*
191	* Function: canSendMessage	179	* Function: canSendMessage
192	*	180	*
193	* Input: CAN_MESSAGE to send	181	* Input: CAN_MESSAGE to send
194	* Output: True if packet scheduled sucess, false otherwise.	182	* Output: True if packet scheduled sucess, false otherwise.
195	* Pre-conditions: canInit	183	* Pre-conditions: canInit
196	* Affects: ..	184	* Affects: ..
197	* Depends: ..	185	* Depends: ..
198	*/	186	*/
199	BOOL canSendMessage(CAN_MESSAGE cm,CAN_PRIORITY prio)	187	BOOL canSendMessage(CAN_MESSAGE cm,CAN_PRIORITY prio)
200	{	188	{
201		189
202	if ( TXB0CONbits.TXREQ == 0 ) { ECANCON=(ECANCON&0b00000)\|0b00011; }	190	if ( TXB0CONbits.TXREQ == 0 ) { ECANCON=(ECANCON&0b00000)\|0b00011; }
203	if ( TXB1CONbits.TXREQ == 0 ) { ECANCON=(ECANCON&0b00000)\|0b00100; }	191	if ( TXB1CONbits.TXREQ == 0 ) { ECANCON=(ECANCON&0b00000)\|0b00100; }
204	if ( TXB2CONbits.TXREQ == 0 ) { ECANCON=(ECANCON&0b00000)\|0b00101; }	192	if ( TXB2CONbits.TXREQ == 0 ) { ECANCON=(ECANCON&0b00000)\|0b00101; }
205	// None of the transmit buffers were empty.	193	// None of the transmit buffers were empty.
206	else { return FALSE;}	194	else { return FALSE;}
207		195
208	if (prio<0 \|\| prio>3) prio = 0;	196	if (prio<0 \|\| prio>3) prio = 0;
209		197
210		198
211	//RXB0SIDH 28 27 26 25 24 23 22 21	199	//RXB0SIDH 28 27 26 25 24 23 22 21
212	//RXB0SIDL 20 19 18 xx xx xx 17 16	200	//RXB0SIDL 20 19 18 xx xx xx 17 16
213	//RXB0EIDH 15 14 13 12 11 10 09 08	201	//RXB0EIDH 15 14 13 12 11 10 09 08
214	//RXB0EIDL 07 06 05 04 03 02 01 00	202	//RXB0EIDL 07 06 05 04 03 02 01 00
215		203
216	//funct xx xx xx xx 28 27 26 25	204	//funct xx xx xx xx 28 27 26 25
217	//funcc xx xx xx xx xx xx 24 23 22 21 20 19 18 17 16 15	205	//funcc xx xx xx xx xx xx 24 23 22 21 20 19 18 17 16 15
218	//nid xx xx 14 13 12 11 10 09	206	//nid xx xx 14 13 12 11 10 09
219	//sid xx xx xx xx xx xx xx 08 07 06 05 04 03 02 01 00	207	//sid xx xx xx xx xx xx xx 08 07 06 05 04 03 02 01 00
220		208
221	RXB0SIDH = (BYTE)((cm.funct & 0x0F)<<4)+(BYTE)((cm.funcc & 0x03C0)>>6);	209	RXB0SIDH = (BYTE)((cm.funct & 0x0F)<<4)+(BYTE)((cm.funcc & 0x03C0)>>6);
222	RXB0SIDL = (BYTE)((cm.funcc & 0x003F)<<2)+(BYTE)((cm.funcc & 0x0006)>>1);	210	RXB0SIDL = (BYTE)((cm.funcc & 0x003F)<<2)+(BYTE)((cm.funcc & 0x0006)>>1);
223	RXB0EIDH = (BYTE)((cm.funcc & 0x0001)<<7)+(BYTE)((cm.nid & 0x3F)<<1)+(BYTE)((cm.sid & 0x0100)>>8);	211	RXB0EIDH = (BYTE)((cm.funcc & 0x0001)<<7)+(BYTE)((cm.nid & 0x3F)<<1)+(BYTE)((cm.sid & 0x0100)>>8);
224	RXB0EIDL = (BYTE)((cm.sid & 0x00FF));	212	RXB0EIDL = (BYTE)((cm.sid & 0x00FF));
225		213
226	// Data length	214	// Data length
227	RXB0DLC = 0;	215	RXB0DLC = 0;
228	if (cm.data_length>8) RXB0DLC=8; else RXB0DLC=cm.data_length;	216	if (cm.data_length>8) RXB0DLC=8; else RXB0DLC=cm.data_length;
229		217
230		218
231	// NOT Remote request	219	// NOT Remote request
232	_asm	220	_asm
233	bcf RXB0DLC, 6, 0	221	bcf RXB0DLC, 6, 0
234	_endasm	222	_endasm
235		223
236		224
237	// Data one bye one, for speed	225	// Data one bye one, for speed
238	RXB0D0=cm.data[0]; RXB0D1=cm.data[1];	226	RXB0D0=cm.data[0]; RXB0D1=cm.data[1];
239	RXB0D2=cm.data[2]; RXB0D3=cm.data[3];	227	RXB0D2=cm.data[2]; RXB0D3=cm.data[3];
240	RXB0D4=cm.data[4]; RXB0D5=cm.data[5];	228	RXB0D4=cm.data[4]; RXB0D5=cm.data[5];
241	RXB0D6=cm.data[6]; RXB0D7=cm.data[7];	229	RXB0D6=cm.data[6]; RXB0D7=cm.data[7];
242		230
243	// set extended	231	// set extended
244	RXB0SIDLbits.EXID=1;	232	RXB0SIDLbits.EXID=1;
245		233
246	// Priority	234	// Priority
247	RXB0CON = (RXB0CON & 0b11111100) \| prio;	235	RXB0CON = (RXB0CON & 0b11111100) \| prio;
248		236
249	// mark as redy to transmit	237	// mark as redy to transmit
250	_asm	238	_asm
251	bsf RXB0CON, 3, 0	239	bsf RXB0CON, 3, 0
252	_endasm	240	_endasm
253		241
254	return TRUE;	242	return TRUE;
255		243
256	}	244	}
257		245
258		246
259		247
260	#endif //USE_CAN	248	#endif //USE_CAN
261		249

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/PIC/canBase/Source/CAN.c @ 95 – Rev 87 → 95