WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/CanRelay/main.c


/**
 * CAN Relay.
 *
 *
 * @date    2006-12-17
 * @author  Erik Larsson
 *
 *   ADC=Vin*1024/Vref
 *   Vout=( 10 mV/C )( Temperature C ) + 500 mV
 *
 *  Transmitts: DATA: <temperature low byte> <temperature high byte> <relay status> <failsafe mode>
 *
 *
 */
 
#define TWO_BUTTON_MODE 0 /* If using two (or just one but nothing more) auxiliary buttons */
 
/*-----------------------------------------------------------------------------
 * Includes
 *---------------------------------------------------------------------------*/
/* system files */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <avr/wdt.h>
/* lib files */
#include <bios.h>
#include <tc1047.h>
#include <funcdefs.h>
 
/* defines */
#define GROUP_ID        0x01UL
 
#define RELAY_OFF           0x01UL
#define RELAY_ON            0x02UL
#define FAILSAFE_MODE       0x0FUL
#define FAILSAFE_TRESHOLD   60  /* Degrees when nodeRelay goes into failsafe mode */
 
#define RELAY_CMD_ON        0x01UL
#define RELAY_CMD_OFF       0x02UL
#define RELAY_CMD_TOGGLE    0x03UL
#define RELAY_CMD_STATUS    0x04UL
#define RELAY_CMD_RESET     0x05UL
#define STATUS_SEND_PERIOD  10000 /* milliseconds */
#define FAILSAFE_SEND_PERIOD    10000 /* milliseconds */
#define BOUNCE_TIME         10 /* milliseconds */
#define BUTTON1             1
#define BUTTON2             2
 
/*-------------------------------------------------------------------------
 * Global variables
 * -----------------------------------------------------------------------*/
#if TWO_BUTTON_MODE
Can_Message_t txMsg_Button;
#endif
 
uint8_t relayStatus, failsafe_flag = 0;
uint32_t boardTemperature = 0;
Can_Message_t txMsg;
 
/*----------------------------------------------------------------------------
 * Functions
 * -------------------------------------------------------------------------*/
uint8_t relayOff();
uint8_t relayOn();
void relayFailsafe();
 
void can_receive(Can_Message_t *msg){
    uint32_t act;
    uint32_t m, act_type, group, node;
 
    if( ((msg->Id & CLASS_MASK)>>CLASS_MASK_BITS) == CLASS_ACT){
 
        act = (msg->Id & TYPE_MASK) >> TYPE_MASK_BITS;
        act_type = (act & ACT_TYPE_MASK) >> ACT_TYPE_BITS;
        group = (act & ACT_GROUP_MASK) >> ACT_GROUP_BITS;
        node = (act & ACT_NODE_MASK) >> ACT_NODE_BITS;
 
        if( act_type == ACT_TYPE_RELAY && (group == GROUP_ID || node == NODE_ID) ){
            if(msg->Data.bytes[0] == RELAY_CMD_ON && !failsafe_flag){
                // Turn relay on
                relayStatus = relayOn();
 
            }else if(msg->Data.bytes[0] == RELAY_CMD_OFF && !failsafe_flag){
                // Turn relay off
                relayStatus = relayOff();
                txMsg.Id = 0x8000111UL; // FIXME
                bios->can_send(&txMsg);
 
            }else if(msg->Data.bytes[0] == RELAY_CMD_TOGGLE && !failsafe_flag){
                    // Toggle relay
                    if(relayStatus == RELAY_OFF){
                        relayStatus = relayOn();
                    }else{
                        relayStatus = relayOff();
                        txMsg.Id = 0x8000113UL; // FIXME
                        bios->can_send(&txMsg);
                    }
 
            }else if(msg->Data.bytes[0] == RELAY_CMD_STATUS && !failsafe_flag){
                // Send relay status to CAN
                boardTemperature = getTC1047temperature();
 
                if( (int32_t)boardTemperature >= FAILSAFE_TRESHOLD ){
                    // Goto failsafe mode
                    relayFailsafe();
                }else{
                    // Transmitt node status
                    txMsg.Data.bytes[0] = boardTemperature & 0x00FF;
                    txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;
                    txMsg.Data.bytes[2] = relayStatus;
                    txMsg.Data.bytes[3] = 0;
                    txMsg.Id = ( CLASS_SNS<<CLASS_MASK_BITS )|( SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS )|(NODE_ID);
                    bios->can_send( &txMsg );
                }
            }else if(msg->Data.bytes[0] == RELAY_CMD_RESET){
                // Return to normal operation
                failsafe_flag = 0;
            }
        }
    }
}
 
/*----------------------------------------------------------------------------
 * Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder
 * -------------------------------------------------------------------------*/
#if TWO_BUTTON_MODE
ISR( PCINT2_vect )
{
    /*
     * Auxiliary button pressed and released
     * Check time between press and release to eliminate bounces
     */
    static uint32_t buttonTime[2];
 
    txMsg_Button.RemoteFlag = 0;
    txMsg_Button.ExtendedFlag = 1;
 
    if( (PIND & (1<<PD6)) == 0){
        /* Button pressed */
        buttonTime[0] = Timebase_CurrentTime();
    }else if( (PIND & (1<<PD6)) == 1){
        if( Timebase_PassedTimeMillis( buttonTime[0] ) >= BOUNCE_TIME ){
            /* No bounce, send message */
            txMsg_Button.Id = BUTTON_ID;
            txMsg_Button.DataLength = 1;
            txMsg_Button.Data.bytes[0] = BUTTON1;
            return;
        }else{
            /* Just bounces, ignore it */
            return;
        }
    }
    if( (PIND & (1<<PD7)) == 0){
        /* Button pressed */
        buttonTime[1] = Timebase_CurrentTime();
    }else if( (PIND & (1<<PD7)) == 1){
        if( Timebase_PassedTimeMillis( buttonTime[1] ) >= BOUNCE_TIME ){
            /* No bounce, send message */
            txMsg_Button.Id = BUTTON_ID;
            txMsg_Button.DataLength = 1;
            txMsg_Button.Data.bytes[0] = BUTTON2;
            return;
        }else{
            /* Just bounces, ignore it */
            return;
        }
    }
}
#endif
 
/*-----------------------------------------------------------------------------
 * Main Program
 *---------------------------------------------------------------------------*/
int main(void) {
 
    adcTemperatureInit();
 
#if TWO_BUTTON_MODE
#error two button mode not yet tested
    /*
     * Initialize buttons
     * It is possible to use ie. sensors instead
     * but then change this
     */
    // Set as input and enable pull-up
    DDRD &= ~( (1<<DDD6)|(1<<DDD7) );
    PORTD |= (1<<PD6)|(1<<PD7);
 
    // Enable IO-pin interrupt
    PCICR |= (1<<PCIE1);
    // Unmask PD6 and PD7
    PCMSK2 |= (1<<PCINT22) | (1<<PCINT23);
#endif
 
    // Control channel for relay
    DDRC |= (1<<DDC1);
 
    // Set up callback for CAN messages
    bios->can_callback = &can_receive;
 
 
 
 
 
 
 
 
    txMsg.RemoteFlag = 0;
    txMsg.ExtendedFlag = 1;
    txMsg.DataLength = 4;
 
    sei();
 
    // Turn relay off
    relayStatus = relayOff();
    txMsg.Id = 0x8000110UL; // FIXME
    bios->can_send(&txMsg);
 
    uint32_t timeStamp = 0;
 
 
    // Main loop
    while (1) {
 
        if( bios->timebase_get() - timeStamp >= STATUS_SEND_PERIOD ){
            timeStamp = bios->timebase_get();
            // Send relay status to CAN
 
            boardTemperature = getTC1047temperature();
 
            if( (int32_t)boardTemperature >= FAILSAFE_TRESHOLD ){
                relayFailsafe();
            }else{
                txMsg.Data.bytes[0] = boardTemperature & 0x00FF;
                txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;
                txMsg.Data.bytes[2] = relayStatus;
                txMsg.Data.bytes[3] = 0;
                txMsg.Id = ( CLASS_SNS<<CLASS_MASK_BITS )|( SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS )|(NODE_ID);
                bios->can_send( &txMsg );
            }
        }
    }
    return 0;
}
 
uint8_t relayOff()
{
    // Turn off relay
    PORTC &= ~(1<<PC1);
    DDRC |= (1<<DDC1); // FIXME
 
    return RELAY_OFF;
}
 
uint8_t relayOn()
{
    // Turn on relay
    DDRC &= ~(1<<DDC1); // FIXME
    PORTC |= (1<<PC1);
 
    return RELAY_ON;
}
 
void relayFailsafe()
{
    uint32_t timeStamp = 0;
 
    relayStatus = relayOff();
    failsafe_flag = 1;
 
    while(1){
 
        if( !failsafe_flag ){
            // Return from failsafe mode
            return;
        }
 
        if( bios->timebase_get() - timeStamp >= FAILSAFE_SEND_PERIOD ){
            timeStamp = bios->timebase_get();
            // Send relay status to CAN
            boardTemperature = getTC1047temperature();
 
            txMsg.Data.bytes[0] = boardTemperature & 0x00FF;
            txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;
            txMsg.Data.bytes[2] = relayStatus;
            txMsg.Data.bytes[3] = FAILSAFE_MODE;
            txMsg.Id = ( CLASS_SNS<<CLASS_MASK_BITS )|( SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS )|(NODE_ID);
 
            bios->can_send( &txMsg );
        }
    }
}
 
 

Rev 351	Rev 352
1	/**	1	/**
2	* CAN Relay.	2	* CAN Relay.
3	*	3	*
4	*	4	*
5	* @date 2006-12-17	5	* @date 2006-12-17
6	* @author Erik Larsson	6	* @author Erik Larsson
7	*	7	*
8	* ADC=Vin*1024/Vref	8	* ADC=Vin*1024/Vref
9	* Vout=( 10 mV/C )( Temperature C ) + 500 mV	9	* Vout=( 10 mV/C )( Temperature C ) + 500 mV
10	*	10	*
11	* Transmitts: DATA: <temperature low byte> <temperature high byte> <relay status> <failsafe mode>	11	* Transmitts: DATA: <temperature low byte> <temperature high byte> <relay status> <failsafe mode>
12	*	12	*
13	*	13	*
14	*/	14	*/
15		15
16	#define TWO_BUTTON_MODE 0 /* If using two (or just one but nothing more) auxiliary buttons */	16	#define TWO_BUTTON_MODE 0 /* If using two (or just one but nothing more) auxiliary buttons */
17		17
18	/*-----------------------------------------------------------------------------	18	/*-----------------------------------------------------------------------------
19	* Includes	19	* Includes
20	---------------------------------------------------------------------------/	20	---------------------------------------------------------------------------/
21	/* system files */	21	/* system files */
22	#include <avr/io.h>	22	#include <avr/io.h>
23	#include <avr/interrupt.h>	23	#include <avr/interrupt.h>
24	#include <stdio.h>	24	#include <stdio.h>
-		25	#include <avr/wdt.h>
25	/* lib files */	26	/* lib files */
26	#include <bios.h>	27	#include <bios.h>
27	#include <tc1047.h>	28	#include <tc1047.h>
28	#include <funcdefs.h>	29	#include <funcdefs.h>
29		30
30	/* defines */	31	/* defines */
31	#define GROUP_ID ~~0x01~~	32	#define GROUP_ID 0x01UL
32		33
33	#define RELAY_OFF ~~0x01~~	34	#define RELAY_OFF 0x01UL
34	#define RELAY_ON ~~0x02~~	35	#define RELAY_ON 0x02UL
35	#define FAILSAFE_MODE ~~0x0F~~	36	#define FAILSAFE_MODE 0x0FUL
36	#define FAILSAFE_TRESHOLD 60 /* Degrees when nodeRelay goes into failsafe mode */	37	#define FAILSAFE_TRESHOLD 60 /* Degrees when nodeRelay goes into failsafe mode */
37		38
38	#define RELAY_CMD_ON ~~0x01~~	39	#define RELAY_CMD_ON 0x01UL
39	#define RELAY_CMD_OFF ~~0x02~~	40	#define RELAY_CMD_OFF 0x02UL
40	#define RELAY_CMD_TOGGLE ~~0x03~~	41	#define RELAY_CMD_TOGGLE 0x03UL
41	#define RELAY_CMD_STATUS ~~0x04~~	42	#define RELAY_CMD_STATUS 0x04UL
42	#define RELAY_CMD_RESET ~~0x05~~	43	#define RELAY_CMD_RESET 0x05UL
43	#define STATUS_SEND_PERIOD 10000 /* milliseconds */	44	#define STATUS_SEND_PERIOD 10000 /* milliseconds */
44	#define FAILSAFE_SEND_PERIOD 10000 /* milliseconds */	45	#define FAILSAFE_SEND_PERIOD 10000 /* milliseconds */
45	#define BOUNCE_TIME 10 /* milliseconds */	46	#define BOUNCE_TIME 10 /* milliseconds */
46	#define BUTTON1 1	47	#define BUTTON1 1
47	#define BUTTON2 2	48	#define BUTTON2 2
48		49
49	/*-------------------------------------------------------------------------	50	/*-------------------------------------------------------------------------
50	* Global variables	51	* Global variables
51	* -----------------------------------------------------------------------*/	52	* -----------------------------------------------------------------------*/
52	#if TWO_BUTTON_MODE	53	#if TWO_BUTTON_MODE
53	Can_Message_t txMsg_Button;	54	Can_Message_t txMsg_Button;
54	#endif	55	#endif
55		56
56	uint8_t relayStatus, failsafe_flag;	57	uint8_t relayStatus, failsafe_flag = 0;
57	uint32_t boardTemperature = 0;	58	uint32_t boardTemperature = 0;
58	Can_Message_t txMsg;	59	Can_Message_t txMsg;
59		60
60	/*----------------------------------------------------------------------------	61	/*----------------------------------------------------------------------------
61	* Functions	62	* Functions
62	* -------------------------------------------------------------------------*/	63	* -------------------------------------------------------------------------*/
63	uint8_t relayOff();	64	uint8_t relayOff();
64	uint8_t relayOn();	65	uint8_t relayOn();
65	void relayFailsafe();	66	void relayFailsafe();
66		67
67	void can_receive(Can_Message_t *msg){	68	void can_receive(Can_Message_t *msg){
68	uint32_t act;	69	uint32_t act;
69	~~uint8_t~~ m, act_type, group, node;	70	uint32_t m, act_type, group, node;
70		71
71	if( ((msg->Id & CLASS_MASK)>>CLASS_MASK_BITS) == CLASS_ACT){	72	if( ((msg->Id & CLASS_MASK)>>CLASS_MASK_BITS) == CLASS_ACT){
72		73
73	act = (msg->Id & TYPE_MASK) >> TYPE_MASK_BITS;	74	act = (msg->Id & TYPE_MASK) >> TYPE_MASK_BITS;
74	act_type = (act & ACT_TYPE_MASK) >> ACT_TYPE_BITS;	75	act_type = (act & ACT_TYPE_MASK) >> ACT_TYPE_BITS;
75	group = (act & ACT_GROUP_MASK) >> ACT_GROUP_BITS;	76	group = (act & ACT_GROUP_MASK) >> ACT_GROUP_BITS;
76	node = (act & ACT_NODE_MASK) >> ACT_NODE_BITS;	77	node = (act & ACT_NODE_MASK) >> ACT_NODE_BITS;
77		78
78	if( act_type == ACT_TYPE_RELAY && (group == GROUP_ID \|\| node == NODE_ID) ){	79	if( act_type == ACT_TYPE_RELAY && (group == GROUP_ID \|\| node == NODE_ID) ){
79	if(msg->Data.bytes[0] == RELAY_CMD_ON){	80	if(msg->Data.bytes[0] == RELAY_CMD_ON && !failsafe_flag){
80	// Turn relay on	81	// Turn relay on
81	relayStatus = relayOn();	82	relayStatus = relayOn();
82		83
83	}else if(msg->Data.bytes[0] == RELAY_CMD_OFF){	84	}else if(msg->Data.bytes[0] == RELAY_CMD_OFF && !failsafe_flag){
84	// Turn relay off	85	// Turn relay off
85	relayStatus = relayOff();	86	relayStatus = relayOff();
-		87	txMsg.Id = 0x8000111UL; // FIXME
-		88	bios->can_send(&txMsg);
86		89
87	}else if(msg->Data.bytes[0] == RELAY_CMD_TOGGLE ){	90	}else if(msg->Data.bytes[0] == RELAY_CMD_TOGGLE && !failsafe_flag){
88	// Toggle relay	91	// Toggle relay
89	if(relayStatus == RELAY_OFF){	92	if(relayStatus == RELAY_OFF){
90	relayStatus = relayOn();	93	relayStatus = relayOn();
91	}else{	94	}else{
92	relayStatus = relayOff();	95	relayStatus = relayOff();
-		96	txMsg.Id = 0x8000113UL; // FIXME
-		97	bios->can_send(&txMsg);
93	}	98	}
94		99
95	}else if(msg->Data.bytes[0] == RELAY_CMD_STATUS){	100	}else if(msg->Data.bytes[0] == RELAY_CMD_STATUS && !failsafe_flag){
96	// Send relay status to CAN	101	// Send relay status to CAN
97	boardTemperature = getTC1047temperature();	102	boardTemperature = getTC1047temperature();
98		103
99	if( (int32_t)boardTemperature >= FAILSAFE_TRESHOLD ){	104	if( (int32_t)boardTemperature >= FAILSAFE_TRESHOLD ){
100	// Goto failsafe mode	105	// Goto failsafe mode
101	relayFailsafe();	106	relayFailsafe();
102	}else{	107	}else{
103	// Transmitt node status	108	// Transmitt node status
104	txMsg.Data.bytes[0] = boardTemperature & 0x00FF;	109	txMsg.Data.bytes[0] = boardTemperature & 0x00FF;
105	txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;	110	txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;
106	txMsg.Data.bytes[2] = relayStatus;	111	txMsg.Data.bytes[2] = relayStatus;
107	txMsg.~~DataLength~~ = 3;	112	txMsg.Data.bytes[3] = 0;
-		113	txMsg.Id = ( CLASS_SNS<<CLASS_MASK_BITS )\|( SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS )\|(NODE_ID);
108	bios->can_send( &txMsg );	114	bios->can_send( &txMsg );
109	}	115	}
110	}else if(msg->Data.bytes[0] == RELAY_CMD_RESET){	116	}else if(msg->Data.bytes[0] == RELAY_CMD_RESET){
111	// Return to normal operation	117	// Return to normal operation
112	failsafe_flag = 1;	118	failsafe_flag = 0;
113	}	119	}
114	}	120	}
115	}	121	}
116	}	122	}
117		123
118	/*----------------------------------------------------------------------------	124	/*----------------------------------------------------------------------------
119	* Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder	125	* Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder
120	* -------------------------------------------------------------------------*/	126	* -------------------------------------------------------------------------*/
121	#if TWO_BUTTON_MODE	127	#if TWO_BUTTON_MODE
122	ISR( PCINT2_vect )	128	ISR( PCINT2_vect )
123	{	129	{
124	/*	130	/*
125	* Auxiliary button pressed and released	131	* Auxiliary button pressed and released
126	* Check time between press and release to eliminate bounces	132	* Check time between press and release to eliminate bounces
127	*/	133	*/
128	static uint32_t buttonTime[2];	134	static uint32_t buttonTime[2];
129		135
130	txMsg_Button.RemoteFlag = 0;	136	txMsg_Button.RemoteFlag = 0;
131	txMsg_Button.ExtendedFlag = 1;	137	txMsg_Button.ExtendedFlag = 1;
132		138
133	if( (PIND & (1<<PD6)) == 0){	139	if( (PIND & (1<<PD6)) == 0){
134	/* Button pressed */	140	/* Button pressed */
135	buttonTime[0] = Timebase_CurrentTime();	141	buttonTime[0] = Timebase_CurrentTime();
136	}else if( (PIND & (1<<PD6)) == 1){	142	}else if( (PIND & (1<<PD6)) == 1){
137	if( Timebase_PassedTimeMillis( buttonTime[0] ) >= BOUNCE_TIME ){	143	if( Timebase_PassedTimeMillis( buttonTime[0] ) >= BOUNCE_TIME ){
138	/* No bounce, send message */	144	/* No bounce, send message */
139	txMsg_Button.Id = BUTTON_ID;	145	txMsg_Button.Id = BUTTON_ID;
140	txMsg_Button.DataLength = 1;	146	txMsg_Button.DataLength = 1;
141	txMsg_Button.Data.bytes[0] = BUTTON1;	147	txMsg_Button.Data.bytes[0] = BUTTON1;
142	return;	148	return;
143	}else{	149	}else{
144	/* Just bounces, ignore it */	150	/* Just bounces, ignore it */
145	return;	151	return;
146	}	152	}
147	}	153	}
148	if( (PIND & (1<<PD7)) == 0){	154	if( (PIND & (1<<PD7)) == 0){
149	/* Button pressed */	155	/* Button pressed */
150	buttonTime[1] = Timebase_CurrentTime();	156	buttonTime[1] = Timebase_CurrentTime();
151	}else if( (PIND & (1<<PD7)) == 1){	157	}else if( (PIND & (1<<PD7)) == 1){
152	if( Timebase_PassedTimeMillis( buttonTime[1] ) >= BOUNCE_TIME ){	158	if( Timebase_PassedTimeMillis( buttonTime[1] ) >= BOUNCE_TIME ){
153	/* No bounce, send message */	159	/* No bounce, send message */
154	txMsg_Button.Id = BUTTON_ID;	160	txMsg_Button.Id = BUTTON_ID;
155	txMsg_Button.DataLength = 1;	161	txMsg_Button.DataLength = 1;
156	txMsg_Button.Data.bytes[0] = BUTTON2;	162	txMsg_Button.Data.bytes[0] = BUTTON2;
157	return;	163	return;
158	}else{	164	}else{
159	/* Just bounces, ignore it */	165	/* Just bounces, ignore it */
160	return;	166	return;
161	}	167	}
162	}	168	}
163	}	169	}
164	#endif	170	#endif
165		171
166	/*-----------------------------------------------------------------------------	172	/*-----------------------------------------------------------------------------
167	* Main Program	173	* Main Program
168	---------------------------------------------------------------------------/	174	---------------------------------------------------------------------------/
169	int main(void) {	175	int main(void) {
170		176
171	adcTemperatureInit();	177	adcTemperatureInit();
172		178
173	#if TWO_BUTTON_MODE	179	#if TWO_BUTTON_MODE
174	#error two button mode not yet tested	180	#error two button mode not yet tested
175	/*	181	/*
176	* Initialize buttons	182	* Initialize buttons
177	* It is possible to use ie. sensors instead	183	* It is possible to use ie. sensors instead
178	* but then change this	184	* but then change this
179	*/	185	*/
180	// Set as input and enable pull-up	186	// Set as input and enable pull-up
181	DDRD &= ~( (1<<DDD6)\|(1<<DDD7) );	187	DDRD &= ~( (1<<DDD6)\|(1<<DDD7) );
182	PORTD \|= (1<<PD6)\|(1<<PD7);	188	PORTD \|= (1<<PD6)\|(1<<PD7);
183		189
184	// Enable IO-pin interrupt	190	// Enable IO-pin interrupt
185	PCICR \|= (1<<PCIE1);	191	PCICR \|= (1<<PCIE1);
186	// Unmask PD6 and PD7	192	// Unmask PD6 and PD7
187	PCMSK2 \|= (1<<PCINT22) \| (1<<PCINT23);	193	PCMSK2 \|= (1<<PCINT22) \| (1<<PCINT23);
188	#endif	194	#endif
189		195
190	// Control channel for relay	196	// Control channel for relay
191	DDRC \|= (1<<DDC1);	197	DDRC \|= (1<<DDC1);
192		198
193	// Set up callback for CAN messages	199	// Set up callback for CAN messages
194	bios->can_callback = &can_receive;	200	bios->can_callback = &can_receive;
195		-
196	sei();	-
197		-
198	// Turn relay off	-
199	relayStatus = relayOff();	-
200		-
201	uint32_t timeStamp = 0;	-
202		201
203	txMsg.RemoteFlag = 0;	202	txMsg.RemoteFlag = 0;
204	txMsg.ExtendedFlag = 1;	203	txMsg.ExtendedFlag = 1;
-		204	txMsg.DataLength = 4;
-		205
-		206	sei();
-		207
-		208	// Turn relay off
-		209	relayStatus = relayOff();
205	txMsg.Id = ~~( CLASS_SNS<<CLASS_MASK_BITS )\|(~~ ~~SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS~~ ~~)\|(NODE_ID);~~	210	txMsg.Id = 0x8000110UL; // FIXME
-		211	bios->can_send(&txMsg);
-		212
-		213	uint32_t timeStamp = 0;
-		214
206		215
207	// Main loop	216	// Main loop
208	while (1) {	217	while (1) {
209		218
210	if( bios->timebase_get() - timeStamp >= STATUS_SEND_PERIOD ){	219	if( bios->timebase_get() - timeStamp >= STATUS_SEND_PERIOD ){
211	timeStamp = bios->timebase_get();	220	timeStamp = bios->timebase_get();
212	// Send relay status to CAN	221	// Send relay status to CAN
213		222
214	boardTemperature = getTC1047temperature();	223	boardTemperature = getTC1047temperature();
215		224
216	if( (int32_t)boardTemperature >= FAILSAFE_TRESHOLD ){	225	if( (int32_t)boardTemperature >= FAILSAFE_TRESHOLD ){
217	relayFailsafe();	226	relayFailsafe();
218	}else{	227	}else{
219	txMsg.Data.bytes[0] = boardTemperature & 0x00FF;	228	txMsg.Data.bytes[0] = boardTemperature & 0x00FF;
220	txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;	229	txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;
221	txMsg.Data.bytes[2] = relayStatus;	230	txMsg.Data.bytes[2] = relayStatus;
222	txMsg.~~DataLength~~ = 3;	231	txMsg.Data.bytes[3] = 0;
-		232	txMsg.Id = ( CLASS_SNS<<CLASS_MASK_BITS )\|( SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS )\|(NODE_ID);
223	bios->can_send( &txMsg );	233	bios->can_send( &txMsg );
224	}	234	}
225	}	235	}
226	}	236	}
227	return 0;	237	return 0;
228	}	238	}
229		239
230	uint8_t relayOff()	240	uint8_t relayOff()
231	{	241	{
232	// Turn off relay	242	// Turn off relay
233	PORTC &= ~(1<<PC1);	243	PORTC &= ~(1<<PC1);
-		244	DDRC \|= (1<<DDC1); // FIXME
234		245
235	return RELAY_OFF;	246	return RELAY_OFF;
236	}	247	}
237		248
238	uint8_t relayOn()	249	uint8_t relayOn()
239	{	250	{
240	// Turn on relay	251	// Turn on relay
-		252	DDRC &= ~(1<<DDC1); // FIXME
241	PORTC \|= (1<<PC1);	253	PORTC \|= (1<<PC1);
242		254
243	return RELAY_ON;	255	return RELAY_ON;
244	}	256	}
245		257
246	void relayFailsafe()	258	void relayFailsafe()
247	{	259	{
248	uint32_t timeStamp = 0;	260	uint32_t timeStamp = 0;
249		261
250	relayStatus = relayOff();	262	relayStatus = relayOff();
251	failsafe_flag = 0;	263	failsafe_flag = 1;
252		264
253	while(1){	265	while(1){
254		266
255	if( failsafe_flag ){	267	if( !failsafe_flag ){
256	// Return from failsafe mode	268	// Return from failsafe mode
257	return;	269	return;
258	}	270	}
259		271
260	if( bios->timebase_get() - timeStamp >= FAILSAFE_SEND_PERIOD ){	272	if( bios->timebase_get() - timeStamp >= FAILSAFE_SEND_PERIOD ){
261	timeStamp = bios->timebase_get();	273	timeStamp = bios->timebase_get();
262	// Send relay status to CAN	274	// Send relay status to CAN
263	boardTemperature = getTC1047temperature();	275	boardTemperature = getTC1047temperature();
264		276
265	txMsg.Data.bytes[0] = boardTemperature & 0x00FF;	277	txMsg.Data.bytes[0] = boardTemperature & 0x00FF;
266	txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;	278	txMsg.Data.bytes[1] = (boardTemperature & 0xFF00)>>8;
267	txMsg.Data.bytes[2] = relayStatus;	279	txMsg.Data.bytes[2] = relayStatus;
268	txMsg.Data.bytes[3] = FAILSAFE_MODE;	280	txMsg.Data.bytes[3] = FAILSAFE_MODE;
-		281	txMsg.Id = ( CLASS_SNS<<CLASS_MASK_BITS )\|( SNS_ACT_STATUS_RELAY<<TYPE_MASK_BITS )\|(NODE_ID);
269		282
270	bios->can_send( &txMsg );	283	bios->can_send( &txMsg );
271	}	284	}
272	}	285	}
273	}	286	}
274		287
275		288

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/CanRelay/main.c @ 352 – Rev 351 → 352