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

 #endif
 #define sns_irTransceive_BaseFrq (4145146UL)
 #ifndef sns_irTransceive_PRONTO_SUPPORT
-#define sns_irTransceive_PRONTO_SUPPORT 0
+#define sns_irTransceive_PRONTO_SUPPORT 1
 #endif
 /*
  * PRONTO HEX Routines
  */
 static int decodeProntoData(int channel, uint8_t data)
+{
     static uint8_t waitingForLSB = FALSE;
-    // check if done
-    if (irTxChannel[activeChannel].txlen == (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen))) {
-        return 2;
-    }
     if (irTxChannel[channel].txlen >= MAX_NR_TIMES) {
         // max length exceeded
         return -1;
+    }
         waitingForLSB = FALSE;
         if (data == 0) {
             // cannot start with 0x00
             return -2;
+        }
     }
     // 0x00 means that previously received time is MSB of 16bit value, and that next byte will be LSB
     if (data == 0 && !waitingForLSB) {
         // convert previous time to MSB of the 16bit value. next received byte will become LSB
         irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1] <<= 8;
         waitingForLSB = FALSE;
+    }
     // non-zero value! simply new 8bit value
     else {
+        // check if we're already done
+        if (irTxChannel[activeChannel].txlen >= (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen))) {
+            // too much data received, not necessarily a problem in case frames are padded
+            return 2;
+        }
         irTxChannel[channel].txbuf[irTxChannel[channel].txlen] = data;
         irTxChannel[channel].txlen++;
+    }
                     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);
                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
                 /* Let protocol driver parse and then send on CAN */
                 uint8_t res2 = parseProtocol(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, &irRxChannel[channel].proto);
                 if (res2 == IR_OK && irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
                     irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED;
                     irTxMsg.Data[0] |= channel<<4;
                     irTxMsg.Data[1] = irRxChannel[channel].proto.protocol;
                     irTxMsg.Data[2] = (irRxChannel[channel].proto.data>>24)&0xff;
                     irTxMsg.Data[3] = (irRxChannel[channel].proto.data>>16)&0xff;
                     irTxMsg.Data[4] = (irRxChannel[channel].proto.data>>8)&0xff;
                     irTxMsg.Data[5] = irRxChannel[channel].proto.data&0xff;
                     StdCan_Put(&irTxMsg);
+                }
                 else if (irRxChannel[channel].proto.protocol == IR_PROTO_UNKNOWN)
+                {
 #if (sns_irTransceive_SEND_DEBUG==1)
                     send_debug(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen);
         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].state = sns_irTransceive_STATE_IDLE;
             break;
         default:
             break;
         }
 #endif
 #if IR_TX_ENABLE==1
         switch (irTxChannel[channel].state)
+        {
         case sns_irTransceive_STATE_IDLE:
             /* transmission is started when a command is received on can */
             break;
         case sns_irTransceive_STATE_START_TRANSMIT:
         {
-            if (expandProtocol(irTxChannel[channel].txbuf, &irTxChannel[channel].txlen, &irTxChannel[channel].proto) == IR_OK)
+            if (expandProtocol(irTxChannel[channel].txbuf, &irTxChannel[channel].txlen, &irTxChannel[channel].proto) == IR_OK) {
-            {
                 IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen);
                 irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
             }
-            else
+            else {
-            {
                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
             }
             break;
+        }
         case sns_irTransceive_STATE_START_TRANSMIT_PRONTO:
+        {
             /* Start IR transmission. */
             IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].onceSeqLen - 1);
             /* Enter transmitting state. */
             irTxChannel[channel].sendingPronto = TRUE;
             irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
             break;
+        }
         case sns_irTransceive_STATE_PRONTO_REPEAT:
+        {
             /* Check if done. */
-            if (irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats && irTxChannel[channel].proto.repeats != 0xFF)
+            if (irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats && irTxChannel[channel].proto.repeats != 0xFF) {
-            {
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
                 break;
+            }
             if (irTxChannel[channel].repeatCount < 255) {
                 // don't transmit last passive. last passive handled by timer
                 IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen - 1);
+            }
             irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
+        }
         case sns_irTransceive_STATE_TRANSMITTING:
         {
             if (irTxChannel[channel].sendComplete == TRUE)
+            {
                 cli();
                 irTxChannel[channel].sendComplete = FALSE;
                 sei();
                 if (irTxChannel[channel].sendingPronto)
                 {
                     if(irTxChannel[channel].repeatCount == 0 || irTxChannel[channel].repSeqLen == 0)
+                    {
                         // use last passive time as timeout
                         uint16_t lastPasTime = irTxChannel[channel].txbuf[irTxChannel[channel].onceSeqLen - 1] / 1000;
                         Timer_SetTimeout(irTxChannel[channel].timerNum, lastPasTime==0 ? 1 : lastPasTime, TimerTypeOneShot, 0);
                     }
                     else
+                    {
                         // use last passive time as timeout
                         uint16_t lastPasTime = irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1]  / 1000;
                         Timer_SetTimeout(irTxChannel[channel].timerNum, lastPasTime==0 ? 1 : lastPasTime, TimerTypeOneShot, 0);
                     }
                     irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
                 }
                 else
+                {
                     irTxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
+                }
             }
             break;
+        }
         case sns_irTransceive_STATE_START_PAUSE:
+        {
             if (irTxChannel[channel].repeatCount < irTxChannel[channel].proto.repeats)
+            {
                 irTxChannel[channel].repeatCount++;
             }
             Timer_SetTimeout(irTxChannel[channel].timerNum, irTxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
             if (irTxChannel[channel].proto.framecnt != 255)
+            {
                 irTxChannel[channel].proto.framecnt++;
+            }
             irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
             break;
         }
         case sns_irTransceive_STATE_PAUSING:
         {
             if (irTxChannel[channel].sendingPronto)
             {
                 if (Timer_Expired(irTxChannel[channel].timerNum))
+                {
                     irTxChannel[channel].state = sns_irTransceive_STATE_PRONTO_REPEAT;
                 }
                 break;
+            }
             if (Timer_Expired(irTxChannel[channel].timerNum))
+            {
                 //TODO maybe send message on can for status? to confirm stopped sending, ready for new command
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+            }
             break;
+        }
         case sns_irTransceive_STATE_START_IDLE:
             irTxChannel[channel].stopSend = FALSE;
             irTxChannel[channel].repeatCount = 0;
             irTxChannel[channel].proto.framecnt = 0;
             irTxChannel[channel].sendingPronto = FALSE;
             break;
+        }
         // decode pronto data
         for (uint8_t i = 0; i < rxMsg->Length; i++) {
+            int res;
-            if (decodeProntoData(activeChannel, rxMsg->Data[i]) != 1) {
+            if ((res=decodeProntoData(activeChannel, rxMsg->Data[i])) != 1) {
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
-                printf("DECERROR");
+                printf("DE:%02d:%02d", res, i);
                 return;
+            }
+        }
         irTxChannel[activeChannel].expectedSeqNr++;

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c – Rev 1842 → 1843