WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/application/Relay/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>
 *
 *
 */
 
 
/*-----------------------------------------------------------------------------
 * Includes
 *---------------------------------------------------------------------------*/
/* system files */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <string.h>
/* lib files */
#include "../config.inc" 
#include <config.h>
#include <bios.h>
#include <drivers/timer/timebase.h>
#include <drivers/sensor/tc1047/tc1047.h>
 
 
 
/* defines */
#define RELAY_OFF           0x01
#define RELAY_ON            0x02
#define FAILSAFE_MODE       0x0F
#define FAILSAFE_TRESHOLD   0xFF  /* Degrees when nodeRelay goes into failsafe mode */
 
#define RELAY_CMD_ON        0x01
#define RELAY_CMD_OFF       0x02
#define RELAY_CMD_TOGGLE    0x03
#define RELAY_CMD_STATUS    0x04
#define RELAY_CMD_RESET     0x05
#define STATUS_SEND_PERIOD  10000UL /* milliseconds */
#define FAILSAFE_SEND_PERIOD    10000UL /* milliseconds */
#define BOUNCE_TIME         10 /* milliseconds */
#define BUTTON1             1
#define BUTTON2             2
 
#define APP_TYPE    CAN_APPTYPES_RELAY
#define APP_VERSION 0x0001
 
/*-------------------------------------------------------------------------
 * Global variables
 * -----------------------------------------------------------------------*/
uint8_t relayStatus, failsafe_flag = 0;
uint32_t boardTemperature = 0;
 
volatile Can_Message_t rxMsg; // Message storage
volatile uint8_t rxMsgFull;   // Synchronization flag
 
 
/*----------------------------------------------------------------------------
 * Functions
 * -------------------------------------------------------------------------*/
uint8_t relayOff(void);
uint8_t relayOn(void);
void relayFailsafe(void);
void sendStatus(void);
 
void can_receive(Can_Message_t *msg)
{ // CAN callback function
    if (!rxMsgFull) {
        memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
        rxMsgFull = 1;
    }
}
 
/*----------------------------------------------------------------------------
 * Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder
 * -------------------------------------------------------------------------*/
#if TWO_BUTTON_MODE
ISR( PCINT2_vect )
{
 
}
#endif
 
/*-----------------------------------------------------------------------------
 * Main Program
 *---------------------------------------------------------------------------*/
int main(void) {
 
    uint32_t timeStamp = Timebase_CurrentTime(), temp = timeStamp;
 
    adcTemperatureInit();
 
    // Set up callback for CAN messages
    BIOS_CanCallback = &can_receive;
 
    sei();
   
    Timebase_Init();
 
    Can_Message_t txMsg;
    txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) | (NODE_ID << CAN_SHIFT_NMT_SID);
    txMsg.DataLength = 4;
    txMsg.RemoteFlag = 0;
    txMsg.ExtendedFlag = 1;
    txMsg.Data.words[0] = APP_TYPE;
    txMsg.Data.words[1] = APP_VERSION;
    BIOS_CanSend(&txMsg);
 
    // Turn relay off
    relayStatus = relayOff();
 
    // Main loop
    while (1) {
 
        temp = Timebase_CurrentTime();
        if( temp - timeStamp >= STATUS_SEND_PERIOD ){
            timeStamp = temp;
            // Send relay status to CAN
            sendStatus();
        }
 
        if (rxMsgFull) {
            uint16_t acttype;
            uint8_t relayid;
       
            if ( ((rxMsg.Id & CAN_MASK_CLASS)>>CAN_SHIFT_CLASS) == CAN_ACT){
                // Actuator package
                acttype =(uint16_t)((rxMsg.Id & CAN_MASK_ACT_TYPE) >> CAN_SHIFT_ACT_TYPE);
                relayid = (uint8_t)((rxMsg.Id & CAN_MASK_ACT_ID) >> CAN_SHIFT_ACT_ID);
               
                if ((acttype == ACT_TYPE_RELAY) && (relayid == THISRELAYID)) {
                    // This is a message for this relay
                    if (rxMsg.Data.bytes[0] == RELAY_CMD_RESET) {
                        // Return to normal operation
                        failsafe_flag = 0;
                    }
                   
                    if (!failsafe_flag) {
                        if (rxMsg.Data.bytes[0] == RELAY_CMD_ON ){
                            // Turn relay on
                            relayStatus = relayOn();
           
                        } else if (rxMsg.Data.bytes[0] == RELAY_CMD_OFF ){
                            // Turn relay off
                            relayStatus = relayOff();
           
                        } else if (rxMsg.Data.bytes[0] == RELAY_CMD_TOGGLE ){
                                // Toggle relay
                                if(relayStatus == RELAY_OFF){
                                    relayStatus = relayOn();
                                }else{
                                    relayStatus = relayOff();
                                }
           
                        }else if(rxMsg.Data.bytes[0] == RELAY_CMD_STATUS ){
                            // Send relay status to CAN
                            sendStatus();
                        }
                    }
                }
            }
            rxMsgFull = 0; //  
 
        }
       
    }
    return 0;
}
 
uint8_t relayOff()
{
    // Turn off relay
    PORTC &= ~(1<<PC1);
    DDRC |= (1<<DDC1);
 
    return RELAY_OFF;
}
 
uint8_t relayOn()
{
    // Turn on relay
    DDRC &= ~(1<<DDC1);
    PORTC |= (1<<PC1);
 
    return RELAY_ON;
}
 
void relayFailsafe()
{
    uint32_t failsafe_timeStamp, temp;
    relayStatus = relayOff();
    failsafe_flag = 1;
 
    while(1){
 
        if( !failsafe_flag ){
            // Return from failsafe mode
            return;
        }
// TODO skicka med period
        sendStatus( );
    }
}
 
void sendStatus()
{
    uint32_t temperature;
    Can_Message_t statusMsg;
    statusMsg.RemoteFlag = 0;
    statusMsg.ExtendedFlag = 1;
    statusMsg.DataLength = 4;
    statusMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_STATUS << CAN_SHIFT_SNS_TYPE) | (SNS_ID_RELAY_STATUS << CAN_SHIFT_SNS_ID) | (NODE_ID << CAN_SHIFT_SNS_SID));
   
    temperature = getTC1047temperature();
    if( (int32_t)temperature >= FAILSAFE_TRESHOLD && !failsafe_flag ){
        // Goto failsafe mode
        relayFailsafe();
    }else{
        // Transmitt node status
        statusMsg.Data.bytes[0] = temperature & 0x00FF;
        statusMsg.Data.bytes[1] = (temperature & 0xFF00)>>8;
        statusMsg.Data.bytes[2] = relayStatus;
        statusMsg.Data.bytes[3] = failsafe_flag;
 
        BIOS_CanSend( &statusMsg );
    }
}
 

Rev 563	Rev 576
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		16
17	/*-----------------------------------------------------------------------------	17	/*-----------------------------------------------------------------------------
18	* Includes	18	* Includes
19	---------------------------------------------------------------------------/	19	---------------------------------------------------------------------------/
20	/* system files */	20	/* system files */
21	#include <avr/io.h>	21	#include <avr/io.h>
22	#include <avr/interrupt.h>	22	#include <avr/interrupt.h>
23	#include <stdio.h>	23	#include <stdio.h>
-		24	#include <string.h>
24	/* lib files */	25	/* lib files */
-		26	#include "../config.inc"
25	#include <config.h>	27	#include <config.h>
26	#include <bios.h>	28	#include <bios.h>
27	#include <drivers/timer/timebase.h>	29	#include <drivers/timer/timebase.h>
28	#include <drivers/sensor/tc1047/tc1047.h>	30	#include <drivers/sensor/tc1047/tc1047.h>
29		31
30	//#include "settings.h" //Migrated to config.inc	-
31		32
32	/* defines */	33	/* defines */
33	#define RELAY_OFF 0x01	34	#define RELAY_OFF 0x01
34	#define RELAY_ON 0x02	35	#define RELAY_ON 0x02
35	#define FAILSAFE_MODE 0x0F	36	#define FAILSAFE_MODE 0x0F
36	#define FAILSAFE_TRESHOLD 0xFF /* Degrees when nodeRelay goes into failsafe mode */	37	#define FAILSAFE_TRESHOLD 0xFF /* Degrees when nodeRelay goes into failsafe mode */
37		38
38	#define RELAY_CMD_ON 0x01	39	#define RELAY_CMD_ON 0x01
39	#define RELAY_CMD_OFF 0x02	40	#define RELAY_CMD_OFF 0x02
40	#define RELAY_CMD_TOGGLE 0x03	41	#define RELAY_CMD_TOGGLE 0x03
41	#define RELAY_CMD_STATUS 0x04	42	#define RELAY_CMD_STATUS 0x04
42	#define RELAY_CMD_RESET 0x05	43	#define RELAY_CMD_RESET 0x05
43	#define STATUS_SEND_PERIOD 10000UL /* milliseconds */	44	#define STATUS_SEND_PERIOD 10000UL /* milliseconds */
44	#define FAILSAFE_SEND_PERIOD 10000UL /* milliseconds */	45	#define FAILSAFE_SEND_PERIOD 10000UL /* 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	#define APP_TYPE CAN_APPTYPES_RELAY	50	#define APP_TYPE CAN_APPTYPES_RELAY
50	#define APP_VERSION 0x0001	51	#define APP_VERSION 0x0001
51		52
52	/*-------------------------------------------------------------------------	53	/*-------------------------------------------------------------------------
53	* Global variables	54	* Global variables
54	* -----------------------------------------------------------------------*/	55	* -----------------------------------------------------------------------*/
55	uint8_t relayStatus, failsafe_flag = 0;	56	uint8_t relayStatus, failsafe_flag = 0;
56	uint32_t boardTemperature = 0;	57	uint32_t boardTemperature = 0;
57		58
58	volatile Can_Message_t rxMsg; // Message storage	59	volatile Can_Message_t rxMsg; // Message storage
59	volatile uint8_t rxMsgFull; // Synchronization flag	60	volatile uint8_t rxMsgFull; // Synchronization flag
60		61
61		62
62	/*----------------------------------------------------------------------------	63	/*----------------------------------------------------------------------------
63	* Functions	64	* Functions
64	* -------------------------------------------------------------------------*/	65	* -------------------------------------------------------------------------*/
65	uint8_t relayOff(void);	66	uint8_t relayOff(void);
66	uint8_t relayOn(void);	67	uint8_t relayOn(void);
67	void relayFailsafe(void);	68	void relayFailsafe(void);
68	void sendStatus(void);	69	void sendStatus(void);
69		70
70	void can_receive(Can_Message_t *msg)	71	void can_receive(Can_Message_t *msg)
71	{ // CAN callback function	72	{ // CAN callback function
72	if (!rxMsgFull) {	73	if (!rxMsgFull) {
73	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));	74	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
74	rxMsgFull = 1;	75	rxMsgFull = 1;
75	}	76	}
76	}	77	}
77		78
78	/*----------------------------------------------------------------------------	79	/*----------------------------------------------------------------------------
79	* Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder	80	* Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder
80	* -------------------------------------------------------------------------*/	81	* -------------------------------------------------------------------------*/
81	#if TWO_BUTTON_MODE	82	#if TWO_BUTTON_MODE
82	ISR( PCINT2_vect )	83	ISR( PCINT2_vect )
83	{	84	{
84		85
85	}	86	}
86	#endif	87	#endif
87		88
88	/*-----------------------------------------------------------------------------	89	/*-----------------------------------------------------------------------------
89	* Main Program	90	* Main Program
90	---------------------------------------------------------------------------/	91	---------------------------------------------------------------------------/
91	int main(void) {	92	int main(void) {
92		93
93	uint32_t timeStamp = Timebase_CurrentTime(), temp = timeStamp;	94	uint32_t timeStamp = Timebase_CurrentTime(), temp = timeStamp;
94		95
95	adcTemperatureInit();	96	adcTemperatureInit();
96		97
97	// Set up callback for CAN messages	98	// Set up callback for CAN messages
98	BIOS_CanCallback = &can_receive;	99	BIOS_CanCallback = &can_receive;
99		100
100	sei();	101	sei();
101		102
102	Timebase_Init();	103	Timebase_Init();
103		104
104	Can_Message_t txMsg;	105	Can_Message_t txMsg;
105	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);	106	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);
106	txMsg.DataLength = 4;	107	txMsg.DataLength = 4;
107	txMsg.RemoteFlag = 0;	108	txMsg.RemoteFlag = 0;
108	txMsg.ExtendedFlag = 1;	109	txMsg.ExtendedFlag = 1;
109	txMsg.Data.words[0] = APP_TYPE;	110	txMsg.Data.words[0] = APP_TYPE;
110	txMsg.Data.words[1] = APP_VERSION;	111	txMsg.Data.words[1] = APP_VERSION;
111	BIOS_CanSend(&txMsg);	112	BIOS_CanSend(&txMsg);
112		113
113	// Turn relay off	114	// Turn relay off
114	relayStatus = relayOff();	115	relayStatus = relayOff();
115		116
116	// Main loop	117	// Main loop
117	while (1) {	118	while (1) {
118		119
119	temp = Timebase_CurrentTime();	120	temp = Timebase_CurrentTime();
120	if( temp - timeStamp >= STATUS_SEND_PERIOD ){	121	if( temp - timeStamp >= STATUS_SEND_PERIOD ){
121	timeStamp = temp;	122	timeStamp = temp;
122	// Send relay status to CAN	123	// Send relay status to CAN
123	sendStatus();	124	sendStatus();
124	}	125	}
125		126
126	if (rxMsgFull) {	127	if (rxMsgFull) {
127	uint16_t acttype;	128	uint16_t acttype;
128	uint8_t relayid;	129	uint8_t relayid;
129		130
130	if ( ((rxMsg.Id & CAN_MASK_CLASS)>>CAN_SHIFT_CLASS) == CAN_ACT){	131	if ( ((rxMsg.Id & CAN_MASK_CLASS)>>CAN_SHIFT_CLASS) == CAN_ACT){
131	// Actuator package	132	// Actuator package
132	acttype =(uint16_t)((rxMsg.Id & CAN_MASK_ACT_TYPE) >> CAN_SHIFT_ACT_TYPE);	133	acttype =(uint16_t)((rxMsg.Id & CAN_MASK_ACT_TYPE) >> CAN_SHIFT_ACT_TYPE);
133	relayid = (uint8_t)((rxMsg.Id & CAN_MASK_ACT_ID) >> CAN_SHIFT_ACT_ID);	134	relayid = (uint8_t)((rxMsg.Id & CAN_MASK_ACT_ID) >> CAN_SHIFT_ACT_ID);
134		135
135	if ((acttype == ACT_TYPE_RELAY) && (relayid == THISRELAYID)) {	136	if ((acttype == ACT_TYPE_RELAY) && (relayid == THISRELAYID)) {
136	// This is a message for this relay	137	// This is a message for this relay
137	if (rxMsg.Data.bytes[0] == RELAY_CMD_RESET) {	138	if (rxMsg.Data.bytes[0] == RELAY_CMD_RESET) {
138	// Return to normal operation	139	// Return to normal operation
139	failsafe_flag = 0;	140	failsafe_flag = 0;
140	}	141	}
141		142
142	if (!failsafe_flag) {	143	if (!failsafe_flag) {
143	if (rxMsg.Data.bytes[0] == RELAY_CMD_ON ){	144	if (rxMsg.Data.bytes[0] == RELAY_CMD_ON ){
144	// Turn relay on	145	// Turn relay on
145	relayStatus = relayOn();	146	relayStatus = relayOn();
146		147
147	} else if (rxMsg.Data.bytes[0] == RELAY_CMD_OFF ){	148	} else if (rxMsg.Data.bytes[0] == RELAY_CMD_OFF ){
148	// Turn relay off	149	// Turn relay off
149	relayStatus = relayOff();	150	relayStatus = relayOff();
150		151
151	} else if (rxMsg.Data.bytes[0] == RELAY_CMD_TOGGLE ){	152	} else if (rxMsg.Data.bytes[0] == RELAY_CMD_TOGGLE ){
152	// Toggle relay	153	// Toggle relay
153	if(relayStatus == RELAY_OFF){	154	if(relayStatus == RELAY_OFF){
154	relayStatus = relayOn();	155	relayStatus = relayOn();
155	}else{	156	}else{
156	relayStatus = relayOff();	157	relayStatus = relayOff();
157	}	158	}
158		159
159	}else if(rxMsg.Data.bytes[0] == RELAY_CMD_STATUS ){	160	}else if(rxMsg.Data.bytes[0] == RELAY_CMD_STATUS ){
160	// Send relay status to CAN	161	// Send relay status to CAN
161	sendStatus();	162	sendStatus();
162	}	163	}
163	}	164	}
164	}	165	}
165	}	166	}
166	rxMsgFull = 0; //	167	rxMsgFull = 0; //
167		168
168	}	169	}
169		170
170	}	171	}
171	return 0;	172	return 0;
172	}	173	}
173		174
174	uint8_t relayOff()	175	uint8_t relayOff()
175	{	176	{
176	// Turn off relay	177	// Turn off relay
177	PORTC &= ~(1<<PC1);	178	PORTC &= ~(1<<PC1);
178	DDRC \|= (1<<DDC1);	179	DDRC \|= (1<<DDC1);
179		180
180	return RELAY_OFF;	181	return RELAY_OFF;
181	}	182	}
182		183
183	uint8_t relayOn()	184	uint8_t relayOn()
184	{	185	{
185	// Turn on relay	186	// Turn on relay
186	DDRC &= ~(1<<DDC1);	187	DDRC &= ~(1<<DDC1);
187	PORTC \|= (1<<PC1);	188	PORTC \|= (1<<PC1);
188		189
189	return RELAY_ON;	190	return RELAY_ON;
190	}	191	}
191		192
192	void relayFailsafe()	193	void relayFailsafe()
193	{	194	{
194	uint32_t failsafe_timeStamp, temp;	195	uint32_t failsafe_timeStamp, temp;
195	relayStatus = relayOff();	196	relayStatus = relayOff();
196	failsafe_flag = 1;	197	failsafe_flag = 1;
197		198
198	while(1){	199	while(1){
199		200
200	if( !failsafe_flag ){	201	if( !failsafe_flag ){
201	// Return from failsafe mode	202	// Return from failsafe mode
202	return;	203	return;
203	}	204	}
204	// TODO skicka med period	205	// TODO skicka med period
205	sendStatus( );	206	sendStatus( );
206	}	207	}
207	}	208	}
208		209
209	void sendStatus()	210	void sendStatus()
210	{	211	{
211	uint32_t temperature;	212	uint32_t temperature;
212	Can_Message_t statusMsg;	213	Can_Message_t statusMsg;
213	statusMsg.RemoteFlag = 0;	214	statusMsg.RemoteFlag = 0;
214	statusMsg.ExtendedFlag = 1;	215	statusMsg.ExtendedFlag = 1;
215	statusMsg.DataLength = 4;	216	statusMsg.DataLength = 4;
216	statusMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_STATUS << CAN_SHIFT_SNS_TYPE) \| (SNS_ID_RELAY_STATUS << CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));	217	statusMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_STATUS << CAN_SHIFT_SNS_TYPE) \| (SNS_ID_RELAY_STATUS << CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));
217		218
218	temperature = getTC1047temperature();	219	temperature = getTC1047temperature();
219	if( (int32_t)temperature >= FAILSAFE_TRESHOLD && !failsafe_flag ){	220	if( (int32_t)temperature >= FAILSAFE_TRESHOLD && !failsafe_flag ){
220	// Goto failsafe mode	221	// Goto failsafe mode
221	relayFailsafe();	222	relayFailsafe();
222	}else{	223	}else{
223	// Transmitt node status	224	// Transmitt node status
224	statusMsg.Data.bytes[0] = temperature & 0x00FF;	225	statusMsg.Data.bytes[0] = temperature & 0x00FF;
225	statusMsg.Data.bytes[1] = (temperature & 0xFF00)>>8;	226	statusMsg.Data.bytes[1] = (temperature & 0xFF00)>>8;
226	statusMsg.Data.bytes[2] = relayStatus;	227	statusMsg.Data.bytes[2] = relayStatus;
227	statusMsg.Data.bytes[3] = failsafe_flag;	228	statusMsg.Data.bytes[3] = failsafe_flag;
228		229
229	BIOS_CanSend( &statusMsg );	230	BIOS_CanSend( &statusMsg );
230	}	231	}
231	}	232	}
232		233

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/application/Relay/main.c – Rev 563 → 576