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

 #endif
 uint16_t    buf[IR_SUPPORTED_NUM_CHANNELS][MAX_NR_TIMES];
 StdCan_Msg_t        irTxMsg;
+#ifndef sns_irTransceive_PRONTO_SUPPORT
+#define sns_irTransceive_PRONTO_SUPPORT 1
+#endif
 #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 */
         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);
+    }
+}
+#if sns_irTransceive_PRONTO_SUPPORT==1
+/* TODO configurable divider parameter */
+#define BaseFrq (4145146ULL)
+#define wFrqDiv (0x6d)
+#define divider (1000000ULL*wFrqDiv/BaseFrq)
+void send_pronto(uint16_t *buffer, uint8_t len) {
+    StdCan_Msg_t msg;
+    StdCan_Set_class(msg.Header, CAN_MODULE_CLASS_SNS);
+    StdCan_Set_direction(msg.Header, DIRECTIONFLAG_FROM_OWNER);
+    msg.Length = 8;
+    msg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
+    msg.Header.ModuleId = sns_irTransceive_ID;
+    msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART;
+    msg.Data[0] = 0x00; /* Prontoformat 0x0000 */
+    msg.Data[1] = 0x00;
+    msg.Data[2] = 0x00; /* Freq divider, 38kHz => 0x006d TODO: configurable */
+    msg.Data[3] = wFrqDiv;
+    msg.Data[4] = 0x00; /* Once seq length, first byte always 0 */
+    msg.Data[5] = len/2;
+    msg.Data[6] = 0x00; /* Repeat seq length, always 0 for ir receive */
+    msg.Data[7] = 0x00;
+    while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
+    _delay_ms(1);
+    /* TODO Add more prontodata commands -> 32 */
+    msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1;
+    for (uint8_t i = 0; i < len>>2; i++) {
+        uint8_t index = i<<2;
+        msg.Data[0] = ((buffer[index]/divider)>>8)&0xff;
+        msg.Data[1] = ((buffer[index]/divider)>>0)&0xff;
+        msg.Data[2] = ((buffer[index+1]/divider)>>8)&0xff;
+        msg.Data[3] = ((buffer[index+1]/divider)>>0)&0xff;
+        msg.Data[4] = ((buffer[index+2]/divider)>>8)&0xff;
+        msg.Data[5] = ((buffer[index+2]/divider)>>0)&0xff;
+        msg.Data[6] = ((buffer[index+3]/divider)>>8)&0xff;
+        msg.Data[7] = ((buffer[index+3]/divider)>>0)&0xff;
+        /* 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);
+        msg.Header.Command++;
+    }
+    uint8_t lastpacketcnt = len&0x03;
+    /* msg command kept from for loop, but increase 16 */
+    msg.Header.Command+=32;
+    msg.Length = lastpacketcnt<<1;
+    for (uint8_t i = 0; i < lastpacketcnt; i++) {
+        msg.Data[i<<1] = ((buffer[(len&0xfc)|i]/divider)>>8)&0xff;
+        msg.Data[(i<<1)+1] = ((buffer[(len&0xfc)|i]/divider)>>0)&0xff;
+    }
+    /* 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);
+}
+#endif
 #endif
 #if IR_RX_ENABLE==1
 void sns_irTransceive_RX_done_callback(uint8_t channel, uint16_t *buffer, uint8_t len)
+{
                     Pca95xx_set_out(sns_irTransceive_TX0_PWRl);
                     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
                     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
                     Pca95xx_set_out(sns_irTransceive_TX1_PWRl);
                     Pca95xx_set_out(sns_irTransceive_TX1_PWRh);
                     if (power&0x1)
+                    {
                         Pca95xx_set_in(sns_irTransceive_TX1_PWRl);
                     }
                     if (power&0x2)
+                    {
                         Pca95xx_set_in(sns_irTransceive_TX1_PWRh);
                     }
 #endif
                     break;
                 case 2:
 #if IR_RX_ENABLE==1
                     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
                         Pca95xx_set_in(sns_irTransceive_TX2_PWRl);
+                    }
                     if (power&0x2)
+                    {
                         Pca95xx_set_in(sns_irTransceive_TX2_PWRh);
                     }
 #endif
                     break;
+            }
             irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+        }
 #endif
+    }
+}
 void sns_irTransceive_Init(void)
 {
     StdCan_Set_class(irTxMsg.Header, CAN_MODULE_CLASS_SNS);
     StdCan_Set_direction(irTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
     irTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
     irTxMsg.Header.ModuleId = sns_irTransceive_ID;
     irTxMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_IR;
         irTxChannel[i].txlen = 0;
         irTxChannel[i].proto.data=0;
         irTxChannel[i].proto.repeats=0;
         irTxChannel[i].proto.framecnt=0;
         irTxChannel[i].proto.protocol=0;
 #endif
     }
 #if IR_RX_ENABLE==1
     // TODO: hardcoded to 3 channels?? /jm
     irRxChannel[0].timerNum=sns_irTransceive_RX0_REPEATE_TIMER;
     irRxChannel[1].timerNum=sns_irTransceive_RX1_REPEATE_TIMER;
+}
 void sns_irTransceive_Process(void)
+{
     for (uint8_t channel=0; channel < IR_SUPPORTED_NUM_CHANNELS; channel++)
     {
 #if IR_RX_ENABLE==1
         switch (irRxChannel[channel].state)
+        {
         case sns_irTransceive_STATE_IDLE:
             irRxChannel[channel].state = sns_irTransceive_STATE_START_RECEIVE;
             break;
         case sns_irTransceive_STATE_START_RECEIVE:
             IrTransceiver_ResetRx(channel);
             cli();
             irRxChannel[channel].newData = FALSE;
             sei();
             irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
             break;
         case sns_irTransceive_STATE_RECEIVING:
                     StdCan_Put(&irTxMsg);
+                }
                 else if (irRxChannel[channel].proto.protocol == IR_PROTO_UNKNOWN)
+                {
 #if (sns_irTransceive_SEND_DEBUG==1)
+#if sns_irTransceive_PRONTO_SUPPORT==0
                     send_debug(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen);
                     irRxChannel[channel].proto.timeout=300;
+#endif
+#if sns_irTransceive_PRONTO_SUPPORT==1
+                    send_pronto(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen);
+                    irRxChannel[channel].proto.timeout=300;
+#endif
 #endif
+                }
                 /* Enable the receiver again */
                 IrTransceiver_EnableRx(channel);

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c – Rev 1771 → 1810