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

Subversion Repositories HomeAutomation

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