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


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

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/PIC/canIR/Source/Main.c @ 125 – Rev 122 → 125