WebSVN – HomeAutomation – Diff – /EmbeddedSoftware/PIC/canNode/Source/Main.c


/*********************************************************************
 *
 *                  Main application
 *
 *********************************************************************
 * FileName:        Main.c
 *
 * Author               Date    Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Johan Böhlin     21-10-06    Original        (Rev 1.0)
 ********************************************************************/
 
#include "../Include/compiler.h"
#include "../Include/stackTasks.h"
#include "../Include/Tick.h"
 
#ifdef USE_CAN
    #include "../Include/CAN.h"
#endif
 
#ifdef USE_UART
    #include "../Include/uart.h"
#endif
 
 
 
static void mainInit(void);
 
void main()
{
    static TICK t = 0;
 
    // Inits
 
    mainInit();
 
    #ifdef USE_CAN
        canInit();
    #endif
 
    #ifdef USE_UART
        uartInit();
        uartPutrs("BOOT OK!");
    #endif
 
    tickInit();
 
    while(1)
    {
        if ((tickGet()-t)>=10*TICK_SECOND)
        {
            CAN_MESSAGE cm;
 
            t = tickGet();
       
            // Send heartbeat
            cm.ident=0x00000707;
            cm.extended=FALSE;
            cm.data_length=1;
            cm.data[0]='H';
 
            while(!canSendMessage(cm));
 
           
        }
    }
}
 
 
#pragma interruptlow HighISR
void HighISR(void)
{
    #ifdef USE_CAN
        canISR();
    #endif
 
    #ifdef USE_UART
        uartISR();
    #endif
 
    tickUpdate();
}
#pragma code highVector=0x08
void HighVector (void)
{
    _asm goto HighISR _endasm
}
#pragma code // Return to default code section
 
 
 
#pragma interruptlow LowISR
void LowISR(void)
{
 
}
#pragma code lowVector=0x18
void LowVector (void)
{
    _asm goto LowISR _endasm
}
#pragma code // Return to default code section
 
 
/*
*   Function: mainInit
*
*   Input:  none
*   Output: none
*   Pre-conditions: none
*   Affects: Se code
*   Depends: none.
*/
void mainInit()
{
    LED0_TRIS=0;   
 
    // Enable internal PORTB pull-ups
    INTCON2bits.RBPU = 0;
   
    // Enable Interrupts
    INTCONbits.GIEH = 1;
    INTCONbits.GIEL = 1;
 
}
 
/*
*   Function: canParse
*
*   Input:  Received can message
*   Output: none
*   Pre-conditions: canInit and received packet.
*   Affects: Sensors/actuators/etc. See code.
*   Depends: none.
*/
#ifdef USE_CAN
void canParse(CAN_MESSAGE cm)
{
    int i=0;
 
    if (cm.extended==TRUE)
    {
        uartPutc((BYTE)(cm.ident>>24));
        uartPutc((BYTE)(cm.ident>>16));
    }
    uartPutc((BYTE)(cm.ident>>8));
    uartPutc((BYTE)(cm.ident));
 
    for(i=0;i<cm.data_length && i<8;i++)
        uartPutc(cm.data[cm.data_length-i-1]);
 
}
#endif
 
 
/*
*   Function: uartParse
*
*   Input:  Received uart message
*   Output: none
*   Pre-conditions: uartInit and received byte.
*   Affects: Sensors/actuators/etc. See code.
*   Depends: none.
*/
#ifdef USE_UART
void uartParse(BYTE c)
{
 
 
    if (c=='1')
    {
        CAN_MESSAGE cm;
        cm.ident=0x00000123;
        cm.extended=FALSE;
        cm.data_length=4;
        cm.data[0]='!';
        cm.data[1]='j';
        cm.data[2]='e';
        cm.data[3]='H';
 
        while(!canSendMessage(cm));
    }
 
    if (c=='2')
    {
        CAN_MESSAGE cm;
        cm.ident=0x0ABCDEF0;
        cm.extended=TRUE;
        cm.data_length=8;
        cm.data[0]='!';
        cm.data[1]='g';
        cm.data[2]='a';
        cm.data[3]='d';
        cm.data[4]=' ';
        cm.data[5]='d';
        cm.data[6]='o';
        cm.data[7]='G';
 
 
        while(!canSendMessage(cm));
    }
 
    if (c=='d')
    {
        uartPutc('D');
    }
 
    if (c=='D')
    {
        uartPutrs("Debug? Debug!");
    }
 
    if (c=='3')
    {
        uartPutc(RXB0CON);
        uartPutc(RXB1CON);
        uartPutc(123);
        uartPutc(B0CON);
        uartPutc(B1CON);
        uartPutc(B2CON);
        uartPutc(123); 
        uartPutc(B3CON);   
        uartPutc(B4CON);   
        uartPutc(B5CON);
        uartPutc(123); 
        uartPutc(CANSTAT); 
        uartPutc(COMSTAT); 
        uartPutc(ECANCON);
        uartPutc(123); 
        uartPutc(TXB0CON); 
        uartPutc(TXB1CON); 
        uartPutc(TXB2CON); 
        uartPutc(123);
        uartPutc(PIR3);
        uartPutc(PIE3);
        uartPutc(123);
        uartPutc(BRGCON1);
        uartPutc(BRGCON2);
        uartPutc(BRGCON3);
        uartPutc(123);
        uartPutc(RXFCON0);
        uartPutc(RXFCON1);
        uartPutc(123);
        uartPutc(RXFBCON0);
        uartPutc(RXFBCON1);
        uartPutc(RXFBCON2);
        uartPutc(RXFBCON3);
        uartPutc(RXFBCON4);
        uartPutc(RXFBCON5);
        uartPutc(RXFBCON6);
        uartPutc(RXFBCON7);
        uartPutc(123);
        uartPutc(TXBIE);
        uartPutc(BIE0);
    }
 
}
#endif
 

Rev 25	Rev 26
1	/*********************************************************************	1	/*********************************************************************
2	*	2	*
3	* Main application	3	* Main application
4	*	4	*
5	*********************************************************************	5	*********************************************************************
6	* FileName: Main.c	6	* FileName: Main.c
7	*	7	*
8	* Author Date Comment	8	* Author Date Comment
9	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	9	*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10	* Johan Böhlin 21-10-06 Original (Rev 1.0)	10	* Johan Böhlin 21-10-06 Original (Rev 1.0)
11	********************************************************************/	11	********************************************************************/
12		12
13	#include "../Include/compiler.h"	13	#include "../Include/compiler.h"
14	#include "../Include/stackTasks.h"	14	#include "../Include/stackTasks.h"
15	#include "../Include/Tick.h"	15	#include "../Include/Tick.h"
16		16
17	#ifdef USE_CAN	17	#ifdef USE_CAN
18	#include "../Include/CAN.h"	18	#include "../Include/CAN.h"
19	#endif	19	#endif
20		20
21	#ifdef USE_UART	21	#ifdef USE_UART
22	#include "../Include/uart.h"	22	#include "../Include/uart.h"
23	#endif	23	#endif
24		24
25		25
26		26
27	static void mainInit(void);	27	static void mainInit(void);
28		28
29	void main()	29	void main()
30	{	30	{
31	static TICK t = 0;	31	static TICK t = 0;
32		32
33	// Inits	33	// Inits
34		34
35	mainInit();	35	mainInit();
36		36
37	#ifdef USE_CAN	37	#ifdef USE_CAN
38	canInit();	38	canInit();
39	#endif	39	#endif
40		40
41	#ifdef USE_UART	41	#ifdef USE_UART
42	uartInit();	42	uartInit();
43	uartPutrs("BOOT OK!");	43	uartPutrs("BOOT OK!");
44	#endif	44	#endif
45		45
46	tickInit();	46	tickInit();
47		47
48	while(1)	48	while(1)
49	{	49	{
50	if ((tickGet()-t)>=10*TICK_SECOND)	50	if ((tickGet()-t)>=10*TICK_SECOND)
51	{	51	{
52	CAN_MESSAGE cm;	52	CAN_MESSAGE cm;
53		53
54	t = tickGet();	54	t = tickGet();
55		55
56	// Send heartbeat	56	// Send heartbeat
57	cm.ident=0x00000707;	57	cm.ident=0x00000707;
58	cm.extended=FALSE;	58	cm.extended=FALSE;
59	cm.data_length=1;	59	cm.data_length=1;
60	cm.data[0]='H';	60	cm.data[0]='H';
61		61
62	while(!canSendMessage(cm));	62	while(!canSendMessage(cm));
63		63
64		64
65	}	65	}
66	}	66	}
67	}	67	}
68		68
69		69
70	#pragma interruptlow HighISR	70	#pragma interruptlow HighISR
71	void HighISR(void)	71	void HighISR(void)
72	{	72	{
73	#ifdef USE_CAN	73	#ifdef USE_CAN
74	canISR();	74	canISR();
75	#endif	75	#endif
76		76
77	#ifdef USE_UART	77	#ifdef USE_UART
78	uartISR();	78	uartISR();
79	#endif	79	#endif
80		80
81	tickUpdate();	81	tickUpdate();
82	}	82	}
83	#pragma code highVector=0x08	83	#pragma code highVector=0x08
84	void HighVector (void)	84	void HighVector (void)
85	{	85	{
86	_asm goto HighISR _endasm	86	_asm goto HighISR _endasm
87	}	87	}
88	#pragma code // Return to default code section	88	#pragma code // Return to default code section
89		89
90		90
91		91
92	#pragma interruptlow LowISR	92	#pragma interruptlow LowISR
93	void LowISR(void)	93	void LowISR(void)
94	{	94	{
95		95
96	}	96	}
97	#pragma code lowVector=0x18	97	#pragma code lowVector=0x18
98	void LowVector (void)	98	void LowVector (void)
99	{	99	{
100	_asm goto LowISR _endasm	100	_asm goto LowISR _endasm
101	}	101	}
102	#pragma code // Return to default code section	102	#pragma code // Return to default code section
103		103
104		104
105	/*	105	/*
106	* Function: mainInit	106	* Function: mainInit
107	*	107	*
108	* Input: none	108	* Input: none
109	* Output: none	109	* Output: none
110	* Pre-conditions: none	110	* Pre-conditions: none
111	* Affects: Se code	111	* Affects: Se code
112	* Depends: none.	112	* Depends: none.
113	*/	113	*/
114	void mainInit()	114	void mainInit()
115	{	115	{
116	LED0_TRIS=0;	116	LED0_TRIS=0;
117		117
118	// Enable internal PORTB pull-ups	118	// Enable internal PORTB pull-ups
119	INTCON2bits.RBPU = 0;	119	INTCON2bits.RBPU = 0;
120		120
121	// Enable Interrupts	121	// Enable Interrupts
122	INTCONbits.GIEH = 1;	122	INTCONbits.GIEH = 1;
123	INTCONbits.GIEL = 1;	123	INTCONbits.GIEL = 1;
124		124
125	}	125	}
126		126
127	/*	127	/*
128	* Function: canParse	128	* Function: canParse
129	*	129	*
130	* Input: Received can message	130	* Input: Received can message
131	* Output: none	131	* Output: none
132	* Pre-conditions: canInit and received packet.	132	* Pre-conditions: canInit and received packet.
133	* Affects: Sensors/actuators/etc. See code.	133	* Affects: Sensors/actuators/etc. See code.
134	* Depends: none.	134	* Depends: none.
135	*/	135	*/
136	#ifdef USE_CAN	136	#ifdef USE_CAN
137	void canParse(CAN_MESSAGE cm)	137	void canParse(CAN_MESSAGE cm)
138	{	138	{
139	int i=0;	139	int i=0;
140		140
141	if (cm.extended==TRUE)	141	if (cm.extended==TRUE)
142	{	142	{
143	uartPutc((BYTE)(cm.ident>>24));	143	uartPutc((BYTE)(cm.ident>>24));
144	uartPutc((BYTE)(cm.ident>>16));	144	uartPutc((BYTE)(cm.ident>>16));
145	}	145	}
146	uartPutc((BYTE)(cm.ident>>8));	146	uartPutc((BYTE)(cm.ident>>8));
147	uartPutc((BYTE)(cm.ident));	147	uartPutc((BYTE)(cm.ident));
148		148
149	for(i=0;i<cm.data_length && i<8;i++)	149	for(i=0;i<cm.data_length && i<8;i++)
150	uartPutc(cm.data[cm.data_length-i-1]);	150	uartPutc(cm.data[cm.data_length-i-1]);
151		151
152	}	152	}
153	#endif	153	#endif
154		154
155		155
156	/*	156	/*
157	* Function: uartParse	157	* Function: uartParse
158	*	158	*
159	* Input: Received uart message	159	* Input: Received uart message
160	* Output: none	160	* Output: none
161	* Pre-conditions: uartInit and received byte.	161	* Pre-conditions: uartInit and received byte.
162	* Affects: Sensors/actuators/etc. See code.	162	* Affects: Sensors/actuators/etc. See code.
163	* Depends: none.	163	* Depends: none.
164	*/	164	*/
165	#ifdef USE_UART	165	#ifdef USE_UART
166	void uartParse(BYTE c)	166	void uartParse(BYTE c)
167	{	167	{
168		168
169		169
170	if (c=='1')	170	if (c=='1')
171	{	171	{
172	CAN_MESSAGE cm;	172	CAN_MESSAGE cm;
173	cm.ident=~~0x1FFF07FF~~;	173	cm.ident=0x00000123;
174	cm.extended=~~TRUE~~;	174	cm.extended=FALSE;
175	cm.data_length=4;	175	cm.data_length=4;
176	cm.data[0]=~~'a'~~;	176	cm.data[0]='!';
-		177	cm.data[1]='j';
-		178	cm.data[2]='e';
-		179	cm.data[3]='H';
-		180
-		181	while(!canSendMessage(cm));
-		182	}
-		183
-		184	if (c=='2')
-		185	{
-		186	CAN_MESSAGE cm;
-		187	cm.ident=0x0ABCDEF0;
-		188	cm.extended=TRUE;
-		189	cm.data_length=8;
-		190	cm.data[0]='!';
177	cm.data[1]=~~'b'~~;	191	cm.data[1]='g';
178	cm.data[2]=~~'c'~~;	192	cm.data[2]='a';
179	cm.data[3]='d';	193	cm.data[3]='d';
-		194	cm.data[4]=' ';
-		195	cm.data[5]='d';
-		196	cm.data[6]='o';
-		197	cm.data[7]='G';
-		198
180		199
181	while(!canSendMessage(cm));	200	while(!canSendMessage(cm));
182	}	201	}
183		202
184	if (c=='d')	203	if (c=='d')
185	{	204	{
186	uartPutc('D');	205	uartPutc('D');
187	}	206	}
188		207
189	if (c=='D')	208	if (c=='D')
190	{	209	{
191	uartPutrs("Debug? Debug!");	210	uartPutrs("Debug? Debug!");
192	}	211	}
193		212
194	if (c==~~'2'~~)	213	if (c=='3')
195	{	214	{
196	uartPutc(RXB0CON);	215	uartPutc(RXB0CON);
197	uartPutc(RXB1CON);	216	uartPutc(RXB1CON);
198	uartPutc(123);	217	uartPutc(123);
199	uartPutc(B0CON);	218	uartPutc(B0CON);
200	uartPutc(B1CON);	219	uartPutc(B1CON);
201	uartPutc(B2CON);	220	uartPutc(B2CON);
202	uartPutc(123);	221	uartPutc(123);
203	uartPutc(B3CON);	222	uartPutc(B3CON);
204	uartPutc(B4CON);	223	uartPutc(B4CON);
205	uartPutc(B5CON);	224	uartPutc(B5CON);
206	uartPutc(123);	225	uartPutc(123);
207	uartPutc(CANSTAT);	226	uartPutc(CANSTAT);
208	uartPutc(COMSTAT);	227	uartPutc(COMSTAT);
209	uartPutc(ECANCON);	228	uartPutc(ECANCON);
210	uartPutc(123);	229	uartPutc(123);
211	uartPutc(TXB0CON);	230	uartPutc(TXB0CON);
212	uartPutc(TXB1CON);	231	uartPutc(TXB1CON);
213	uartPutc(TXB2CON);	232	uartPutc(TXB2CON);
214	uartPutc(123);	233	uartPutc(123);
215	uartPutc(PIR3);	234	uartPutc(PIR3);
216	uartPutc(PIE3);	235	uartPutc(PIE3);
217	uartPutc(123);	236	uartPutc(123);
218	uartPutc(BRGCON1);	237	uartPutc(BRGCON1);
219	uartPutc(BRGCON2);	238	uartPutc(BRGCON2);
220	uartPutc(BRGCON3);	239	uartPutc(BRGCON3);
221	uartPutc(123);	240	uartPutc(123);
222	uartPutc(RXFCON0);	241	uartPutc(RXFCON0);
223	uartPutc(RXFCON1);	242	uartPutc(RXFCON1);
224	uartPutc(123);	243	uartPutc(123);
225	uartPutc(RXFBCON0);	244	uartPutc(RXFBCON0);
226	uartPutc(RXFBCON1);	245	uartPutc(RXFBCON1);
227	uartPutc(RXFBCON2);	246	uartPutc(RXFBCON2);
228	uartPutc(RXFBCON3);	247	uartPutc(RXFBCON3);
229	uartPutc(RXFBCON4);	248	uartPutc(RXFBCON4);
230	uartPutc(RXFBCON5);	249	uartPutc(RXFBCON5);
231	uartPutc(RXFBCON6);	250	uartPutc(RXFBCON6);
232	uartPutc(RXFBCON7);	251	uartPutc(RXFBCON7);
233	uartPutc(123);	252	uartPutc(123);
234	uartPutc(TXBIE);	253	uartPutc(TXBIE);
235	uartPutc(BIE0);	254	uartPutc(BIE0);
236	}	255	}
237		256
238	}	257	}
239	#endif	258	#endif
240		259

Subversion Repositories HomeAutomation

(root)/EmbeddedSoftware/PIC/canNode/Source/Main.c @ 26 – Rev 25 → 26