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    0xf010
#define APP_VERSION 0x0001
 
#define CAN_IR 0x12
 
#define STATE_IDLE      0
#define STATE_IR_REPEAT 1
 
 
// 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();
   
    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_ID_SNS_IRDATA;   // ((CAN_SNS << CAN_SHIFT_CLASS) | (NODE_ID << CAN_SHIFT_SNS_SID))
   
    //printf("AVR Test Application\n");
    //printf("Using AVR BIOS version %x\n", BIOS_VERSION);
 
 
    //txMsg.Id = (CAN_SNS << CAN_SHIFT_CLASS) | ((CAN_IR & CAN_MASK_SNS_FUNCC) << CAN_SHIFT_SNS_FUNCC) | (NODE_ID << CAN_SHIFT_SNS_SID);
    //txMsg.Data.dwords[0] = 0x01020304;
    //txMsg.DataLength = 4;
 
    IRDDR &= ~(1<<IRBIT);
 
    unsigned long time = Timebase_CurrentTime();
    unsigned long irTimeoutTime;
   
    uint8_t ir_protocol, ir_address, ir_command;
    uint8_t state = STATE_IDLE;
 
    while (1) {
        time = Timebase_CurrentTime();
        if (state == STATE_IDLE) {
            if (checkIr(&ir_protocol, &ir_address, &ir_command) == IR_OK) {
                txMsg.Data.bytes[0] = 0x00;
                txMsg.Data.bytes[1] = ir_protocol;
                txMsg.Data.bytes[2] = ir_address;
                txMsg.Data.bytes[3] = ir_command;
                txMsg.DataLength = 4;
                BIOS_CanSend(&txMsg);
                irTimeoutTime = Timebase_CurrentTime();
                state = STATE_IR_REPEAT;
            }
        } else if (state == STATE_IR_REPEAT) {
            //kolla efter ny ir, om ingen ny ir och timeout så sätt state till IDLE
            if (time - irTimeoutTime >= 105) {      //getLastProtoTimeout()
                state = STATE_IDLE;
                txMsg.Data.bytes[0] = 0x0f;
                BIOS_CanSend(&txMsg);
            }
            if (checkIrIdle() == IR_OK) {       //funktion som borde finnas i irreceiver.c
                irTimeoutTime = Timebase_CurrentTime();
            }
        }
 
 
 
 
 
 
 
 
 
 
       
        if (rxMsgFull) {
            // Flush the received message
            rxMsgFull = 0; //  
        }
    }
   
    return 0;
}
 

Rev 403	Rev 439
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 0xf010	11	#define APP_TYPE 0xf010
12	#define APP_VERSION 0x0001	12	#define APP_VERSION 0x0001
13		13
14	#define CAN_IR 0x12;	14	#define CAN_IR 0x12
15		15
16	#define STATE_IDLE 0	16	#define STATE_IDLE 0
17	#define STATE_IR_REPEAT 1	17	#define STATE_IR_REPEAT 1
-		18
18		19
19	// A simple message "queue", with space for one message only.	20	// A simple message "queue", with space for one message only.
20	// These are declared volatile to tell the compiler not to optimize away accesses.	21	// These are declared volatile to tell the compiler not to optimize away accesses.
21	volatile Can_Message_t rxMsg; // Message storage	22	volatile Can_Message_t rxMsg; // Message storage
22	volatile uint8_t rxMsgFull; // Synchronization flag	23	volatile uint8_t rxMsgFull; // Synchronization flag
23		24
24	// CAN message reception callback.	25	// CAN message reception callback.
25	// This function runs with interrupts disabled, keep it as short as possible.	26	// This function runs with interrupts disabled, keep it as short as possible.
26	void can_receive(Can_Message_t *msg) {	27	void can_receive(Can_Message_t *msg) {
27	if (!rxMsgFull) {	28	if (!rxMsgFull) {
28	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));	29	memcpy((void*)&rxMsg, msg, sizeof(rxMsg));
29	rxMsgFull = 1;	30	rxMsgFull = 1;
30	}	31	}
31	}	32	}
32		33
33	int main(void)	34	int main(void)
34	{	35	{
35	// Enable interrupts as early as possible	36	// Enable interrupts as early as possible
36	sei();	37	sei();
37		38
38	Timebase_Init();	39	Timebase_Init();
39	//Serial_Init();	40	//Serial_Init();
40		41
41	Can_Message_t txMsg;	42	Can_Message_t txMsg;
42	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);	43	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) \| (NODE_ID << CAN_SHIFT_NMT_SID);
43	txMsg.DataLength = 4;	44	txMsg.DataLength = 4;
44	txMsg.RemoteFlag = 0;	45	txMsg.RemoteFlag = 0;
45	txMsg.ExtendedFlag = 1;	46	txMsg.ExtendedFlag = 1;
46	txMsg.Data.words[0] = APP_TYPE;	47	txMsg.Data.words[0] = APP_TYPE;
47	txMsg.Data.words[1] = APP_VERSION;	48	txMsg.Data.words[1] = APP_VERSION;
48		49
49	// Set up callback for CAN reception, this is optional if only sending is required.	50	// Set up callback for CAN reception, this is optional if only sending is required.
50	BIOS_CanCallback = &can_receive;	51	BIOS_CanCallback = &can_receive;
51	// Send CAN_NMT_APP_START	52	// Send CAN_NMT_APP_START
52	BIOS_CanSend(&txMsg);	53	BIOS_CanSend(&txMsg);
-		54
-		55	txMsg.Id = CAN_ID_SNS_IRDATA; // ((CAN_SNS << CAN_SHIFT_CLASS) \| (NODE_ID << CAN_SHIFT_SNS_SID))
53		56
54	//printf("AVR Test Application\n");	57	//printf("AVR Test Application\n");
55	//printf("Using AVR BIOS version %x\n", BIOS_VERSION);	58	//printf("Using AVR BIOS version %x\n", BIOS_VERSION);
56		59
57	txMsg.Id = CAN_ID_SNS_IRDATA; // ((CAN_SNS << CAN_SHIFT_CLASS) \| (NODE_ID << CAN_SHIFT_SNS_SID))	-
58	//txMsg.Id = (CAN_SNS << CAN_SHIFT_CLASS) \| ((CAN_IR & CAN_MASK_SNS_FUNCC) << CAN_SHIFT_SNS_FUNCC) \| (NODE_ID << CAN_SHIFT_SNS_SID);	60	//txMsg.Id = (CAN_SNS << CAN_SHIFT_CLASS) \| ((CAN_IR & CAN_MASK_SNS_FUNCC) << CAN_SHIFT_SNS_FUNCC) \| (NODE_ID << CAN_SHIFT_SNS_SID);
59	//txMsg.Data.dwords[0] = 0x01020304;	61	//txMsg.Data.dwords[0] = 0x01020304;
60	//txMsg.DataLength = 4;	62	//txMsg.DataLength = 4;
61		63
62	IRDDR &= ~(1<<IRBIT);	64	IRDDR &= ~(1<<IRBIT);
63		65
64	unsigned long time = Timebase_CurrentTime();	66	unsigned long time = Timebase_CurrentTime();
65	unsigned long irTimeoutTime;	67	unsigned long irTimeoutTime;
66		68
67	uint8_t ir_protocol, ir_address, ir_command;	69	uint8_t ir_protocol, ir_address, ir_command;
68	uint8_t state = STATE_IDLE;	70	uint8_t state = STATE_IDLE;
69		71
70	while (1) {	72	while (1) {
71	time = Timebase_CurrentTime();	73	time = Timebase_CurrentTime();
72	if (state == STATE_IDLE) {	74	if (state == STATE_IDLE) {
73	if (checkIr(&ir_protocol, &ir_address, &ir_command) == IR_OK) {	75	if (checkIr(&ir_protocol, &ir_address, &ir_command) == IR_OK) {
74	txMsg.Data.bytes[0] = 0x00;	76	txMsg.Data.bytes[0] = 0x00;
75	txMsg.Data.bytes[1] = ir_protocol;	77	txMsg.Data.bytes[1] = ir_protocol;
76	txMsg.Data.bytes[2] = ir_address;	78	txMsg.Data.bytes[2] = ir_address;
77	txMsg.Data.bytes[3] = ir_command;	79	txMsg.Data.bytes[3] = ir_command;
78	txMsg.DataLength = 4;	80	txMsg.DataLength = 4;
79	BIOS_CanSend(&txMsg);	81	BIOS_CanSend(&txMsg);
80	irTimeoutTime = Timebase_CurrentTime();	82	irTimeoutTime = Timebase_CurrentTime();
81	state = STATE_IR_REPEAT;	83	state = STATE_IR_REPEAT;
82	}	84	}
83	} else if (state == STATE_IR_REPEAT) {	85	} else if (state == STATE_IR_REPEAT) {
84	//kolla efter ny ir, om ingen ny ir och timeout så sätt state till IDLE	86	//kolla efter ny ir, om ingen ny ir och timeout så sätt state till IDLE
85	if (time - irTimeoutTime >= 105) { //getLastProtoTimeout()	87	if (time - irTimeoutTime >= 105) { //getLastProtoTimeout()
86	state = STATE_IDLE;	88	state = STATE_IDLE;
87	txMsg.Data.bytes[0] = 0x0f;	89	txMsg.Data.bytes[0] = 0x0f;
88	BIOS_CanSend(&txMsg);	90	BIOS_CanSend(&txMsg);
89	}	91	}
90	if (checkIrIdle() == IR_OK) { //funktion som borde finnas i irreceiver.c	92	if (checkIrIdle() == IR_OK) { //funktion som borde finnas i irreceiver.c
91	irTimeoutTime = Timebase_CurrentTime();	93	irTimeoutTime = Timebase_CurrentTime();
92	}	94	}
93	}	95	}
94		96
95		-
96		-
97	/*if ((time - time1) >= 2000) {	-
98	time1 = time;	-
99	// Send a CAN message	-
100	txMsg.Data.dwords[1] = time;	-
101	BIOS_CanSend(&txMsg);	-
102	printf("Two seconds passed, time is now %ld.\n", time);	-
103	}*/	-
104		97
105	if (rxMsgFull) {	98	if (rxMsgFull) {
106	// Flush the received message	99	// Flush the received message
107	rxMsgFull = 0; //	100	rxMsgFull = 0; //
108	}	101	}
109	}	102	}
110		103
111	return 0;	104	return 0;
112	}	105	}
113		106

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/application/IrReceive/main.c @ 443 – Rev 403 → 439