WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/application/IrReceive/main.c


#include <inttypes.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <string.h>
#include <config.h> // All configuration parameters
#include <bios.h>   // BIOS interface declarations, including CAN structure and ID defines.
//#include <drivers/uart/serial.h>
#include <drivers/timer/timebase.h>
#include <drivers/ir/receiver/irreceiver.h>
 
#define APP_TYPE    CAN_APPTYPES_IRRECEIVER
#define APP_VERSION 0x0003
 
#define STATE_IDLE      0
#define STATE_IR_REPEAT 1
 
#define IR_ID_DATA  0
#define IR_ID_RAW   1
#define IR_ID_DEBUG 10
 
// A simple message "queue", with space for one message only.
// These are declared volatile to tell the compiler not to optimize away accesses.
volatile Can_Message_t rxMsg; // Message storage
volatile uint8_t rxMsgFull;   // Synchronization flag
 
// CAN message reception callback.
// This function runs with interrupts disabled, keep it as short as possible.
void can_receive(Can_Message_t *msg) {
    if (!rxMsgFull) {
        memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
        rxMsgFull = 1;
    }
}
 
int main(void)
{
    // Enable interrupts as early as possible
    sei();
   
    Timebase_Init();
    //Serial_Init();
    IrReceive_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;
   
    // Set up callback for CAN reception, this is optional if only sending is required.
    BIOS_CanCallback = &can_receive;
    // Send CAN_NMT_APP_START
    BIOS_CanSend(&txMsg);
 
    //txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) | (IR_ID_DATA<<CAN_SHIFT_SNS_ID) | (NODE_ID << CAN_SHIFT_SNS_SID));
   
    unsigned long time = Timebase_CurrentTime();
    unsigned long irTimeoutTime = 100;
   
    uint8_t ir_protocol, ir_address, ir_command;
    uint16_t ir_timeout;
    uint8_t state = STATE_IDLE;
 
    while (1) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        time = Timebase_CurrentTime();
       
        if (state == STATE_IDLE) {
            /* test for irdata */
            uint8_t returnval = IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout);
            if (returnval == IR_OK) {
                /* a protocol was found for irdata, send on can */
                txMsg.Data.bytes[0] = IR_BUTTON_DOWN;
                txMsg.Data.bytes[1] = ir_protocol;
                txMsg.Data.bytes[2] = ir_address;
                txMsg.Data.bytes[3] = ir_command;
                txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) | (IR_ID_DATA<<CAN_SHIFT_SNS_ID) | (NODE_ID << CAN_SHIFT_SNS_SID));
                txMsg.DataLength = 4;
                BIOS_CanSend(&txMsg);
               
                /* set up timeout */
                irTimeoutTime = Timebase_CurrentTime();
                state = STATE_IR_REPEAT;
               
            } else if (returnval == IR_NO_PROTOCOL) {
                /* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
                ir_protocol = IR_PROTO_UNKNOWN;     //used in STATE_IR_REPEATE, to know if to send a release
                txMsg.DataLength = 8;
                txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) | (IR_ID_RAW<<CAN_SHIFT_SNS_ID) | (NODE_ID << CAN_SHIFT_SNS_SID));
                uint8_t datacnt = getRawDataCnt();
                for (uint8_t i = 0; i < datacnt>>2; i++) {
                    uint8_t index = i<<2;
                    txMsg.Data.words[0] = getRawData(index);
                    txMsg.Data.words[1] = getRawData(index+1);
                    txMsg.Data.words[2] = getRawData(index+2);
                    txMsg.Data.words[3] = getRawData(index+3);
                   
                    /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
                    //while (BIOS_CanSend(&txMsg) != CAN_OK) {}
                    BIOS_CanSend(&txMsg);
                   
                    uint16_t dummycnt = 1;
                    while (dummycnt > 0) {
                        dummycnt++;
                        asm("nop");
                        asm("nop");
                    }
                }
               
                uint8_t lastpacketcnt = datacnt&0x03;
                if (lastpacketcnt > 0) {
                    txMsg.DataLength = lastpacketcnt<<1;
                    for (uint8_t i = 0; i < lastpacketcnt; i++) {
                        txMsg.Data.words[i] = getRawData((datacnt&0xfc)|i);
                    }
                    /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
                    //while (BIOS_CanSend(&txMsg) != CAN_OK) {}
                    BIOS_CanSend(&txMsg);
                }
 
                irTimeoutTime = Timebase_CurrentTime();
                state = STATE_IR_REPEAT;
                ir_timeout = 200;           /* Set a default timeout */
            } else if (returnval != IR_NO_DATA) {
                /* debug, send the returned message on errors (except for IR_NO_DATA-errors) */
                txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) | (IR_ID_DEBUG<<CAN_SHIFT_SNS_ID) | (NODE_ID << CAN_SHIFT_SNS_SID));
                txMsg.DataLength = 1;
                txMsg.Data.bytes[0] = returnval;
                BIOS_CanSend(&txMsg);
            }
 
        } else if (state == STATE_IR_REPEAT) {
            /* check for new ir-data, if no new data during the timout-time then set state to IDLE */
            if (time - irTimeoutTime >= ir_timeout) {      
                state = STATE_IDLE;
                /* if the protocol was known then send a release-message */
                if (ir_protocol != IR_PROTO_UNKNOWN) {
                    txMsg.Data.bytes[0] = IR_BUTTON_UP;
                    BIOS_CanSend(&txMsg);
                }
            }
            if (IrReceive_CheckIdle() == IR_OK) {
                irTimeoutTime = Timebase_CurrentTime();
            }
        }
 
 
 
       
        if (rxMsgFull) {
            /* No message reception functionality implemented */
           
            /* Flush the received message */
            rxMsgFull = 0; //  
        }
    }
   
    return 0;
}
 

Rev 528	Rev 549
1	#include <inttypes.h>	1	#include <inttypes.h>
2	#include <avr/interrupt.h>	2	#include <avr/interrupt.h>
3	#include <stdio.h>	3	#include <stdio.h>
4	#include <string.h>	4	#include <string.h>
5	#include <config.h> // All configuration parameters	5	#include <config.h> // All configuration parameters
6	#include <bios.h> // BIOS interface declarations, including CAN structure and ID defines.	6	#include <bios.h> // BIOS interface declarations, including CAN structure and ID defines.
7	//#include <drivers/uart/serial.h>	7	//#include <drivers/uart/serial.h>
8	#include <drivers/timer/timebase.h>	8	#include <drivers/timer/timebase.h>
9	#include <drivers/ir/receiver/irreceiver.h>	9	#include <drivers/ir/receiver/irreceiver.h>
10		10
11	#define APP_TYPE CAN_APPTYPES_IRRECEIVER	11	#define APP_TYPE CAN_APPTYPES_IRRECEIVER
12	#define APP_VERSION 0x0003	12	#define APP_VERSION 0x0003
13		13
14	#define STATE_IDLE 0	14	#define STATE_IDLE 0
15	#define STATE_IR_REPEAT 1	15	#define STATE_IR_REPEAT 1
16		16
17	#define IR_ID_DATA 0	17	#define IR_ID_DATA 0
18	#define IR_ID_RAW 1	18	#define IR_ID_RAW 1
19	#define IR_ID_DEBUG 10	19	#define IR_ID_DEBUG 10
20		20
21	// A simple message "queue", with space for one message only.	21	// A simple message "queue", with space for one message only.
22	// These are declared volatile to tell the compiler not to optimize away accesses.	22	// These are declared volatile to tell the compiler not to optimize away accesses.
23	volatile Can_Message_t rxMsg; // Message storage	23	volatile Can_Message_t rxMsg; // Message storage
24	volatile uint8_t rxMsgFull; // Synchronization flag	24	volatile uint8_t rxMsgFull; // Synchronization flag
25		25
26	// CAN message reception callback.	26	// CAN message reception callback.
27	// This function runs with interrupts disabled, keep it as short as possible.	27	// This function runs with interrupts disabled, keep it as short as possible.
28	void can_receive(Can_Message_t *msg) {	28	void can_receive(Can_Message_t *msg) {
29	if (!rxMsgFull) {	29	if (!rxMsgFull) {
30	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));	30	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
31	rxMsgFull = 1;	31	rxMsgFull = 1;
32	}	32	}
33	}	33	}
34		34
35	int main(void)	35	int main(void)
36	{	36	{
37	// Enable interrupts as early as possible	37	// Enable interrupts as early as possible
38	sei();	38	sei();
39		39
40	Timebase_Init();	40	Timebase_Init();
41	//Serial_Init();	41	//Serial_Init();
42	IrReceive_Init();	42	IrReceive_Init();
43		43
44	Can_Message_t txMsg;	44	Can_Message_t txMsg;
45	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);	45	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);
46	txMsg.DataLength = 4;	46	txMsg.DataLength = 4;
47	txMsg.RemoteFlag = 0;	47	txMsg.RemoteFlag = 0;
48	txMsg.ExtendedFlag = 1;	48	txMsg.ExtendedFlag = 1;
49	txMsg.Data.words[0] = APP_TYPE;	49	txMsg.Data.words[0] = APP_TYPE;
50	txMsg.Data.words[1] = APP_VERSION;	50	txMsg.Data.words[1] = APP_VERSION;
51		51
52	// Set up callback for CAN reception, this is optional if only sending is required.	52	// Set up callback for CAN reception, this is optional if only sending is required.
53	BIOS_CanCallback = &can_receive;	53	BIOS_CanCallback = &can_receive;
54	// Send CAN_NMT_APP_START	54	// Send CAN_NMT_APP_START
55	BIOS_CanSend(&txMsg);	55	BIOS_CanSend(&txMsg);
56		56
57	//txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DATA<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));	57	//txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DATA<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));
58		58
59	unsigned long time = Timebase_CurrentTime();	59	unsigned long time = Timebase_CurrentTime();
60	unsigned long irTimeoutTime = 100;	60	unsigned long irTimeoutTime = 100;
61		61
62	uint8_t ir_protocol, ir_address, ir_command;	62	uint8_t ir_protocol, ir_address, ir_command;
63	uint16_t ir_timeout;	63	uint16_t ir_timeout;
64	uint8_t state = STATE_IDLE;	64	uint8_t state = STATE_IDLE;
65		65
66	while (1) {	66	while (1) {
67	#if 0	-
68	time = Timebase_CurrentTime();	-
69	if (state == STATE_IDLE) {	-
70	if (IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout) == IR_OK) {	-
71	txMsg.Data.bytes[0] = 0x00;	-
72	txMsg.Data.bytes[1] = ir_protocol;	-
73	txMsg.Data.bytes[2] = ir_address;	-
74	txMsg.Data.bytes[3] = ir_command;	-
75	txMsg.DataLength = 4;	-
76	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DATA<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));	-
77	BIOS_CanSend(&txMsg);	-
78	irTimeoutTime = Timebase_CurrentTime();	-
79	state = STATE_IR_REPEAT;	-
80	}	-
81	} else if (state == STATE_IR_REPEAT) {	-
82	//kolla efter ny ir, om ingen ny ir och timeout så sätt state till IDLE	-
83	if (time - irTimeoutTime >= ir_timeout) {	-
84	state = STATE_IDLE;	-
85	txMsg.Data.bytes[0] = 0x0f;	-
86	BIOS_CanSend(&txMsg);	-
87	}	-
88	if (IrReceive_CheckIdle() == IR_OK) {	-
89	irTimeoutTime = Timebase_CurrentTime();	-
90	}	-
91	}	-
92	#endif	-
93		-
94	#if 1	-
95	time = Timebase_CurrentTime();	67	time = Timebase_CurrentTime();
96		68
97	if (state == STATE_IDLE) {	69	if (state == STATE_IDLE) {
98	/* test for irdata */	70	/* test for irdata */
99	uint8_t returnval = IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout);	71	uint8_t returnval = IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout);
100	if (returnval == IR_OK) {	72	if (returnval == IR_OK) {
101	/* a protocol was found for irdata, send on can */	73	/* a protocol was found for irdata, send on can */
102	txMsg.Data.bytes[0] = ~~0x00~~;	74	txMsg.Data.bytes[0] = IR_BUTTON_DOWN;
103	txMsg.Data.bytes[1] = ir_protocol;	75	txMsg.Data.bytes[1] = ir_protocol;
104	txMsg.Data.bytes[2] = ir_address;	76	txMsg.Data.bytes[2] = ir_address;
105	txMsg.Data.bytes[3] = ir_command;	77	txMsg.Data.bytes[3] = ir_command;
106	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DATA<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));	78	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DATA<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));
107	txMsg.DataLength = 4;	79	txMsg.DataLength = 4;
108	BIOS_CanSend(&txMsg);	80	BIOS_CanSend(&txMsg);
109		81
110	/* set up timeout */	82	/* set up timeout */
111	irTimeoutTime = Timebase_CurrentTime();	83	irTimeoutTime = Timebase_CurrentTime();
112	state = STATE_IR_REPEAT;	84	state = STATE_IR_REPEAT;
113		85
114	} else if (returnval == IR_NO_PROTOCOL) {	86	} else if (returnval == IR_NO_PROTOCOL) {
115	/* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */	87	/* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
116	ir_protocol = IR_PROTO_UNKNOWN; //used in STATE_IR_REPEATE, to know if to send a release	88	ir_protocol = IR_PROTO_UNKNOWN; //used in STATE_IR_REPEATE, to know if to send a release
117	txMsg.DataLength = 8;	89	txMsg.DataLength = 8;
118	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_RAW<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));	90	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_RAW<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));
119	uint8_t datacnt = getRawDataCnt();	91	uint8_t datacnt = getRawDataCnt();
120	for (uint8_t i = 0; i < datacnt>>2; i++) {	92	for (uint8_t i = 0; i < datacnt>>2; i++) {
121	uint8_t index = i<<2;	93	uint8_t index = i<<2;
122	txMsg.Data.words[0] = getRawData(index);	94	txMsg.Data.words[0] = getRawData(index);
123	txMsg.Data.words[1] = getRawData(index+1);	95	txMsg.Data.words[1] = getRawData(index+1);
124	txMsg.Data.words[2] = getRawData(index+2);	96	txMsg.Data.words[2] = getRawData(index+2);
125	txMsg.Data.words[3] = getRawData(index+3);	97	txMsg.Data.words[3] = getRawData(index+3);
126		98
127	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */	99	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */
128	//while (BIOS_CanSend(&txMsg) != CAN_OK) {}	100	//while (BIOS_CanSend(&txMsg) != CAN_OK) {}
129	BIOS_CanSend(&txMsg);	101	BIOS_CanSend(&txMsg);
130		102
131	uint16_t dummycnt = 1;	103	uint16_t dummycnt = 1;
132	while (dummycnt > 0) {	104	while (dummycnt > 0) {
133	dummycnt++;	105	dummycnt++;
134	asm("nop");	106	asm("nop");
135	asm("nop");	107	asm("nop");
136	}	108	}
137	}	109	}
138		110
139	uint8_t lastpacketcnt = datacnt&0x03;	111	uint8_t lastpacketcnt = datacnt&0x03;
140	if (lastpacketcnt > 0) {	112	if (lastpacketcnt > 0) {
141	txMsg.DataLength = lastpacketcnt<<1;	113	txMsg.DataLength = lastpacketcnt<<1;
142	for (uint8_t i = 0; i < lastpacketcnt; i++) {	114	for (uint8_t i = 0; i < lastpacketcnt; i++) {
143	txMsg.Data.words[i] = getRawData((datacnt&0xfc)\|i);	115	txMsg.Data.words[i] = getRawData((datacnt&0xfc)\|i);
144	}	116	}
145	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */	117	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */
146	//while (BIOS_CanSend(&txMsg) != CAN_OK) {}	118	//while (BIOS_CanSend(&txMsg) != CAN_OK) {}
147	BIOS_CanSend(&txMsg);	119	BIOS_CanSend(&txMsg);
148	}	120	}
149		121
150	irTimeoutTime = Timebase_CurrentTime();	122	irTimeoutTime = Timebase_CurrentTime();
151	state = STATE_IR_REPEAT;	123	state = STATE_IR_REPEAT;
152	ir_timeout = 200; /* Set a default timeout */	124	ir_timeout = 200; /* Set a default timeout */
153	} else if (returnval != IR_NO_DATA) {	125	} else if (returnval != IR_NO_DATA) {
154	/* debug, send the returned message on errors (except for IR_NO_DATA-errors) */	126	/* debug, send the returned message on errors (except for IR_NO_DATA-errors) */
155	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DEBUG<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));	127	txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) \| (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) \| (IR_ID_DEBUG<<CAN_SHIFT_SNS_ID) \| (NODE_ID << CAN_SHIFT_SNS_SID));
156	txMsg.DataLength = 1;	128	txMsg.DataLength = 1;
157	txMsg.Data.bytes[0] = returnval;	129	txMsg.Data.bytes[0] = returnval;
158	BIOS_CanSend(&txMsg);	130	BIOS_CanSend(&txMsg);
159	}	131	}
160		132
161	} else if (state == STATE_IR_REPEAT) {	133	} else if (state == STATE_IR_REPEAT) {
162	/* check for new ir-data, if no new data during the timout-time then set state to IDLE */	134	/* check for new ir-data, if no new data during the timout-time then set state to IDLE */
163	if (time - irTimeoutTime >= ir_timeout) {	135	if (time - irTimeoutTime >= ir_timeout) {
164	state = STATE_IDLE;	136	state = STATE_IDLE;
165	/* if the protocol was known then send a release-message */	137	/* if the protocol was known then send a release-message */
166	if (ir_protocol != IR_PROTO_UNKNOWN) {	138	if (ir_protocol != IR_PROTO_UNKNOWN) {
167	txMsg.Data.bytes[0] = ~~0x0f~~;	139	txMsg.Data.bytes[0] = IR_BUTTON_UP;
168	BIOS_CanSend(&txMsg);	140	BIOS_CanSend(&txMsg);
169	}	141	}
170	}	142	}
171	if (IrReceive_CheckIdle() == IR_OK) {	143	if (IrReceive_CheckIdle() == IR_OK) {
172	irTimeoutTime = Timebase_CurrentTime();	144	irTimeoutTime = Timebase_CurrentTime();
173	}	145	}
174	}	146	}
175		-
176	#endif	-
177		147
178		148
179	if (rxMsgFull) {	149	if (rxMsgFull) {
180	/* No message reception functionality implemented */	150	/* No message reception functionality implemented */
181		151
182	/* Flush the received message */	152	/* Flush the received message */
183	rxMsgFull = 0; //	153	rxMsgFull = 0; //
184	}	154	}
185	}	155	}
186		156
187	return 0;	157	return 0;
188	}	158	}
189		159

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/application/IrReceive/main.c @ 596 – Rev 528 → 549