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


/*********************************************************************
 *
 *                  Main application
 *
 *********************************************************************
 * FileName:        $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canBase/Source/Main.c $
 * Last changed:    $LastChangedDate: 2006-11-15 18:49:55 +0100 (Wed, 15 Nov 2006) $
 * By:              $LastChangedBy: johboh $
 * Revision:        $Revision: 109 $
 ********************************************************************/
 
 
#include <compiler.h>
#include <stackTasks.h>
#include <Tick.h>
#include <funcdefs.h>
#include <EEaccess.h>
 
#ifdef USE_CAN
    #include <CAN.h>
#endif
 
static void mainInit(void);
 
 
static int MY_ID = DEFAULT_ID;
static BYTE MY_NID = DEFAULT_NID;
 
void main()
{
    static TICK t = 0;
    CAN_MESSAGE outCm;
 
    // Inits
 
    mainInit();
 
    #ifdef USE_CAN
        canInit();
    #endif
 
    tickInit();
 
    // Read ID and NID if exist.
    if (EERead(NODE_ID_EE)==NODE_HAS_ID)
    {
        MY_ID=(((WORD)EERead(NODE_ID_EE + 1))<<8)+EERead(NODE_ID_EE + 2);
        MY_NID=EERead(NODE_ID_EE + 3);
    }
 
    // Send user program startup heatbeat
    outCm.funct                     = FUNCT_BOOTLOADER;
    outCm.funcc                     = FUNCC_BOOT_HEARTBEAT;
    outCm.nid                       = MY_NID;
    outCm.sid                       = MY_ID;
    outCm.data_length               = 1;
    outCm.data[BOOT_DATA_HEARTBEAT_INDEX] = HEARTBEAT_USER_STARTUP;
    while(!canSendMessage(outCm,PRIO_HIGH));
 
 
    while(1)
    {
        static TICK t = 0;
        static TICK heartbeat = 0;
 
       
        if ((tickGet()-heartbeat)>TICK_SECOND*5)
        {
            // Send alive heartbeat
            outCm.funct                     = FUNCT_BOOTLOADER;
            outCm.funcc                     = FUNCC_BOOT_HEARTBEAT;
            outCm.nid                       = MY_NID;
            outCm.sid                       = MY_ID;
            outCm.data_length               = 1;
            outCm.data[BOOT_DATA_HEARTBEAT_INDEX] = HEARTBEAT_ALIVE;
            while(!canSendMessage(outCm,PRIO_HIGH));
           
            heartbeat = tickGet();
        }
        if ((tickGet()-t)>TICK_SECOND)
        {
            LED0_IO=~LED0_IO;
            t = tickGet();
        }
    }
}
 
 
#pragma interrupt high_isr
void high_isr(void)
{
    ClrWdt();
 
    #ifdef USE_CAN
        canISR();
    #endif
 
    tickUpdate();
 
}
 
 
#pragma interrupt low_isr
void low_isr(void)
{
 
}
 
 
 
/*
*   Function: mainInit
*
*   Input:  none
*   Output: none
*   Pre-conditions: none
*   Affects: Se code
*   Depends: none.
*/
void mainInit()
{
    LED0_TRIS=0;   
 
    // Enable Interrupts
    INTCONbits.GIEH = 1;
    INTCONbits.GIEL = 1;
 
    // Enable interrupt prirority
    RCONbits.IPEN=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)
{
    CAN_MESSAGE outCm;
 
    ClrWdt();
 
    switch(cm.funct)
    {
        case FUNCT_BOOTLOADER:
            if (cm.nid==MY_NID && ((((unsigned int)cm.data[BOOT_DATA_RID_HIGH_INDEX])<<8)+cm.data[BOOT_DATA_RID_LOW_INDEX])==MY_ID)
            {
                switch(cm.funcc)
                {
                    case FUNCC_BOOT_INIT: Reset(); break; //User whant to program me, reset me.
                    case FUNCC_BOOT_SET_ID:
                        // Change my ID and NID
                        MY_ID=(((WORD)cm.data[BOOT_DATA_NEW_ID_HIGH_INDEX])<<8)+cm.data[BOOT_DATA_NEW_ID_LOW_INDEX];
                        MY_NID=cm.data[BOOT_DATA_NEW_NID_INDEX];
                        EEWrite(NODE_ID_EE+1,cm.data[BOOT_DATA_NEW_ID_HIGH_INDEX]);
                        EEWrite(NODE_ID_EE+2,cm.data[BOOT_DATA_NEW_ID_LOW_INDEX]);
                        EEWrite(NODE_ID_EE+3,cm.data[BOOT_DATA_NEW_NID_INDEX]);
                        EEWrite(NODE_ID_EE,NODE_HAS_ID);
                        // Send ack with new id.
                        outCm.funct                     = FUNCT_BOOTLOADER;
                        outCm.funcc                     = FUNCC_BOOT_ACK;
                        outCm.nid                       = MY_NID;
                        outCm.sid                       = MY_ID;
                        outCm.data_length               = 8;
                        outCm.data[BOOT_DATA_ERR_INDEX] = ACK_ERR_NO_ERROR;
                        while(!canSendMessage(outCm,PRIO_HIGH));
                    break;
                }
            }
 
 
        break;
    }
}
#endif
 
 
// Below are mandantory when using bootloader
// define DEBUG_MODE to use without bootloader.
 
#ifndef DEBUG_MODE
extern void _startup (void);
#pragma code _RESET_INTERRUPT_VECTOR = 0x001000
void _reset (void)
{
    _asm goto _startup _endasm
}
#pragma code
#endif
 
#pragma code _HIGH_INTERRUPT_VECTOR = 0x001008
void _high_ISR (void)
{
    _asm GOTO high_isr _endasm
}
#pragma code
 
#pragma code _LOW_INTERRUPT_VECTOR = 0x001018
void _low_ISR (void)
{
    _asm GOTO low_isr _endasm
}
#pragma code
 

Rev 108	Rev 109
1	/*********************************************************************	1	/*********************************************************************
2	*	2	*
3	* Main application	3	* Main application
4	*	4	*
5	*********************************************************************	5	*********************************************************************
6	* FileName: $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canBase/Source/Main.c $	6	* FileName: $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canBase/Source/Main.c $
7	* Last changed: $LastChangedDate: 2006-11-15 17:32:31 +0100 (Wed, 15 Nov 2006) $	7	* Last changed: $LastChangedDate: 2006-11-15 18:49:55 +0100 (Wed, 15 Nov 2006) $
8	* By: $LastChangedBy: johboh $	8	* By: $LastChangedBy: johboh $
9	* Revision: $Revision: ~~108~~ $	9	* Revision: $Revision: 109 $
10	********************************************************************/	10	********************************************************************/
11		11
12		12
13	#include <compiler.h>	13	#include <compiler.h>
14	#include <stackTasks.h>	14	#include <stackTasks.h>
15	#include <Tick.h>	15	#include <Tick.h>
16	#include <funcdefs.h>	16	#include <funcdefs.h>
17	#include <EEaccess.h>	17	#include <EEaccess.h>
18		18
19	#ifdef USE_CAN	19	#ifdef USE_CAN
20	#include <CAN.h>	20	#include <CAN.h>
21	#endif	21	#endif
22		22
23	static void mainInit(void);	23	static void mainInit(void);
24		24
25		25
26	static int MY_ID = DEFAULT_ID;	26	static int MY_ID = DEFAULT_ID;
27	static BYTE MY_NID = DEFAULT_NID;	27	static BYTE MY_NID = DEFAULT_NID;
28		28
29	void main()	29	void main()
30	{	30	{
31	static TICK t = 0;	31	static TICK t = 0;
32	CAN_MESSAGE outCm;	32	CAN_MESSAGE outCm;
33		33
34	// Inits	34	// Inits
35		35
36	mainInit();	36	mainInit();
37		37
38	#ifdef USE_CAN	38	#ifdef USE_CAN
39	canInit();	39	canInit();
40	#endif	40	#endif
41		41
42	tickInit();	42	tickInit();
43		43
44	// Read ID and NID if exist.	44	// Read ID and NID if exist.
45	if (EERead(NODE_ID_EE)==NODE_HAS_ID)	45	if (EERead(NODE_ID_EE)==NODE_HAS_ID)
46	{	46	{
47	MY_ID=(((WORD)EERead(NODE_ID_EE + 1))<<8)+EERead(NODE_ID_EE + 2);	47	MY_ID=(((WORD)EERead(NODE_ID_EE + 1))<<8)+EERead(NODE_ID_EE + 2);
48	MY_NID=EERead(NODE_ID_EE + 3);	48	MY_NID=EERead(NODE_ID_EE + 3);
49	}	49	}
-		50
-		51	// Send user program startup heatbeat
-		52	outCm.funct = FUNCT_BOOTLOADER;
-		53	outCm.funcc = FUNCC_BOOT_HEARTBEAT;
-		54	outCm.nid = MY_NID;
-		55	outCm.sid = MY_ID;
-		56	outCm.data_length = 1;
-		57	outCm.data[BOOT_DATA_HEARTBEAT_INDEX] = HEARTBEAT_USER_STARTUP;
-		58	while(!canSendMessage(outCm,PRIO_HIGH));
-		59
50		60
51	while(1)	61	while(1)
52	{	62	{
53	static TICK t = 0;	63	static TICK t = 0;
54	static TICK heartbeat = 0;	64	static TICK heartbeat = 0;
55		65
56		66
57	if ((tickGet()-heartbeat)>TICK_SECOND*5)	67	if ((tickGet()-heartbeat)>TICK_SECOND*5)
58	{	68	{
-		69	// Send alive heartbeat
59	outCm.funct = FUNCT_BOOTLOADER;	70	outCm.funct = FUNCT_BOOTLOADER;
60	outCm.funcc = FUNCC_BOOT_HEARTBEAT;	71	outCm.funcc = FUNCC_BOOT_HEARTBEAT;
61	outCm.nid = MY_NID;	72	outCm.nid = MY_NID;
62	outCm.sid = MY_ID;	73	outCm.sid = MY_ID;
63	outCm.data_length = 0;	74	outCm.data_length = 1;
-		75	outCm.data[BOOT_DATA_HEARTBEAT_INDEX] = HEARTBEAT_ALIVE;
64	while(!canSendMessage(outCm,PRIO_HIGH));	76	while(!canSendMessage(outCm,PRIO_HIGH));
65		77
66	heartbeat = tickGet();	78	heartbeat = tickGet();
67	}	79	}
68	if ((tickGet()-t)>TICK_SECOND)	80	if ((tickGet()-t)>TICK_SECOND)
69	{	81	{
70	LED0_IO=~LED0_IO;	82	LED0_IO=~LED0_IO;
71	t = tickGet();	83	t = tickGet();
72	}	84	}
73	}	85	}
74	}	86	}
75		87
76		88
77	#pragma interrupt high_isr	89	#pragma interrupt high_isr
78	void high_isr(void)	90	void high_isr(void)
79	{	91	{
80	ClrWdt();	92	ClrWdt();
81		93
82	#ifdef USE_CAN	94	#ifdef USE_CAN
83	canISR();	95	canISR();
84	#endif	96	#endif
85		97
86	tickUpdate();	98	tickUpdate();
87		99
88	}	100	}
89		101
90		102
91	#pragma interrupt low_isr	103	#pragma interrupt low_isr
92	void low_isr(void)	104	void low_isr(void)
93	{	105	{
94		106
95	}	107	}
96		108
97		109
98		110
99	/*	111	/*
100	* Function: mainInit	112	* Function: mainInit
101	*	113	*
102	* Input: none	114	* Input: none
103	* Output: none	115	* Output: none
104	* Pre-conditions: none	116	* Pre-conditions: none
105	* Affects: Se code	117	* Affects: Se code
106	* Depends: none.	118	* Depends: none.
107	*/	119	*/
108	void mainInit()	120	void mainInit()
109	{	121	{
110	LED0_TRIS=0;	122	LED0_TRIS=0;
111		123
112	// Enable Interrupts	124	// Enable Interrupts
113	INTCONbits.GIEH = 1;	125	INTCONbits.GIEH = 1;
114	INTCONbits.GIEL = 1;	126	INTCONbits.GIEL = 1;
115		127
116	// Enable interrupt prirority	128	// Enable interrupt prirority
117	RCONbits.IPEN=1;	129	RCONbits.IPEN=1;
118		130
119		131
120	}	132	}
121		133
122	/*	134	/*
123	* Function: canParse	135	* Function: canParse
124	*	136	*
125	* Input: Received can message	137	* Input: Received can message
126	* Output: none	138	* Output: none
127	* Pre-conditions: canInit and received packet.	139	* Pre-conditions: canInit and received packet.
128	* Affects: Sensors/actuators/etc. See code.	140	* Affects: Sensors/actuators/etc. See code.
129	* Depends: none.	141	* Depends: none.
130	*/	142	*/
131	#ifdef USE_CAN	143	#ifdef USE_CAN
132	void canParse(CAN_MESSAGE cm)	144	void canParse(CAN_MESSAGE cm)
133	{	145	{
134	CAN_MESSAGE outCm;	146	CAN_MESSAGE outCm;
135		147
136	ClrWdt();	148	ClrWdt();
137		149
138	switch(cm.funct)	150	switch(cm.funct)
139	{	151	{
140	case FUNCT_BOOTLOADER:	152	case FUNCT_BOOTLOADER:
141	if (cm.nid==MY_NID && ((((unsigned int)cm.data[BOOT_DATA_RID_HIGH_INDEX])<<8)+cm.data[BOOT_DATA_RID_LOW_INDEX])==MY_ID)	153	if (cm.nid==MY_NID && ((((unsigned int)cm.data[BOOT_DATA_RID_HIGH_INDEX])<<8)+cm.data[BOOT_DATA_RID_LOW_INDEX])==MY_ID)
142	{	154	{
143	switch(cm.funcc)	155	switch(cm.funcc)
144	{	156	{
145	case FUNCC_BOOT_INIT: Reset(); break; //User whant to program me, reset me.	157	case FUNCC_BOOT_INIT: Reset(); break; //User whant to program me, reset me.
146	case FUNCC_BOOT_SET_ID:	158	case FUNCC_BOOT_SET_ID:
147	// Change my ID and NID	159	// Change my ID and NID
148	MY_ID=(((WORD)cm.data[~~BOOT_DATA_NEW_ID_HIGH~~])<<8)+cm.data[~~BOOT_DATA_NEW_ID_LOW~~];	160	MY_ID=(((WORD)cm.data[BOOT_DATA_NEW_ID_HIGH_INDEX])<<8)+cm.data[BOOT_DATA_NEW_ID_LOW_INDEX];
149	MY_NID=cm.data[~~BOOT_DATA_NEW_NID~~];	161	MY_NID=cm.data[BOOT_DATA_NEW_NID_INDEX];
150	EEWrite(NODE_ID_EE+1,cm.data[~~BOOT_DATA_NEW_ID_HIGH~~]);	162	EEWrite(NODE_ID_EE+1,cm.data[BOOT_DATA_NEW_ID_HIGH_INDEX]);
151	EEWrite(NODE_ID_EE+2,cm.data[~~BOOT_DATA_NEW_ID_LOW~~]);	163	EEWrite(NODE_ID_EE+2,cm.data[BOOT_DATA_NEW_ID_LOW_INDEX]);
152	EEWrite(NODE_ID_EE+3,cm.data[~~BOOT_DATA_NEW_NID~~]);	164	EEWrite(NODE_ID_EE+3,cm.data[BOOT_DATA_NEW_NID_INDEX]);
153	EEWrite(NODE_ID_EE,NODE_HAS_ID);	165	EEWrite(NODE_ID_EE,NODE_HAS_ID);
154	// Send ack with new id.	166	// Send ack with new id.
155	outCm.funct = FUNCT_BOOTLOADER;	167	outCm.funct = FUNCT_BOOTLOADER;
156	outCm.funcc = FUNCC_BOOT_ACK;	168	outCm.funcc = FUNCC_BOOT_ACK;
157	outCm.nid = MY_NID;	169	outCm.nid = MY_NID;
158	outCm.sid = MY_ID;	170	outCm.sid = MY_ID;
159	outCm.data_length = 8;	171	outCm.data_length = 8;
160	outCm.data[BOOT_DATA_ERR_INDEX] = ACK_ERR_NO_ERROR;	172	outCm.data[BOOT_DATA_ERR_INDEX] = ACK_ERR_NO_ERROR;
161	while(!canSendMessage(outCm,PRIO_HIGH));	173	while(!canSendMessage(outCm,PRIO_HIGH));
162	break;	174	break;
163	}	175	}
164	}	176	}
165		177
166		178
167	break;	179	break;
168	}	180	}
169	}	181	}
170	#endif	182	#endif
171		183
172		184
173	// Below are mandantory when using bootloader	185	// Below are mandantory when using bootloader
174	// define DEBUG_MODE to use without bootloader.	186	// define DEBUG_MODE to use without bootloader.
175		187
176	#ifndef DEBUG_MODE	188	#ifndef DEBUG_MODE
177	extern void _startup (void);	189	extern void _startup (void);
178	#pragma code _RESET_INTERRUPT_VECTOR = 0x001000	190	#pragma code _RESET_INTERRUPT_VECTOR = 0x001000
179	void _reset (void)	191	void _reset (void)
180	{	192	{
181	_asm goto _startup _endasm	193	_asm goto _startup _endasm
182	}	194	}
183	#pragma code	195	#pragma code
184	#endif	196	#endif
185		197
186	#pragma code _HIGH_INTERRUPT_VECTOR = 0x001008	198	#pragma code _HIGH_INTERRUPT_VECTOR = 0x001008
187	void _high_ISR (void)	199	void _high_ISR (void)
188	{	200	{
189	_asm GOTO high_isr _endasm	201	_asm GOTO high_isr _endasm
190	}	202	}
191	#pragma code	203	#pragma code
192		204
193	#pragma code _LOW_INTERRUPT_VECTOR = 0x001018	205	#pragma code _LOW_INTERRUPT_VECTOR = 0x001018
194	void _low_ISR (void)	206	void _low_ISR (void)
195	{	207	{
196	_asm GOTO low_isr _endasm	208	_asm GOTO low_isr _endasm
197	}	209	}
198	#pragma code	210	#pragma code
199		211

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/PIC/canBase/Source/Main.c @ 109 – Rev 108 → 109