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

 #endif
 #define sns_irTransceive_BaseFrq (4145146UL)
 #define channelIsOk(_ch)    ((_ch)>=0 && (_ch)<IR_SUPPORTED_NUM_CHANNELS)
-#ifndef sns_irTransceive_PRONTO_SUPPORT
-#define sns_irTransceive_PRONTO_SUPPORT 0
-#endif
 /*
  * PRONTO HEX Routines
  */
+#if IR_TX_ENABLE==1
 static void pronto_sendResponse(uint8_t channel, uint8_t responseValue)
 {
     StdCan_Msg_t msg;
     StdCan_Set_class(msg.Header, CAN_MODULE_CLASS_SNS);
     StdCan_Set_direction(msg.Header, DIRECTIONFLAG_FROM_OWNER);
     msg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
     msg.Header.ModuleId = sns_irTransceive_ID;
     /* Send response command. */
     msg.Data[0] = ((channel<<4)|0xf);
     msg.Data[1] = 0xF0;
     msg.Data[2] = (uint8_t)responseValue;
     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
     _delay_ms(1);
 }
 static uint8_t prontoAllocatedTxChannel = -1;
+#endif
 #if sns_irTransceive_PRONTO_SUPPORT==1
 volatile uint32_t sns_irTransceive_LastPronto=0;
+#if IR_TX_ENABLE==1
 /* is any channel transmitting (or preparing to transmit) pronto? */
 static inline int8_t prontoChannelIsAllocated(void)
+{
     if (prontoAllocatedTxChannel >= 0 &&
         prontoAllocatedTxChannel < IR_SUPPORTED_NUM_CHANNELS &&
         irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_DISABLED)
+    {
         return 1;
     }
     return 0;
+}
+#endif
 #define sns_irTransceive_MAXTIMING (16*1000)
 static void pronto_sendData(uint16_t *buffer, uint8_t len, uint8_t channel, uint16_t modfreq)
+{
     msg.Header.ModuleId = sns_irTransceive_ID;
     /* Send timing command. */
     msg.Length = 5;
     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOTIMING;
     if ((currentTime < sns_irTransceive_LastPronto+sns_irTransceive_MAXTIMING) && (sns_irTransceive_LastPronto != 0))
+    {
         /* Calculate elapsed time since last pronto packet. */
         uint32_t elapsedTime = ((currentTime - sns_irTransceive_LastPronto) * 1000) & 0x00FFFFFFUL; /* 24bit value. */
     /* Remember byte if data does not fit 8 bit. */
     uint8_t mem = 0;
     while (i < len)
+    {
         if (mem > 0)
         {
             /* If byte was memorized then buffer it. */
             msg.Data[j] = mem;
             /* Clear memory. */
             mem = 0;
         }
         else
+        {
             /* Convert µs to pronto hex modulation pulses. */
             uint16_t data = (uint16_t)(((uint32_t)buffer[i] * (uint32_t)modfreq) / 1000);
             /* Protocol compression. */
             if (data >= 256)
             {
                 /* If data does not fit into 8 bit, then split, memorize low byte. */
                 mem = data&0xff;
                 /* Buffer high byte. */
                 msg.Data[j] = (data>>8)&0xff;
                 j++;
                 if (j==8)
                 {
                     /* If send buffer is full, send frame. */
                     /* Can buffers will be filled when sending more than 2-3 messages, so retry until sent. */
                     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
                     _delay_ms(1);
                     j=0;
                     seqNr = (seqNr + 1) % 16;
                     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
+                }
                 /* Set complementary burst pair to 0 to indicate 16bit transmission. */
                 msg.Data[j] = 0;
+            }
             else
+            }
             i++;
+        }
         j++;
         if (j==8)
+        {
             /* If send buffer is full, send frame. */
             /* Can buffers will be filled when sending more than 2-3 messages, so retry until sent. */
             while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
             _delay_ms(1);
+        }
+    }
     /* End with max pulse. TODO: fix uglyness. */
     msg.Data[j] = ((IR_MAX_PULSE_WIDTH/((1000000ULL*109)/sns_irTransceive_BaseFrq))>>8) & 0xFF;
     j++;
     if (j==8)
     {
         /* If send buffer is full, send frame. */
         /* Can buffers will be filled when sending more than 2-3 messages, so retry until sent. */
         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
         _delay_ms(1);
         j=0;
         seqNr = (seqNr + 1) % 16;
         msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
+    }
     msg.Data[j] = 0;
     j++;
     j++;
     if (j==8)
+    {
         /* If send buffer is full, send frame. */
         /* Can buffers will be filled when sending more than 2-3 messages, so retry until sent. */
         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
         _delay_ms(1);
         j=0;
         seqNr = (seqNr + 1) % 16;
         msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
+    }
     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
     _delay_ms(1);
+}
+#if IR_TX_ENABLE==1
 static int decodeProntoData(int channel, uint8_t data)
+{
     static uint8_t waitingForLSB = FALSE;
     static uint8_t previousValueWas16bit = FALSE;
         irTxChannel[channel].txlen++;
+    }
     return 1;
+}
+#endif
 #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
 static void sns_irTransceive_setConfig(uint8_t channel, uint8_t config, uint8_t power, uint16_t modfreq)
 {
     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].proto.modfreq = modfreq;
             irRxChannel[channel].rxbuf = buf[channel];
             switch (channel)
             {
                 case 0:
+#ifdef sns_irTransceive_VCC_EN0_PIN
                     gpio_clr_pin(sns_irTransceive_VCC_EN0_PIN);
+#endif
+#ifdef sns_irTransceive_RX0_PIN
                     IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
+#endif
                     break;
                 case 1:
+#ifdef sns_irTransceive_VCC_EN1_PIN
                     gpio_clr_pin(sns_irTransceive_VCC_EN1_PIN);
+#endif
+#ifdef sns_irTransceive_RX1_PIN
                     IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
+#endif
                     break;
                 case 2:
+#ifdef sns_irTransceive_VCC_EN2_PIN
                     gpio_clr_pin(sns_irTransceive_VCC_EN2_PIN);
+#endif
+#ifdef sns_irTransceive_RX2_PIN
                     IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
+#endif
                     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
+#ifdef sns_irTransceive_VCC_EN0_PIN
                     gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
+#endif
                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
 #endif
                     IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX0_PIN);
 #if sns_irTransceive_ENABLE_PCA95xx==1
                     Pca95xx_set_out(sns_irTransceive_TX0_PWRh);
                     if (power&0x1)
+                    {
                         Pca95xx_set_in(sns_irTransceive_TX0_PWRl);
+                    }
                     if (power&0x2)
                     {
                         Pca95xx_set_in(sns_irTransceive_TX0_PWRh);
                     }
 #endif
                     break;
                 case 1:
 #if IR_RX_ENABLE==1
+#ifdef sns_irTransceive_VCC_EN1_PIN
                     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
+#endif
                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
 #endif
                     IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX1_PIN);
 #if sns_irTransceive_ENABLE_PCA95xx==1
+                    }
 #endif
                     break;
                 case 2:
 #if IR_RX_ENABLE==1
+#ifdef sns_irTransceive_VCC_EN2_PIN
                     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
+#endif
                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
 #endif
                     IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX2_PIN);
 #if sns_irTransceive_ENABLE_PCA95xx==1
         irTxChannel[i].proto.protocol=0;
 #endif
+    }
 #if IR_RX_ENABLE==1
+#ifdef sns_irTransceive_RX0_REPEATE_TIMER
     if (IR_SUPPORTED_NUM_CHANNELS>=1) irRxChannel[0].timerNum=sns_irTransceive_RX0_REPEATE_TIMER;
+#endif
+#ifdef sns_irTransceive_RX1_REPEATE_TIMER
     if (IR_SUPPORTED_NUM_CHANNELS>=2) irRxChannel[1].timerNum=sns_irTransceive_RX1_REPEATE_TIMER;
-    if (IR_SUPPORTED_NUM_CHANNELS>=3) irRxChannel[2].timerNum=sns_irTransceive_RX2_REPEATE_TIMER;
 #endif
+#ifdef sns_irTransceive_RX2_REPEATE_TIMER
+    if (IR_SUPPORTED_NUM_CHANNELS>=3) irRxChannel[2].timerNum=sns_irTransceive_RX2_REPEATE_TIMER;
+#endif
+#endif
 #if IR_TX_ENABLE==1
     if (IR_SUPPORTED_NUM_CHANNELS>=1) irTxChannel[0].timerNum=sns_irTransceive_TX0_REPEATE_TIMER;
     if (IR_SUPPORTED_NUM_CHANNELS>=2) irTxChannel[1].timerNum=sns_irTransceive_TX1_REPEATE_TIMER;
     if (IR_SUPPORTED_NUM_CHANNELS>=3) irTxChannel[2].timerNum=sns_irTransceive_TX2_REPEATE_TIMER;
 #endif
     IrTransceiver_Init();
     /* Configure all TX VCC pins as outputs and disable them. */
+#ifdef sns_irTransceive_VCC_EN0_PIN
     gpio_set_out(sns_irTransceive_VCC_EN0_PIN);
-    gpio_set_out(sns_irTransceive_VCC_EN1_PIN);
-    gpio_set_out(sns_irTransceive_VCC_EN2_PIN);
     gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
+#endif
+#ifdef sns_irTransceive_VCC_EN1_PIN
+    gpio_set_out(sns_irTransceive_VCC_EN1_PIN);
     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
+#endif
+#ifdef sns_irTransceive_VCC_EN2_PIN
+    gpio_set_out(sns_irTransceive_VCC_EN2_PIN);
     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
+#endif
-    /* TX-pins must be set in case transmitter is nexa. */
+#if IR_TX_ENABLE==1
     gpio_set_out(sns_irTransceive_MOD_PIN);
     gpio_set_out(sns_irTransceive_TX0_PIN);
     gpio_set_out(sns_irTransceive_TX1_PIN);
     gpio_set_out(sns_irTransceive_TX2_PIN);
 #if IR_TX_ACTIVE_LOW==1
     gpio_set_pin(sns_irTransceive_TX0_PIN);
     gpio_set_pin(sns_irTransceive_TX1_PIN);
     gpio_set_pin(sns_irTransceive_TX2_PIN);
+#endif
 #endif
     /* IR tx power pins on PCA95xx. */
 #if sns_irTransceive_ENABLE_PCA95xx==1
     Pca95xx_Init(0);

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c – Rev 1944 → 1975