WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c

 #include "sns_irTransceive.h"
 #if IR_RX_ENABLE==1
 struct {
     uint8_t             state;
-    uint8_t             newData;
     uint16_t            *rxbuf;
     uint8_t             rxlen;
     uint8_t             timerNum;
     Ir_Protocol_Data_t  proto;
+    uint8_t             newData;
 } irRxChannel[IR_SUPPORTED_NUM_CHANNELS];
 #endif
 #if IR_TX_ENABLE==1
 struct {
     uint8_t             state;
-    uint8_t             sendComplete;
     uint16_t            *txbuf;
     uint8_t             txlen;
     uint8_t             timerNum;
     uint8_t             repeatCount;
+    Ir_Protocol_Data_t  proto;
     uint8_t             stopSend;
-    Ir_Protocol_Data_t  proto;
+    uint8_t             sendComplete;
 } irTxChannel[IR_SUPPORTED_NUM_CHANNELS];
 #endif
 uint16_t    buf[3][MAX_NR_TIMES];
 #if (sns_irTransceive_SEND_DEBUG==1)
 void send_debug(uint16_t *buffer, uint8_t len) {
     StdCan_Msg_t dbgIrTxMsg;
     /* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
     StdCan_Set_class(dbgIrTxMsg.Header, CAN_MODULE_CLASS_SNS);
     StdCan_Set_direction(dbgIrTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
     dbgIrTxMsg.Length = 8;
     dbgIrTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
     dbgIrTxMsg.Header.ModuleId = sns_irTransceive_ID;
         dbgIrTxMsg.Data[3] = (buffer[index+1]>>0)&0xff;
         dbgIrTxMsg.Data[4] = (buffer[index+2]>>8)&0xff;
         dbgIrTxMsg.Data[5] = (buffer[index+2]>>0)&0xff;
         dbgIrTxMsg.Data[6] = (buffer[index+3]>>8)&0xff;
         dbgIrTxMsg.Data[7] = (buffer[index+3]>>0)&0xff;
         /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
         while (StdCan_Put(&dbgIrTxMsg) != StdCan_Ret_OK) {}
         _delay_ms(1);
     }
     uint8_t lastpacketcnt = len&0x03;
     if (lastpacketcnt > 0) {
         dbgIrTxMsg.Length = lastpacketcnt<<1;
         for (uint8_t i = 0; i < lastpacketcnt; i++) {
             dbgIrTxMsg.Data[i<<1] = (buffer[(len&0xfc)|i]>>8)&0xff;
             dbgIrTxMsg.Data[(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 (StdCan_Put(&dbgIrTxMsg) != StdCan_Ret_OK) {}
         _delay_ms(1);
     }
 }
 #endif
 #if IR_RX_ENABLE==1
 void sns_irTransceive_RX_done_callback(uint8_t channel, uint16_t *buffer, uint8_t len)
+{
     if (channel < IR_SUPPORTED_NUM_CHANNELS)
+    {
         irRxChannel[channel].newData = TRUE;
         irRxChannel[channel].rxlen = len;
     }
 }
 #endif
+#if IR_TX_ENABLE==1
 void sns_irTransceive_TX_done_callback(uint8_t channel)
+{
     if (channel < IR_SUPPORTED_NUM_CHANNELS)
+    {
         irTxChannel[channel].sendComplete = TRUE;
+    }
+}
+#endif
 void sns_irTransceive_Init(void)
+{
 /* Debug IO, PB7 */
 gpio_set_out(EXP_A);
     irTxMsg.Length = 6;
     for (uint8_t i = 0; i < IR_SUPPORTED_NUM_CHANNELS; i++)
+    {
 #if IR_RX_ENABLE==1
-        irRxChannel[i].state = sns_irTransceive_STATE_RECEIVING;
+        irRxChannel[i].state = sns_irTransceive_STATE_DISABLED;
         irRxChannel[i].newData = FALSE;
         irRxChannel[i].rxlen = 0;
         irRxChannel[i].proto.timeout=0;
         irRxChannel[i].proto.data=0;
         irRxChannel[i].proto.repeats=0;
         irRxChannel[i].proto.protocol=0;
 #endif
 #if IR_TX_ENABLE==1
-        irTxChannel[i].state = sns_irTransceive_STATE_IDLE;
+        irTxChannel[i].state = sns_irTransceive_STATE_DISABLED;
         irTxChannel[i].sendComplete = FALSE;
         irTxChannel[i].repeatCount = 0;
         irTxChannel[i].txlen = 0;
         irTxChannel[i].proto.data=0;
         irTxChannel[i].proto.repeats=0;
                     irRxChannel[channel].proto.timeout=300;
 #endif
+                }
                 /* Enable the receiver again */
                 IrTransceiver_EnableRx(channel);
                 irRxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
+            }
             break;
         case sns_irTransceive_STATE_START_PAUSE:
             /* set a timer so we can send release button event when no new IR is arriving */
             Timer_SetTimeout(irRxChannel[channel].timerNum, irRxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
             irRxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
             break;
         case sns_irTransceive_STATE_PAUSING:
             /* reset timer if new IR arrived */
             if (irRxChannel[channel].newData == TRUE || IrTransceiver_GetStoreEnableRx(channel) == TRUE) {
                 cli();
                 irRxChannel[channel].newData = FALSE;
                 sei();
                 Timer_SetTimeout(irRxChannel[channel].timerNum, irRxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
             }
             if (Timer_Expired(irRxChannel[channel].timerNum)) {
                 irRxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
             }
             break;
         case sns_irTransceive_STATE_START_IDLE:
             if (irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
                 /* Send button release command on CAN */
                 irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED;
                 irTxMsg.Data[0] |= channel<<4;
                 irTxMsg.Data[5] = irRxChannel[channel].proto.data&0xff;
                 StdCan_Put(&irTxMsg);
+            }
             irRxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+            break;
+        default:
             break;
+        }
 #endif
 #if IR_TX_ENABLE==1
             irTxChannel[channel].stopSend = FALSE;
             irTxChannel[channel].repeatCount = 0;
             irTxChannel[channel].proto.framecnt = 0;
             irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+            break;
+        default:
             break;
+        }
 #endif
+    }
+    {
         uint8_t channel;
         switch (rxMsg->Header.Command)
+        {
         case CAN_MODULE_CMD_PHYSICAL_IR:
             channel = rxMsg->Data[0]>>4;
             if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED && channel < IR_SUPPORTED_NUM_CHANNELS)
             {
                 if (irTxChannel[channel].state == sns_irTransceive_STATE_IDLE)
+                {
                     irTxChannel[channel].proto.protocol = rxMsg->Data[1];
                     irTxChannel[channel].proto.data = rxMsg->Data[2];
                     irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
                     irTxChannel[channel].proto.data |= rxMsg->Data[3];
                     irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
                     irTxChannel[channel].proto.data |= rxMsg->Data[4];
                     irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
+                }
+            }
             else if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED && channel < IR_SUPPORTED_NUM_CHANNELS)
             {
                 if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE)
+                {
                     irTxChannel[channel].stopSend = TRUE;
+                }
+            }
         case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG:
             channel = rxMsg->Data[0]>>4;
             uint8_t config = rxMsg->Data[0] & 0x0f;
             uint8_t power = rxMsg->Data[1]>>6;
             if (channel < IR_SUPPORTED_NUM_CHANNELS && config <= CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE && power < 4)
             {
 #if IR_RX_ENABLE==1
                 if (config == CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE)
+                {
+#if IR_TX_ENABLE==1
+                    irTxChannel[channel].state = sns_irTransceive_STATE_DISABLED;
+#endif
                     irRxChannel[channel].rxbuf = buf[channel];
                     switch (channel)
+                    {
                         case 0:
                             gpio_clr_pin(sns_irTransceive_VCC_EN0_PIN);
                             IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
                             break;
                         case 1:
                             gpio_clr_pin(sns_irTransceive_VCC_EN1_PIN);
                             IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
                             break;
                         case 2:
                             gpio_clr_pin(sns_irTransceive_VCC_EN2_PIN);
                             IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
                             break;
+                    }
+                    irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
+                }
 #endif
 #if IR_TX_ENABLE==1
                 if (config == CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_TRANSMIT)
+                {
+#if IR_RX_ENABLE==1
+                    irRxChannel[channel].state = sns_irTransceive_STATE_DISABLED;
+#endif
                     irTxChannel[channel].txbuf = buf[channel];
                     switch (channel)
+                    {
                         case 0:
 #if IR_RX_ENABLE==1
                             IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
 #endif
                             IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX0_PIN);
                             break;
                         case 1:
 #if IR_RX_ENABLE==1
                             gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
                             IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
 #endif
                             IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX1_PIN);
                             break;
                             IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
 #endif
                             IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX2_PIN);
                             break;
+                    }
+                    irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+                }
 #endif
+            }
             break;
+        }

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c – Rev 1730 → 1737