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

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/application/Relay/main.c – Rev 493 → 498