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/timer/timebase.h>
#include <drivers/ir/transceiver/irtransceiver.h>
#include <drivers/ir/protocols.h>
 
#define APP_TYPE    CAN_APPTYPES_IRRECEIVER
#define APP_VERSION 0x0004
 
#define STATE_IDLE          0
#define STATE_IR_REPEAT     1
#define STATE_START_RECEIVE 2
#define STATE_RECEIVING     3
#define STATE_START_PAUSE   4
#define STATE_PAUSING       5
#define STATE_START_IDLE    6
 
#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;
    }
}
 
#if (SEND_DEBUG)
void send_debug(uint16_t *buffer, uint8_t len) {
    Can_Message_t txMsg;
   
    /* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
    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));
    for (uint8_t i = 0; i < len>>2; i++) {
        uint8_t index = i<<2;
        txMsg.Data.bytes[0] = (buffer[index]>>8)&0xff;
        txMsg.Data.bytes[1] = (buffer[index]>>0)&0xff;
        txMsg.Data.bytes[2] = (buffer[index+1]>>8)&0xff;
        txMsg.Data.bytes[3] = (buffer[index+1]>>0)&0xff;
        txMsg.Data.bytes[4] = (buffer[index+2]>>8)&0xff;
        txMsg.Data.bytes[5] = (buffer[index+2]>>0)&0xff;
        txMsg.Data.bytes[6] = (buffer[index+3]>>8)&0xff;
        txMsg.Data.bytes[7] = (buffer[index+3]>>0)&0xff;
       
        /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
        while (BIOS_CanSend(&txMsg) != CAN_OK) {}
 
 
 
 
 
 
 
 
    }
   
    uint8_t lastpacketcnt = len&0x03;
    if (lastpacketcnt > 0) {
        txMsg.DataLength = lastpacketcnt<<1;
        for (uint8_t i = 0; i < lastpacketcnt; i++) {
            txMsg.Data.bytes[i<<1] = (buffer[(len&0xfc)|i]>>8)&0xff;
            txMsg.Data.bytes[(i<<1)+1] = (buffer[(len&0xfc)|i]>>0)&0xff;
        }
        /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
        while (BIOS_CanSend(&txMsg) != CAN_OK) {}
        //BIOS_CanSend(&txMsg);
    }
 
}
#endif
 
int main(void)
{
    // Enable interrupts as early as possible
    sei();
   
    Timebase_Init();
    IrTransceiver_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);
   
    uint32_t time = Timebase_CurrentTime();
    uint32_t timePauseStarted = 0;
   
    uint8_t state = STATE_IDLE;
   
    Ir_Protocol_Data_t proto;
    proto.timeout=0; proto.data=0; proto.repeats=0; proto.protocol=0;
    uint8_t len=0;
    uint16_t rxbuffer[MAX_NR_TIMES];
   
    while (1) {
        if (state == STATE_IDLE) {
            IrTransceiver_Receive_Start(rxbuffer);
            state = STATE_START_RECEIVE;
        } else if (state == STATE_START_RECEIVE) {
            state = STATE_RECEIVING;
        } else if (state == STATE_RECEIVING) {
            uint8_t res = IrTransceiver_Receive_Poll(&len);
            if ((res == IR_OK) && (len > 0)) {
                //låt protocols parsa och skicka på can
                uint8_t res2 = parseProtocol(rxbuffer, len, &proto);
                if (res2 == IR_OK && proto.protocol != IR_PROTO_UNKNOWN) {
                    txMsg.Data.bytes[0] = IR_BUTTON_DOWN;
                    txMsg.Data.bytes[1] = proto.protocol;
                    txMsg.Data.bytes[2] = (proto.data>>24)&0xff;
                    txMsg.Data.bytes[3] = (proto.data>>16)&0xff;
                    txMsg.Data.bytes[4] = (proto.data>>8)&0xff;
                    txMsg.Data.bytes[5] = proto.data&0xff;
                    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 = 6;
                    BIOS_CanSend(&txMsg);
                } else if (proto.protocol == IR_PROTO_UNKNOWN) {
#if (SEND_DEBUG)
                        send_debug(rxbuffer, len);
                        proto.timeout=300;
#endif
                   
                }
               
                state = STATE_START_PAUSE;
            }
        } else if (state == STATE_START_PAUSE) {
            IrTransceiver_Receive_Start(rxbuffer);
            timePauseStarted = Timebase_CurrentTime();
            state = STATE_PAUSING;
        } else if (state == STATE_PAUSING) {
            //resetta timebase-var om ir finns
            uint8_t res = IrTransceiver_Receive_Poll(&len);
            if (res == IR_NOT_FINISHED || res == IR_OK) {
                timePauseStarted = Timebase_CurrentTime();
            }
            if (res == IR_OK) {
                /* start a new reception */
                IrTransceiver_Receive_Start(rxbuffer);
            }
           
            time = Timebase_CurrentTime();
            if (time - timePauseStarted >= proto.timeout) {
                state = STATE_START_IDLE;
            }
        } else if (state == STATE_START_IDLE) {
            if (proto.protocol != IR_PROTO_UNKNOWN) {
                //skicka på can
                txMsg.Data.bytes[0] = IR_BUTTON_UP;
                BIOS_CanSend(&txMsg);
            }
            state = STATE_IDLE;
        }
       
       
       
        if (rxMsgFull) {
            /* No message reception functionality implemented */
            /* Flush the received message */
            rxMsgFull = 0; //  
        }
    }
    return 0;
}
 

Rev 616	Rev 1044
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		7
8	#include <drivers/timer/timebase.h>	8	#include <drivers/timer/timebase.h>
9	#include <drivers/ir/transceiver/irtransceiver.h>	9	#include <drivers/ir/transceiver/irtransceiver.h>
10	#include <drivers/ir/protocols.h>	10	#include <drivers/ir/protocols.h>
11		11
12	#define APP_TYPE CAN_APPTYPES_IRRECEIVER	12	#define APP_TYPE CAN_APPTYPES_IRRECEIVER
13	#define APP_VERSION 0x0004	13	#define APP_VERSION 0x0004
14		14
15	#define STATE_IDLE 0	15	#define STATE_IDLE 0
16	#define STATE_IR_REPEAT 1	16	#define STATE_IR_REPEAT 1
17	#define STATE_START_RECEIVE 2	17	#define STATE_START_RECEIVE 2
18	#define STATE_RECEIVING 3	18	#define STATE_RECEIVING 3
19	#define STATE_START_PAUSE 4	19	#define STATE_START_PAUSE 4
20	#define STATE_PAUSING 5	20	#define STATE_PAUSING 5
21	#define STATE_START_IDLE 6	21	#define STATE_START_IDLE 6
22		22
23	#define IR_ID_DATA 0	23	#define IR_ID_DATA 0
24	#define IR_ID_RAW 1	24	#define IR_ID_RAW 1
25	#define IR_ID_DEBUG 10	25	#define IR_ID_DEBUG 10
26		26
27	// A simple message "queue", with space for one message only.	27	// A simple message "queue", with space for one message only.
28	// These are declared volatile to tell the compiler not to optimize away accesses.	28	// These are declared volatile to tell the compiler not to optimize away accesses.
29	volatile Can_Message_t rxMsg; // Message storage	29	volatile Can_Message_t rxMsg; // Message storage
30	volatile uint8_t rxMsgFull; // Synchronization flag	30	volatile uint8_t rxMsgFull; // Synchronization flag
31		31
32	// CAN message reception callback.	32	// CAN message reception callback.
33	// This function runs with interrupts disabled, keep it as short as possible.	33	// This function runs with interrupts disabled, keep it as short as possible.
34	void can_receive(Can_Message_t *msg) {	34	void can_receive(Can_Message_t *msg) {
35	if (!rxMsgFull) {	35	if (!rxMsgFull) {
36	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));	36	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
37	rxMsgFull = 1;	37	rxMsgFull = 1;
38	}	38	}
39	}	39	}
40		40
41	#if (SEND_DEBUG)	41	#if (SEND_DEBUG)
42	void send_debug(uint16_t *buffer, uint8_t len) {	42	void send_debug(uint16_t *buffer, uint8_t len) {
43	Can_Message_t txMsg;	43	Can_Message_t txMsg;
44		44
45	/* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */	45	/* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
46	txMsg.DataLength = 8;	46	txMsg.DataLength = 8;
47	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));	47	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));
48	for (uint8_t i = 0; i < len>>2; i++) {	48	for (uint8_t i = 0; i < len>>2; i++) {
49	uint8_t index = i<<2;	49	uint8_t index = i<<2;
50	txMsg.Data.bytes[0] = (buffer[index]>>8)&0xff;	50	txMsg.Data.bytes[0] = (buffer[index]>>8)&0xff;
51	txMsg.Data.bytes[1] = (buffer[index]>>0)&0xff;	51	txMsg.Data.bytes[1] = (buffer[index]>>0)&0xff;
52	txMsg.Data.bytes[2] = (buffer[index+1]>>8)&0xff;	52	txMsg.Data.bytes[2] = (buffer[index+1]>>8)&0xff;
53	txMsg.Data.bytes[3] = (buffer[index+1]>>0)&0xff;	53	txMsg.Data.bytes[3] = (buffer[index+1]>>0)&0xff;
54	txMsg.Data.bytes[4] = (buffer[index+2]>>8)&0xff;	54	txMsg.Data.bytes[4] = (buffer[index+2]>>8)&0xff;
55	txMsg.Data.bytes[5] = (buffer[index+2]>>0)&0xff;	55	txMsg.Data.bytes[5] = (buffer[index+2]>>0)&0xff;
56	txMsg.Data.bytes[6] = (buffer[index+3]>>8)&0xff;	56	txMsg.Data.bytes[6] = (buffer[index+3]>>8)&0xff;
57	txMsg.Data.bytes[7] = (buffer[index+3]>>0)&0xff;	57	txMsg.Data.bytes[7] = (buffer[index+3]>>0)&0xff;
58		58
59	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */	59	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */
60	//while (BIOS_CanSend(&txMsg) != CAN_OK) {}	60	while (BIOS_CanSend(&txMsg) != CAN_OK) {}
61	BIOS_CanSend(&txMsg);	-
62		-
63	uint16_t dummycnt = 1;	-
64	while (dummycnt > 0) {	-
65	dummycnt++;	-
66	asm("nop");	-
67	asm("nop");	-
68	}	-
69	}	61	}
70		62
71	uint8_t lastpacketcnt = len&0x03;	63	uint8_t lastpacketcnt = len&0x03;
72	if (lastpacketcnt > 0) {	64	if (lastpacketcnt > 0) {
73	txMsg.DataLength = lastpacketcnt<<1;	65	txMsg.DataLength = lastpacketcnt<<1;
74	for (uint8_t i = 0; i < lastpacketcnt; i++) {	66	for (uint8_t i = 0; i < lastpacketcnt; i++) {
75	txMsg.Data.bytes[i<<1] = (buffer[(len&0xfc)\|i]>>8)&0xff;	67	txMsg.Data.bytes[i<<1] = (buffer[(len&0xfc)\|i]>>8)&0xff;
76	txMsg.Data.bytes[(i<<1)+1] = (buffer[(len&0xfc)\|i]>>0)&0xff;	68	txMsg.Data.bytes[(i<<1)+1] = (buffer[(len&0xfc)\|i]>>0)&0xff;
77	}	69	}
78	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */	70	/* buffers will be filled when sending more than 2-3 messages, so retry until sent */
79	//while (BIOS_CanSend(&txMsg) != CAN_OK) {}	71	while (BIOS_CanSend(&txMsg) != CAN_OK) {}
80	BIOS_CanSend(&txMsg);	72	//BIOS_CanSend(&txMsg);
81	}	73	}
82		74
83	}	75	}
84	#endif	76	#endif
85		77
86	int main(void)	78	int main(void)
87	{	79	{
88	// Enable interrupts as early as possible	80	// Enable interrupts as early as possible
89	sei();	81	sei();
90		82
91	Timebase_Init();	83	Timebase_Init();
92	IrTransceiver_Init();	84	IrTransceiver_Init();
93		85
94	Can_Message_t txMsg;	86	Can_Message_t txMsg;
95	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);	87	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);
96	txMsg.DataLength = 4;	88	txMsg.DataLength = 4;
97	txMsg.RemoteFlag = 0;	89	txMsg.RemoteFlag = 0;
98	txMsg.ExtendedFlag = 1;	90	txMsg.ExtendedFlag = 1;
99	txMsg.Data.words[0] = APP_TYPE;	91	txMsg.Data.words[0] = APP_TYPE;
100	txMsg.Data.words[1] = APP_VERSION;	92	txMsg.Data.words[1] = APP_VERSION;
101		93
102	// Set up callback for CAN reception, this is optional if only sending is required.	94	// Set up callback for CAN reception, this is optional if only sending is required.
103	BIOS_CanCallback = &can_receive;	95	BIOS_CanCallback = &can_receive;
104	// Send CAN_NMT_APP_START	96	// Send CAN_NMT_APP_START
105	BIOS_CanSend(&txMsg);	97	BIOS_CanSend(&txMsg);
106		98
107	uint32_t time = Timebase_CurrentTime();	99	uint32_t time = Timebase_CurrentTime();
108	uint32_t timePauseStarted = 0;	100	uint32_t timePauseStarted = 0;
109		101
110	uint8_t state = STATE_IDLE;	102	uint8_t state = STATE_IDLE;
111		103
112	Ir_Protocol_Data_t proto;	104	Ir_Protocol_Data_t proto;
113	proto.timeout=0; proto.data=0; proto.repeats=0; proto.protocol=0;	105	proto.timeout=0; proto.data=0; proto.repeats=0; proto.protocol=0;
114	uint8_t len=0;	106	uint8_t len=0;
115	uint16_t rxbuffer[MAX_NR_TIMES];	107	uint16_t rxbuffer[MAX_NR_TIMES];
116		108
117	while (1) {	109	while (1) {
118	if (state == STATE_IDLE) {	110	if (state == STATE_IDLE) {
119	IrTransceiver_Receive_Start(rxbuffer);	111	IrTransceiver_Receive_Start(rxbuffer);
120	state = STATE_START_RECEIVE;	112	state = STATE_START_RECEIVE;
121	} else if (state == STATE_START_RECEIVE) {	113	} else if (state == STATE_START_RECEIVE) {
122	state = STATE_RECEIVING;	114	state = STATE_RECEIVING;
123	} else if (state == STATE_RECEIVING) {	115	} else if (state == STATE_RECEIVING) {
124	uint8_t res = IrTransceiver_Receive_Poll(&len);	116	uint8_t res = IrTransceiver_Receive_Poll(&len);
125	if ((res == IR_OK) && (len > 0)) {	117	if ((res == IR_OK) && (len > 0)) {
126	//låt protocols parsa och skicka på can	118	//låt protocols parsa och skicka på can
127	uint8_t res2 = parseProtocol(rxbuffer, len, &proto);	119	uint8_t res2 = parseProtocol(rxbuffer, len, &proto);
128	if (res2 == IR_OK && proto.protocol != IR_PROTO_UNKNOWN) {	120	if (res2 == IR_OK && proto.protocol != IR_PROTO_UNKNOWN) {
129	txMsg.Data.bytes[0] = IR_BUTTON_DOWN;	121	txMsg.Data.bytes[0] = IR_BUTTON_DOWN;
130	txMsg.Data.bytes[1] = proto.protocol;	122	txMsg.Data.bytes[1] = proto.protocol;
131	txMsg.Data.bytes[2] = (proto.data>>24)&0xff;	123	txMsg.Data.bytes[2] = (proto.data>>24)&0xff;
132	txMsg.Data.bytes[3] = (proto.data>>16)&0xff;	124	txMsg.Data.bytes[3] = (proto.data>>16)&0xff;
133	txMsg.Data.bytes[4] = (proto.data>>8)&0xff;	125	txMsg.Data.bytes[4] = (proto.data>>8)&0xff;
134	txMsg.Data.bytes[5] = proto.data&0xff;	126	txMsg.Data.bytes[5] = proto.data&0xff;
135	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));	127	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));
136	txMsg.DataLength = 6;	128	txMsg.DataLength = 6;
137	BIOS_CanSend(&txMsg);	129	BIOS_CanSend(&txMsg);
138	} else if (proto.protocol == IR_PROTO_UNKNOWN) {	130	} else if (proto.protocol == IR_PROTO_UNKNOWN) {
139	#if (SEND_DEBUG)	131	#if (SEND_DEBUG)
140	send_debug(rxbuffer, len);	132	send_debug(rxbuffer, len);
141	proto.timeout=300;	133	proto.timeout=300;
142	#endif	134	#endif
143		135
144	}	136	}
145		137
146	state = STATE_START_PAUSE;	138	state = STATE_START_PAUSE;
147	}	139	}
148	} else if (state == STATE_START_PAUSE) {	140	} else if (state == STATE_START_PAUSE) {
149	IrTransceiver_Receive_Start(rxbuffer);	141	IrTransceiver_Receive_Start(rxbuffer);
150	timePauseStarted = Timebase_CurrentTime();	142	timePauseStarted = Timebase_CurrentTime();
151	state = STATE_PAUSING;	143	state = STATE_PAUSING;
152	} else if (state == STATE_PAUSING) {	144	} else if (state == STATE_PAUSING) {
153	//resetta timebase-var om ir finns	145	//resetta timebase-var om ir finns
154	uint8_t res = IrTransceiver_Receive_Poll(&len);	146	uint8_t res = IrTransceiver_Receive_Poll(&len);
155	if (res == IR_NOT_FINISHED \|\| res == IR_OK) {	147	if (res == IR_NOT_FINISHED \|\| res == IR_OK) {
156	timePauseStarted = Timebase_CurrentTime();	148	timePauseStarted = Timebase_CurrentTime();
157	}	149	}
158	if (res == IR_OK) {	150	if (res == IR_OK) {
159	/* start a new reception */	151	/* start a new reception */
160	IrTransceiver_Receive_Start(rxbuffer);	152	IrTransceiver_Receive_Start(rxbuffer);
161	}	153	}
162		154
163	time = Timebase_CurrentTime();	155	time = Timebase_CurrentTime();
164	if (time - timePauseStarted >= proto.timeout) {	156	if (time - timePauseStarted >= proto.timeout) {
165	state = STATE_START_IDLE;	157	state = STATE_START_IDLE;
166	}	158	}
167	} else if (state == STATE_START_IDLE) {	159	} else if (state == STATE_START_IDLE) {
168	if (proto.protocol != IR_PROTO_UNKNOWN) {	160	if (proto.protocol != IR_PROTO_UNKNOWN) {
169	//skicka på can	161	//skicka på can
170	txMsg.Data.bytes[0] = IR_BUTTON_UP;	162	txMsg.Data.bytes[0] = IR_BUTTON_UP;
171	BIOS_CanSend(&txMsg);	163	BIOS_CanSend(&txMsg);
172	}	164	}
173	state = STATE_IDLE;	165	state = STATE_IDLE;
174	}	166	}
175		167
176		168
177		169
178	if (rxMsgFull) {	170	if (rxMsgFull) {
179	/* No message reception functionality implemented */	171	/* No message reception functionality implemented */
180	/* Flush the received message */	172	/* Flush the received message */
181	rxMsgFull = 0; //	173	rxMsgFull = 0; //
182	}	174	}
183	}	175	}
184	return 0;	176	return 0;
185	}	177	}
186		178

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/application/IrReceive/main.c @ 1663 – Rev 616 → 1044