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

 volatile uint32_t sns_irTransceive_LastPronto=0;
 static uint8_t activeChannel = 0;
 #define sns_irTransceive_MAXTIMING (16*1000)
 static void send_pronto(uint16_t *buffer, uint8_t len, uint8_t channel, uint16_t modfreq) {
+    return;
     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.Data[0] = ((channel<<4)|0xf);
         msg.Data[1] = 0x10;
         msg.Data[2] = (((currentTime-sns_irTransceive_LastPronto)*1000)>>16)&0xff;
         msg.Data[3] = (((currentTime-sns_irTransceive_LastPronto)*1000)>>8)&0xff;
         msg.Data[4] = ((currentTime-sns_irTransceive_LastPronto)*1000)&0xff;
         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
         _delay_ms(1);
+    }
     sns_irTransceive_LastPronto=currentTime;
     // calculate frequency divider
     uint16_t divider = (uint16_t)(sns_irTransceive_BaseFrq / (1000*(uint32_t)modfreq));
                     _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
-            {
-                msg.Data[j] = data&0xff;
-            }
-            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);
-            j=0;
-            seqNr = (seqNr + 1) % 16;
-            msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
-        }
+            }
+            else
+            {
+                msg.Data[j] = data&0xff;
+            }
+            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);
+            j=0;
+            seqNr = (seqNr + 1) % 16;
+            msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
+        }
+    }
     /* 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 */
 static int decodeProntoData(int channel, uint8_t data)
+{
     static uint8_t waitingForLSB = FALSE;
+    static uint8_t previousValueWas16bit = FALSE;
     if (irTxChannel[channel].txlen >= MAX_NR_TIMES) {
         // max length exceeded
         return -1;
+    }
             return -2;
+        }
+    }
     // 0x00 means that previously received time is MSB of 16bit value, and that next byte will be LSB
-    if (data == 0 && !waitingForLSB) {
+    if (data == 0 && !waitingForLSB && previousValueWas16bit==FALSE) {
         // convert previous time to MSB of the 16bit value. next received byte will become LSB
         irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1] <<= 8;
         // flag that next received byte is LSB rather than a new timing value
         waitingForLSB = TRUE;
         // let this byte be LSB of previous 16bit value
         irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1] |= data;
         // we've now completed reception of the 16bit value
         waitingForLSB = FALSE;
+        previousValueWas16bit = TRUE;
     }
     // 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))) {
+        if (irTxChannel[channel].txlen >= (((uint16_t)irTxChannel[channel].onceSeqLen + (uint16_t)irTxChannel[channel].repSeqLen))) {
             // too much data received, not necessarily a problem in case frames are padded
             return 2;
+        }
         irTxChannel[channel].txbuf[irTxChannel[channel].txlen] = data;
+        previousValueWas16bit = FALSE;
         irTxChannel[channel].txlen++;
+    }
     return 1;
                     Pca95xx_set_out(sns_irTransceive_TX2_PWRh);
                     if (power&0x1)
+                    {
                         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
+    }
+}
                 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
         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) {
                 IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen);
                 irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
             }
             else {
                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+            }
             break;
+        }
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
                 break;
+            }
             if (irTxChannel[channel].repeatCount < 255) {
                 irTxChannel[channel].repeatCount++;
+            }
             // repeat sequence exists?
             if (irTxChannel[channel].repSeqLen != 0) {
                 // use repeat seq
                 cli();
                 irTxChannel[channel].sendComplete = FALSE;
                 sei();
                 if (irTxChannel[channel].sendingPronto)
                 {
+                    // first repeat, or no repeat sequence defined => use last passive time in once seq
                     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);
+                    }
+                    // second, or later repeat => use last passive time in repeat seq
                     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;
+                }
+            }
+            {
                 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))
             {
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
+            }
             /* transmission is stopped when such command is recevied on can */
             if (irTxChannel[channel].stopSend == TRUE && irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
+            {
         default:
             break;
+        }
 #endif
     }
 }
 /* Handle incoming CAN data */
 void sns_irTransceive_HandleMessage(StdCan_Msg_t *rxMsg)
+{
     /* Sanity check. */
     if (StdCan_Ret_class(rxMsg->Header) != CAN_MODULE_CLASS_SNS ||
                 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].proto.data = irTxChannel[channel].proto.data<<8;
                 irTxChannel[channel].proto.data |= rxMsg->Data[5];
                 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;
+            }
         }
         break;
+    }
 #if sns_irTransceive_PRONTO_SUPPORT==1
     /* TODO: add struct which stores pronto info:
             break;
+        }
         uint32_t freqkHz = (sns_irTransceive_BaseFrq / (divider*1000));
         if (freqkHz == 0) {
             // invalid modfreq
             break;
+        }
         irTxChannel[channel].proto.modfreq = freqkHz;
         //printf("FRQ%05u", irTxChannel[channel].proto.modfreq);
         // TODO: reconfigure with new modfreq, if no other channels sending pronto
         /* TODO: Send response frame */
         break;
+    }
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTOP:
         /* TODO: stop sending IR */
         /* TODO: Send response frame */
         break;
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOCONTINUE:
         /* TODO: reset timeout to continue sending repeat sequences */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA12: /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA13: /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA14: /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA15: /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA16:
     {
         // unexpected CAN msg, out of order
         if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
             break;
         }
         // unexpected CAN msg, out of order
         if ((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
             printf("SEQERROR");
-            irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+            irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
             break;
+        }
         // decode pronto data
         for (uint8_t i = 0; i < rxMsg->Length; i++) {
-            int res;
-            if ((res=decodeProntoData(activeChannel, rxMsg->Data[i])) != 1) {
+            if (decodeProntoData(activeChannel, rxMsg->Data[i]) != 1) {
-                irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+                irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
-                printf("DE:%02d:%02d", res, i);
+                printf("DECERROR");
                 return;
+            }
+        }
         irTxChannel[activeChannel].expectedSeqNr++;
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND14:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND15:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND16:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND17:
+    {
         // unexpected CAN msg, out of order
         if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
             break;
         }
         // unexpected CAN msg, out of order
         if (((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1) % 16) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
             printf("SEQERROR");
-            irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+            irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
             break;
+        }
-        // decode remaining pronto data (if any)
+        // decode remaining pronto data (if any). -1 because last byte is repeat count
         for (uint16_t i = 0; i < rxMsg->Length - 1; i++) {
             if (decodeProntoData(activeChannel, rxMsg->Data[i]) < 0) {
                 printf("DECERROR");
-                irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
+                irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
                 return;
+            }
+        }
         // sanity check
         irTxChannel[activeChannel].proto.timeout = 1; // TODO: timer is buggy and doesn't support timeout 0, so we're forced to use 1ms extra between repeats
         // convert pronto data to us
         // TODO: calculate value
-        for (uint16_t i=0; i < irTxChannel[activeChannel].txlen; i++) {
+        for (uint16_t i = 0; i < irTxChannel[activeChannel].txlen; i++) {
-            uint32_t newVal = ((uint32_t)irTxChannel[activeChannel].txbuf[i]) * 27;
+            uint32_t newVal = ((uint32_t)irTxChannel[activeChannel].txbuf[i]) * 27UL;
-            if (newVal > 0xFFFF) {
+            if (newVal > 0xFFFFUL) {
-                newVal = 0xFFFF;
+                newVal = 0xFFFFUL;
+            }
             irTxChannel[activeChannel].txbuf[i] = (uint16_t)newVal;
+        }
         // send

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c – Rev 1846 → 1848