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


/**
 
 
 * CAN Relay.
 *
 
 
 *
 * @date    2006-12-17
 * @author  Erik Larsson
 *
 *   Observera! Applikationen är helt otestad!
 *
 *   ADC=Vin*1024/Vref
 *   Vout=( 10 mV/C )( Temperature C ) + 500 mV
 *
 *  Transmitts: DATA: <temperature high byte> <temperature low byte> <relay status>
 *
 */
 
/*
 * For testing with ATmega88 PDIP enable this fetaure
 * Since PDIP doesn't have ADC7 it will use the ADC0 instead
 */
#define PDIP    0
 
/*-----------------------------------------------------------------------------
 * Includes
 *---------------------------------------------------------------------------*/
/* system files */
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <stdio.h>
/* lib files */
#include <can.h>
#include <serial.h>
#include <timebase.h>
/* defines */
#define OFF     0x00
#define ON      0x01
#define Vref    5
 
/*------------------------------------------------------------------------------
 * Read and send relay state (OPEN/CLOSED) and temperature
 * ---------------------------------------------------------------------------*/
void sendRelayStatus( Can_Message_t* msg, uint8_t state )
{
    int16_t temp;
 
    /* Start measureing */
    ADCSRA |= (1<<ADSC);
 
    /* Wait for conversion to complete */
    while( ADCSRA & (1<<ADSC) ){}
 
    msg->Id = 0x1201; // temporary ID
 
    msg->Data.bytes[0] = state;
 
    /* Convert voltage to temperature */
    temp = (ADCL & (ADCH<<8));
    temp = temp*Vref/1024;
    temp = (temp - 0.5)/(0.01);
 
    msg->Data.bytes[1]= temp;
    msg->Data.bytes[2]= (temp>>8);
    msg->DataLength = 3;
 
    Can_Send( &msg );
}
 
/*-----------------------------------------------------------------------------
 * Main Program
 *---------------------------------------------------------------------------*/
int main(void) {
 
    uint8_t relayStatus;
 
    Timebase_Init();
    Serial_Init();
    sei();
 
    /* Turn relay off */
    PORTC &= ~(1<<PC1);
    DDRC |= (1<<DDC1);
 
    relayStatus = OFF;
 
    /* Initiate ADC for reading temperature sensor */
 
    /* Wake up ADC */
    PRR &= ~(1<<PRADC);
#if PDIP
    /* Enable AREF and ADC0 (For PDIP package) */
    ADMUX = 0x00;
#else
    /* Enable AREF and ADC7 (For TQFP package) */
    ADMUX = 0x07;
#endif
 
    ADCSRA |= (1<<ADEN);
 
    printf("\n------------------------------------------------------------\n");
    printf(  "   CAN: Relay\n");
    printf(  "------------------------------------------------------------\n");
 
 
    printf("CanInit...");
    if (Can_Init() != CAN_OK) {
        printf("FAILED!\n");
    }else{
        printf("OK!\n");
    }
 
    uint32_t timeStamp = 0;
 
    Can_Message_t txMsg;
    Can_Message_t rxMsg;
    txMsg.Id = 0;
    txMsg.RemoteFlag = 0;
    txMsg.ExtendedFlag = 1;
 
 
    /* main loop */
    while (1) {
        /* service the CAN routines */
        Can_Service();
 
        /* check if any messages have been received */
        while (Can_Receive(&rxMsg) == CAN_OK) {
            /* This relay is adressed*/
            if( rxMsg.Id == 0x1200 ){
 
                if( rxMsg.Data.bytes[0] == 0x01 ){
                    /* Turn relay on */
 
                    /* Set as input and enable pull-up */
                    DDRC &= ~(1<<DDC1);
                    PORTC |= (1<<PC1);
 
                    relayStatus = ON;
 
                }else if(rxMsg.Data.bytes[0] == 0x02){
                    /* Turn relay off */
 
                    PORTC &= ~(1<<PC1);
                    DDRC |= (1<<DDC1);
 
                    relayStatus = OFF;
 
                }else if(rxMsg.Data.bytes[0] == 0x03){
                    /* Toggle relay */
 
                    if(relayStatus == ON){
                        PORTC &= ~(1<<PC1);
                        DDRC |= (1<<DDC1);
 
                        relayStatus = OFF;
 
                    }else{
                        DDRC &= ~(1<<DDC1);
                        PORTC |= (1<<PC1);
 
                        relayStatus = ON;
                    }
 
                }else if(rxMsg.Data.bytes[0] == 0x04){
                    /* Get relay status (ON/OFF?, temperature) */
                    sendRelayStatus( &txMsg, relayStatus );
                }
            }
        }
 
        // TODO
        // ska status på relä och temperatur skickas periodiskt?
        // tätare intervall om temperaturen kommer över en viss gräns?
 
        if( Timebase_PassedTimeMillis(timeStamp) >=5000){
            timeStamp = Timebase_CurrentTime();
            /* Get relay status (ON/OFF?, temperature) and send */
 
             sendRelayStatus( &txMsg, relayStatus );
        }
    }
    return 0;
}
 
 

Rev 176	Rev 177
1	/**	1	/**
2	* CAN Test. This program sends a CAN message once every second. The ID of the	-
3	* message is increased each time for testing purposes.	-
4	* ~~Added~~ ~~LCD output~~	2	* CAN Relay.
5	*	3	*
6	* @date 2006-11-21, LCD addition 2006-12-11	-
7	* @author Jimmy Myhrman, Erik Larsson	-
8	*	4	*
-		5	* @date 2006-12-17
-		6	* @author Erik Larsson
-		7	*
9	* Observera! Applikationen är helt ~~otestad~~	8	* Observera! Applikationen är helt otestad!
-		9	*
10	* ADC=Vin*1024/Vref	10	* ADC=Vin*1024/Vref
11	* Vout=( 10 mV/C )( Temperature C ) + 500 mV	11	* Vout=( 10 mV/C )( Temperature C ) + 500 mV
12	*	12	*
13	* Transmitts: DATA: <temperature high byte> <temperature low byte> <relay status>	13	* Transmitts: DATA: <temperature high byte> <temperature low byte> <relay status>
14	*	14	*
15	*/	15	*/
-		16
-		17	/*
-		18	* For testing with ATmega88 PDIP enable this fetaure
-		19	* Since PDIP doesn't have ADC7 it will use the ADC0 instead
-		20	*/
-		21	#define PDIP 0
16		22
17	/*-----------------------------------------------------------------------------	23	/*-----------------------------------------------------------------------------
18	* Includes	24	* Includes
19	---------------------------------------------------------------------------/	25	---------------------------------------------------------------------------/
20	/* system files */	26	/* system files */
21	#include <avr/io.h>	27	#include <avr/io.h>
22	#include <avr/interrupt.h>	28	#include <avr/interrupt.h>
23	#include <avr/wdt.h>	29	#include <avr/wdt.h>
24	#include <stdio.h>	30	#include <stdio.h>
25	/* lib files */	31	/* lib files */
26	#include <can.h>	32	#include <can.h>
27	#include <serial.h>	33	#include <serial.h>
28	#include <timebase.h>	34	#include <timebase.h>
29		35	/* defines */
30	#define OFF 0x00	36	#define OFF 0x00
31	#define ON 0x01	37	#define ON 0x01
32	#define Vref 5	38	#define Vref 5
33		39
34	/*------------------------------------------------------------------------------	40	/*------------------------------------------------------------------------------
35	* Read relay state (OPEN/CLOSED) and temperature	41	* Read and send relay state (OPEN/CLOSED) and temperature
36	* ---------------------------------------------------------------------------*/	42	* ---------------------------------------------------------------------------*/
37	void sendRelayStatus( Can_Message_t* msg, uint8_t state )	43	void sendRelayStatus( Can_Message_t* msg, uint8_t state )
38	{	44	{
39	int16_t temp;	45	int16_t temp;
40		46
41	/* Start measureing */	47	/* Start measureing */
42	ADCSRA \|= (1<<ADSC);	48	ADCSRA \|= (1<<ADSC);
43		49
44	/* Wait for conversion to complete */	50	/* Wait for conversion to complete */
45	while( ADCSRA & (1<<ADSC) ){}	51	while( ADCSRA & (1<<ADSC) ){}
46		52
47	msg->Id = 0x1201; // temporary ID	53	msg->Id = 0x1201; // temporary ID
48		54
49	msg->Data.bytes[0] = state;	55	msg->Data.bytes[0] = state;
50		56
51	/* Convert voltage to temperature */	57	/* Convert voltage to temperature */
52	temp = (ADCL & (ADCH<<8));	58	temp = (ADCL & (ADCH<<8));
53	temp = temp*Vref/1024;	59	temp = temp*Vref/1024;
54	temp = (temp - 0.5)/(0.01);	60	temp = (temp - 0.5)/(0.01);
55		61
56	msg->Data.bytes[1]= temp;	62	msg->Data.bytes[1]= temp;
57	msg->Data.bytes[2]= (temp>>8);	63	msg->Data.bytes[2]= (temp>>8);
58	msg->DataLength = 3;	64	msg->DataLength = 3;
59		65
60	Can_Send( &msg );	66	Can_Send( &msg );
61	}	67	}
62		68
63	/*-----------------------------------------------------------------------------	69	/*-----------------------------------------------------------------------------
64	* Main Program	70	* Main Program
65	---------------------------------------------------------------------------/	71	---------------------------------------------------------------------------/
66	int main(void) {	72	int main(void) {
67		73
68	uint8_t relayStatus;	74	uint8_t relayStatus;
69		75
70	Timebase_Init();	76	Timebase_Init();
71	Serial_Init();	77	Serial_Init();
72	sei();	78	sei();
73		79
74	/* Turn relay off */	80	/* Turn relay off */
75	PORTC &= ~(1<<PC1);	81	PORTC &= ~(1<<PC1);
76	DDRC \|= (1<<DDC1);	82	DDRC \|= (1<<DDC1);
77		83
78	relayStatus = OFF;	84	relayStatus = OFF;
79		85
80	/* Initiate ADC for reading temperature sensor */	86	/* Initiate ADC for reading temperature sensor */
81		87
82	/* Wake up ADC */	88	/* Wake up ADC */
83	PRR &= ~(1<<PRADC);	89	PRR &= ~(1<<PRADC);
-		90	#if PDIP
-		91	/* Enable AREF and ADC0 (For PDIP package) */
-		92	ADMUX = 0x00;
-		93	#else
84	/* Enable AREF and ADC7 */	94	/* Enable AREF and ADC7 (For TQFP package) */
85	ADMUX = 0x07;	95	ADMUX = 0x07;
-		96	#endif
-		97
86	ADCSRA \|= (1<<ADEN);	98	ADCSRA \|= (1<<ADEN);
87		99
88	printf("\n------------------------------------------------------------\n");	100	printf("\n------------------------------------------------------------\n");
89	printf( " CAN: Relay\n");	101	printf( " CAN: Relay\n");
90	printf( "------------------------------------------------------------\n");	102	printf( "------------------------------------------------------------\n");
91		103
92		104
93	printf("CanInit...");	105	printf("CanInit...");
94	if (Can_Init() != CAN_OK) {	106	if (Can_Init() != CAN_OK) {
95	printf("FAILED!\n");	107	printf("FAILED!\n");
96	}else{	108	}else{
97	printf("OK!\n");	109	printf("OK!\n");
98	}	110	}
99		111
100	uint32_t timeStamp = 0;	112	uint32_t timeStamp = 0;
101		113
102	Can_Message_t txMsg;	114	Can_Message_t txMsg;
103	Can_Message_t rxMsg;	115	Can_Message_t rxMsg;
104	txMsg.Id = 0;	116	txMsg.Id = 0;
105	txMsg.RemoteFlag = 0;	117	txMsg.RemoteFlag = 0;
106	txMsg.ExtendedFlag = 1;	118	txMsg.ExtendedFlag = 1;
107		119
108		120
109	/* main loop */	121	/* main loop */
110	while (1) {	122	while (1) {
111	/* service the CAN routines */	123	/* service the CAN routines */
112	Can_Service();	124	Can_Service();
113		125
114	/* check if any messages have been received */	126	/* check if any messages have been received */
115	while (Can_Receive(&rxMsg) == CAN_OK) {	127	while (Can_Receive(&rxMsg) == CAN_OK) {
116	/* This relay is adressed*/	128	/* This relay is adressed*/
117	if( rxMsg.Id == 0x1200 ){	129	if( rxMsg.Id == 0x1200 ){
118		130
119	if( rxMsg.Data.bytes[0] == 0x01 ){	131	if( rxMsg.Data.bytes[0] == 0x01 ){
120	/* Turn relay on */	132	/* Turn relay on */
121		133
122	/* Set as input and enable pull-up */	134	/* Set as input and enable pull-up */
123	DDRC &= ~(1<<DDC1);	135	DDRC &= ~(1<<DDC1);
124	PORTC \|= (1<<PC1);	136	PORTC \|= (1<<PC1);
125		137
126	relayStatus = ON;	138	relayStatus = ON;
127		139
128	}else if(rxMsg.Data.bytes[0] == 0x02){	140	}else if(rxMsg.Data.bytes[0] == 0x02){
129	/* Turn relay off */	141	/* Turn relay off */
130		142
131	PORTC &= ~(1<<PC1);	143	PORTC &= ~(1<<PC1);
132	DDRC \|= (1<<DDC1);	144	DDRC \|= (1<<DDC1);
133		145
134	relayStatus = OFF;	146	relayStatus = OFF;
135		147
136	}else if(rxMsg.Data.bytes[0] == 0x03){	148	}else if(rxMsg.Data.bytes[0] == 0x03){
137	/* Toggle relay */	149	/* Toggle relay */
138		150
139	if(relayStatus == ON){	151	if(relayStatus == ON){
140	PORTC &= ~(1<<PC1);	152	PORTC &= ~(1<<PC1);
141	DDRC \|= (1<<DDC1);	153	DDRC \|= (1<<DDC1);
142		154
143	relayStatus = OFF;	155	relayStatus = OFF;
144		156
145	}else{	157	}else{
146	DDRC &= ~(1<<DDC1);	158	DDRC &= ~(1<<DDC1);
147	PORTC \|= (1<<PC1);	159	PORTC \|= (1<<PC1);
148		160
149	relayStatus = ON;	161	relayStatus = ON;
150	}	162	}
151		163
152	}else if(rxMsg.Data.bytes[0] == 0x04){	164	}else if(rxMsg.Data.bytes[0] == 0x04){
153	/* Get relay status (ON/OFF?, temperature) */	165	/* Get relay status (ON/OFF?, temperature) */
154	sendRelayStatus( &txMsg, relayStatus );	166	sendRelayStatus( &txMsg, relayStatus );
155	}	167	}
156	}	168	}
157	}	169	}
158		170
159	// TODO	171	// TODO
160	// ska status på relä och temperatur skickas periodiskt?	172	// ska status på relä och temperatur skickas periodiskt?
161	// tätare intervall om temperaturen kommer över en viss gräns?	173	// tätare intervall om temperaturen kommer över en viss gräns?
162		174
163	if( Timebase_PassedTimeMillis(timeStamp) >=5000){	175	if( Timebase_PassedTimeMillis(timeStamp) >=5000){
164	timeStamp = Timebase_CurrentTime();	176	timeStamp = Timebase_CurrentTime();
165	/* Get relay status (ON/OFF?, temperature) */	177	/* Get relay status (ON/OFF?, temperature) and send */
166		178
167	sendRelayStatus( &txMsg, relayStatus );	179	sendRelayStatus( &txMsg, relayStatus );
168	}	180	}
169	}	181	}
170	return 0;	182	return 0;
171	}	183	}
172		184
173		185

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/CanRelay/main.c @ 181 – Rev 176 → 177