Subversion Repositories HomeAutomation

Rev

Rev 519 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 519 Rev 527
Line 7... Line 7...
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 0x0002
 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
- 
 
 18 
#define IR_ID_RAW   1
- 
 
 19 
#define IR_ID_DEBUG 10
17 
 
 20 
 
18 
// A simple message "queue", with space for one message only.
 21 
// A simple message "queue", with space for one message only.
19 
// 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.
20 
volatile Can_Message_t rxMsg; // Message storage
 23 
volatile Can_Message_t rxMsg; // Message storage
21 
volatile uint8_t rxMsgFull;   // Synchronization flag
 24 
volatile uint8_t rxMsgFull;   // Synchronization flag
Line 49... Line 52...
49 
    // 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.
50 
    BIOS_CanCallback = &can_receive;
 53 
    BIOS_CanCallback = &can_receive;
51 
    // Send CAN_NMT_APP_START
 54 
    // Send CAN_NMT_APP_START
52 
    BIOS_CanSend(&txMsg);
 55 
    BIOS_CanSend(&txMsg);
53 
 
 56 
 
54 
    txMsg.Id = ((CAN_SNS << CAN_SHIFT_CLASS) | (SNS_TYPE_IR << CAN_SHIFT_SNS_TYPE) | (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));
55 
   
 58 
   
56 
    unsigned long time = Timebase_CurrentTime();
 59 
    unsigned long time = Timebase_CurrentTime();
57 
    unsigned long irTimeoutTime = 100;
 60 
    unsigned long irTimeoutTime = 100;
58 
   
 61 
   
59 
    uint8_t ir_protocol, ir_address, ir_command;
 62 
    uint8_t ir_protocol, ir_address, ir_command;
60 
    uint16_t ir_timeout;
 63 
    uint16_t ir_timeout;
61 
    uint8_t state = STATE_IDLE;
 64 
    uint8_t state = STATE_IDLE;
62 
 
 65 
 
63 
    while (1) {
 66 
    while (1) {
- 
 
 67 
        #if 0
64 
        time = Timebase_CurrentTime();
 68 
        time = Timebase_CurrentTime();
65 
        if (state == STATE_IDLE) {
 69 
        if (state == STATE_IDLE) {
66 
            if (IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout) == IR_OK) {
 70 
            if (IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout) == IR_OK) {
67 
                txMsg.Data.bytes[0] = 0x00;
 71 
                txMsg.Data.bytes[0] = 0x00;
68 
                txMsg.Data.bytes[1] = ir_protocol;
 72 
                txMsg.Data.bytes[1] = ir_protocol;
69 
                txMsg.Data.bytes[2] = ir_address;
 73 
                txMsg.Data.bytes[2] = ir_address;
70 
                txMsg.Data.bytes[3] = ir_command;
 74 
                txMsg.Data.bytes[3] = ir_command;
71 
                txMsg.DataLength = 4;
 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));
72 
                BIOS_CanSend(&txMsg);
 77 
                BIOS_CanSend(&txMsg);
73 
                irTimeoutTime = Timebase_CurrentTime();
 78 
                irTimeoutTime = Timebase_CurrentTime();
74 
                state = STATE_IR_REPEAT;
 79 
                state = STATE_IR_REPEAT;
75 
            }
 80 
            }
76 
        } else if (state == STATE_IR_REPEAT) {
 81 
        } else if (state == STATE_IR_REPEAT) {
Line 82... Line 87...
82 
            }
 87 
            }
83 
            if (IrReceive_CheckIdle() == IR_OK) {
 88 
            if (IrReceive_CheckIdle() == IR_OK) {
84 
                irTimeoutTime = Timebase_CurrentTime();
 89 
                irTimeoutTime = Timebase_CurrentTime();
85 
            }
 90 
            }
86 
        }
 91 
        }
- 
 
 92 
        #endif
- 
 
 93 
       
- 
 
 94 
        #if 1
- 
 
 95 
        time = Timebase_CurrentTime();
- 
 
 96 
       
- 
 
 97 
        if (state == STATE_IDLE) {
- 
 
 98 
            /* test for irdata */
- 
 
 99 
            uint8_t returnval = IrReceive_CheckIR(&ir_protocol, &ir_address, &ir_command, &ir_timeout);
- 
 
 100 
            if (returnval == IR_OK) {
- 
 
 101 
                /* a protocol was found for irdata, send on can */
- 
 
 102 
                txMsg.Data.bytes[0] = 0x00;
- 
 
 103 
                txMsg.Data.bytes[1] = ir_protocol;
- 
 
 104 
                txMsg.Data.bytes[2] = ir_address;
- 
 
 105 
                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));
- 
 
 107 
                txMsg.DataLength = 4;
- 
 
 108 
                BIOS_CanSend(&txMsg);
- 
 
 109 
               
- 
 
 110 
                /* set up timeout */
- 
 
 111 
                irTimeoutTime = Timebase_CurrentTime();
- 
 
 112 
                state = STATE_IR_REPEAT;
- 
 
 113 
               
- 
 
 114 
            } 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 */
- 
 
 116 
                ir_protocol = IR_PROTO_UNKNOWN;     //used in STATE_IR_REPEATE, to know if to send a release
- 
 
 117 
                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));
- 
 
 119 
                uint8_t datacnt = getRawDataCnt();
- 
 
 120 
                for (uint8_t i = 0; i < datacnt>>2; i++) {
- 
 
 121 
                    uint8_t index = i<<2;
- 
 
 122 
                    txMsg.Data.words[0] = getRawData(index);
- 
 
 123 
                    txMsg.Data.words[1] = getRawData(index+1);
- 
 
 124 
                    txMsg.Data.words[2] = getRawData(index+2);
- 
 
 125 
                    txMsg.Data.words[3] = getRawData(index+3);
- 
 
 126 
                   
- 
 
 127 
                    /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
- 
 
 128 
                    while (BIOS_CanSend(&txMsg) != CAN_OK) {}
- 
 
 129 
                }
- 
 
 130 
               
- 
 
 131 
                uint8_t lastpacketcnt = datacnt&0x03;
- 
 
 132 
                if (lastpacketcnt > 0) {
- 
 
 133 
                    txMsg.DataLength = lastpacketcnt<<1;
- 
 
 134 
                    for (uint8_t i = 0; i < lastpacketcnt; i++) {
- 
 
 135 
                        txMsg.Data.words[i] = getRawData((datacnt&0xfc)|i);
- 
 
 136 
                    }
- 
 
 137 
                    BIOS_CanSend(&txMsg);
- 
 
 138 
                }
- 
 
 139 
 
- 
 
 140 
                irTimeoutTime = Timebase_CurrentTime();
- 
 
 141 
                state = STATE_IR_REPEAT;
- 
 
 142 
                ir_timeout = 200;           /* Set a default timeout */
- 
 
 143 
            } else if (returnval != IR_NO_DATA) {
- 
 
 144 
                /* debug, send the returned message on errors (except for IR_NO_DATA-errors) */
- 
 
 145 
                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));
- 
 
 146 
                txMsg.DataLength = 1;
- 
 
 147 
                txMsg.Data.bytes[0] = returnval;
- 
 
 148 
                BIOS_CanSend(&txMsg);
- 
 
 149 
            }
- 
 
 150 
 
- 
 
 151 
        } else if (state == STATE_IR_REPEAT) {
- 
 
 152 
            /* check for new ir-data, if no new data during the timout-time then set state to IDLE */
- 
 
 153 
            if (time - irTimeoutTime >= ir_timeout) {      
- 
 
 154 
                state = STATE_IDLE;
- 
 
 155 
                /* if the protocol was known then send a release-message */
- 
 
 156 
                if (ir_protocol != IR_PROTO_UNKNOWN) {
- 
 
 157 
                    txMsg.Data.bytes[0] = 0x0f;
- 
 
 158 
                    BIOS_CanSend(&txMsg);
- 
 
 159 
                }
- 
 
 160 
            }
- 
 
 161 
            if (IrReceive_CheckIdle() == IR_OK) {
- 
 
 162 
                irTimeoutTime = Timebase_CurrentTime();
- 
 
 163 
            }
- 
 
 164 
        }
- 
 
 165 
           
- 
 
 166 
        #endif
- 
 
 167 
 
87 
 
 168 
       
88 
       
 - 
 
89 
        if (rxMsgFull) {
 169 
        if (rxMsgFull) {
- 
 
 170 
            /* No message reception functionality implemented */
- 
 
 171 
           
90 
            // Flush the received message
 172 
            /* Flush the received message */
91 
            rxMsgFull = 0; //  
 173 
            rxMsgFull = 0; //  
92 
        }
 174 
        }
93 
    }
 175 
    }
94 
   
 176 
   
95 
    return 0;
 177 
    return 0;