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

     uint8_t             timerNum;
     uint8_t             repeatCount;
     Ir_Protocol_Data_t  proto;
     uint8_t             stopSend;
     uint8_t             sendComplete;
-    // pronto params
+    /* Pronto params */
     uint8_t             sendingPronto;
     uint8_t             onceSeqLen;
     uint8_t             repSeqLen;
     uint8_t             expectedSeqNr;
 } irTxChannel[IR_SUPPORTED_NUM_CHANNELS];
 #if sns_irTransceive_PRONTO_SUPPORT==1
 volatile uint32_t sns_irTransceive_LastPronto=0;
 static uint8_t activeChannel = 0;
 #define sns_irTransceive_MAXTIMING (16*1000)
+typedef enum {
+    PRONTO_RESPONSE_OK              = 0,
+    PRONTO_RESPONSE_STOPPED         = 1,
+    PRONTO_RESPONSE_WAITING         = 2,
+    PRONTO_RESPONSE_TRANSMITTING    = 4,
+    PRONTO_RESPONSE_ALREADY_STOPPED = 241,
+    PRONTO_RESPONSE_ABORTED         = 243,
+    PRONTO_RESPONSE_ERROR           = 255,
+} prontoResponse_t;
+static void pronto_sendResponse(uint8_t channel, prontoResponse_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.Length = 3;
+    msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTORESPONSE;
+    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 void send_pronto(uint16_t *buffer, uint8_t len, uint8_t channel, uint16_t modfreq)
+static void pronto_sendData(uint16_t *buffer, uint8_t len, uint8_t channel, uint16_t modfreq)
+{
     uint32_t currentTime = Timer_GetTicks();
     StdCan_Msg_t msg;
     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
+        uint32_t elapsedTime = ((currentTime - sns_irTransceive_LastPronto) * 1000) & 0x00FFFFFFUL; /* 24bit value */
         /* Remove length of the last received sequence */
-        uint32_t sequenceLength = IR_MAX_PULSE_WIDTH; // timeout value not included in buffer
+        uint32_t sequenceLength = IR_MAX_PULSE_WIDTH; /* timeout value not included in buffer */
         for (uint8_t i = 0; i < len; i++) {
             sequenceLength += (uint32_t)buffer[i];
+        }
         if (sequenceLength <= elapsedTime) {
             elapsedTime -= sequenceLength;
         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
         _delay_ms(1);
+    }
     sns_irTransceive_LastPronto = currentTime;
-    // calculate frequency divider
+    /* Calculate frequency divider */
     uint16_t divider = (uint16_t)(sns_irTransceive_BaseFrq / (1000*(uint32_t)modfreq));
     /* Send pronto start */
     msg.Length = 8;
     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART;
     msg.Data[3] = (divider & 0x00FF) >> 0;
     msg.Data[4] = 0x00; /* Once seq length, first byte always 0 */
     msg.Data[5] = (len + 1) / 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);
     /* Send pronto data */
     //uint16_t divider = ((1000000ULL*modfreq)/sns_irTransceive_BaseFrq);
     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1;
     uint8_t seqNr = 0;
     /* Counter for buffer */
     /* 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 us to pronto hex modulation pulses
+            /* Convert µs to pronto hex modulation pulses */
             uint16_t data = (uint16_t)(((uint32_t)buffer[i] * (uint32_t)modfreq) / 1000);
-            // protocol compression
+            /* 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&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 */
         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
         _delay_ms(1);
+{
     static uint8_t waitingForLSB = FALSE;
     static uint8_t previousValueWas16bit = FALSE;
     if (irTxChannel[channel].txlen >= MAX_NR_TIMES) {
-        // max length exceeded
+        /* Max length exceeded */
         return -1;
+    }
     if (irTxChannel[channel].txlen == 0) {
         waitingForLSB = FALSE;
         if (data == 0) {
-            // cannot start with 0x00
+            /* Cannot start with 0x00 */
             return -2;
+        }
+    }
-    // 0x00 means that previously received time is MSB of 16bit value, and that next byte will be LSB
+    /* 0x00 means that previously received time is MSB of 16bit value, and that next byte will be LSB */
     if (data == 0 && !waitingForLSB && previousValueWas16bit==FALSE) {
-        // convert previous time to MSB of the 16bit value. next received byte will become LSB
+        /* 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
+        /* Flag that next received byte is LSB rather than a new timing value */
         waitingForLSB = TRUE;
+    }
-    // non-zero value! is this part of a 16bit-value? use the data as LSB for previously received time
+    /* Non-zero value! is this part of a 16bit-value? use the data as LSB for previously received time */
     else if (waitingForLSB) {
-        // let this byte be LSB of previous 16bit value
+        /* 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
+        /* We've now completed reception of the 16bit value */
         waitingForLSB = FALSE;
         previousValueWas16bit = TRUE;
+    }
-    // non-zero value! simply new 8bit value
+    /* Non-zero value! simply new 8bit value */
     else {
-        // check if we're already done
+        /* Check if we're already done */
         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
+            /* Too much data received, not necessarily a problem in case frames are padded */
             return 2;
+        }
         irTxChannel[channel].txbuf[irTxChannel[channel].txlen] = data;
     return 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
 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;
                     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].modfreq = modfreq;
             irTxChannel[channel].txbuf = buf[channel];
             switch (channel)
+            {
                 case 0:
 #if IR_RX_ENABLE==1
                     gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
                     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_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:
                     Pca95xx_set_out(sns_irTransceive_TX2_PWRl);
                     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[i].proto.protocol=0;
 #endif
+    }
 #if IR_RX_ENABLE==1
-    // TODO: hardcoded to 3 channels?? /jm
-    irRxChannel[0].timerNum=sns_irTransceive_RX0_REPEATE_TIMER;
+    if (IR_SUPPORTED_NUM_CHANNELS>=1) irRxChannel[0].timerNum=sns_irTransceive_RX0_REPEATE_TIMER;
-    irRxChannel[1].timerNum=sns_irTransceive_RX1_REPEATE_TIMER;
+    if (IR_SUPPORTED_NUM_CHANNELS>=2) irRxChannel[1].timerNum=sns_irTransceive_RX1_REPEATE_TIMER;
-    irRxChannel[2].timerNum=sns_irTransceive_RX2_REPEATE_TIMER;
+    if (IR_SUPPORTED_NUM_CHANNELS>=3) irRxChannel[2].timerNum=sns_irTransceive_RX2_REPEATE_TIMER;
 #endif
 #if IR_TX_ENABLE==1
-    // TODO: hardcoded to 3 channels?? /jm
-    irTxChannel[0].timerNum=sns_irTransceive_TX0_REPEATE_TIMER;
+    if (IR_SUPPORTED_NUM_CHANNELS>=1) irTxChannel[0].timerNum=sns_irTransceive_TX0_REPEATE_TIMER;
-    irTxChannel[1].timerNum=sns_irTransceive_TX1_REPEATE_TIMER;
+    if (IR_SUPPORTED_NUM_CHANNELS>=2) irTxChannel[1].timerNum=sns_irTransceive_TX1_REPEATE_TIMER;
-    irTxChannel[2].timerNum=sns_irTransceive_TX2_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 */
     gpio_set_out(sns_irTransceive_VCC_EN0_PIN);
             irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
             break;
         case sns_irTransceive_STATE_RECEIVING:
             if (irRxChannel[channel].newData == TRUE) {
-                //TODO: move this line to the RX callback
+                /* TODO: move this line to the RX callback */
                 IrTransceiver_DisableRx(channel);
                 cli();
                 irRxChannel[channel].newData = FALSE;
                 sei();
+                {
 #if (sns_irTransceive_SEND_DEBUG==1)
                     send_debug(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen);
                     irRxChannel[channel].proto.timeout=300;
 #elif sns_irTransceive_PRONTO_SUPPORT==1
-                    send_pronto(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, channel, irRxChannel[channel].modfreq);
+                    pronto_sendData(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, channel, irRxChannel[channel].modfreq);
                     irRxChannel[channel].proto.timeout=1;
 #endif
+                }
                 /* Enable the receiver again */
                 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 */
         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;
+        }
         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) || irTxChannel[channel].stopSend) {
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
                 break;
+            }
             if (irTxChannel[channel].repeatCount < 255) {
                 irTxChannel[channel].repeatCount++;
             }
-            // repeat sequence exists?
+            /* Repeat sequence exists? */
             if (irTxChannel[channel].repSeqLen != 0) {
-                // use repeat seq
+                /* Use repeat seq */
                 uint16_t offset = ((uint16_t)irTxChannel[channel].onceSeqLen);
-                // don't transmit last passive. last passive handled by timer
+                /* Don't transmit last passive. last passive handled by timer */
                 IrTransceiver_Transmit(channel, &irTxChannel[channel].txbuf[offset], 0, ((uint16_t)irTxChannel[channel].repSeqLen) - 1);
             }
             else {
-                // use once seq
+                /* Use once seq */
-                // don't transmit last passive. last passive handled by timer
+                /* 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)
                 {
-                    // first repeat, or no repeat sequence defined => use last passive time in once seq
+                    /* 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
+                        /* 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
+                    /* Second, or later repeat => use last passive time in repeat seq */
                     else
+                    {
-                        // use last passive time as timeout
+                        /* 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)
+            {
             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))
             {
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
             }
-            /* transmission is stopped when such command is recevied on can */
+            /* Transmission is stopped when such command is recevied on can */
             if (irTxChannel[channel].stopSend == TRUE && irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
+            {
-                //TODO maybe send message on can for status? to confirm stopped sending, ready for new command
+                /* 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;
             irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
             break;
         default:
             break;
+        }
 #endif
+    }
+}
     /* Sanity check. */
     if (StdCan_Ret_class(rxMsg->Header) != CAN_MODULE_CLASS_SNS ||
         StdCan_Ret_direction(rxMsg->Header) != DIRECTIONFLAG_TO_OWNER ||
         rxMsg->Header.ModuleType != CAN_MODULE_TYPE_SNS_IRTRANSCEIVE ||
         rxMsg->Header.ModuleId != sns_irTransceive_ID) return;
-    /* Get IR channel. */
-    uint8_t channel = rxMsg->Data[0] >> 4;
     switch (rxMsg->Header.Command)
     {
 #if IR_TX_ENABLE==1
     case CAN_MODULE_CMD_PHYSICAL_IR:
+    {
+        /* Get IR channel. */
+        uint8_t channel = rxMsg->Data[0] >> 4;
+        /* Sanity check. */
+        if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
+            /* Invalid channel */
+            break;
+        }
-        if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED && channel < IR_SUPPORTED_NUM_CHANNELS)
+        if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED)
         {
             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 |= 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)
+        else if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED)
+        {
             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:
-    channel, pronto receive state, buffer length of once burst pairs, buffer length of repeat burst pairs */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART:
+    {
+        /* Get IR channel. */
+        uint8_t channel = rxMsg->Data[0] >> 4;
         /* Sanity check. */
-        if (channel >= IR_SUPPORTED_NUM_CHANNELS) break;
+        if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
+            /* Invalid channel */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ERROR);
+            break;
+        }
-        if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) break;
+        if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) {
+            /* We're already transmitting on this channel */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ABORTED);
+            break;
+        }
         /* Check if format is supported. */
-        if ((((uint16_t)(rxMsg->Data[0] & 0x0F) << 8) | (uint16_t)(rxMsg->Data[1])) != 0) break;
+        if ((((uint16_t)(rxMsg->Data[0] & 0x0F) << 8) | (uint16_t)(rxMsg->Data[1])) != 0) {
+            /* Invalid pronto format */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ERROR);
+            break;
+        }
         /* Extract received data. */
         uint32_t divider = (rxMsg->Data[2] << 8) | (rxMsg->Data[3] << 0);
         if (divider == 0) {
-            // invalid modfreq
+            /* Invalid wFrqDiv value */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ERROR);
             break;
+        }
         uint32_t freqkHz = (sns_irTransceive_BaseFrq / (divider*1000));
         if (freqkHz == 0) {
-            // invalid modfreq
+            /* Invalid wFrqDiv value */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ERROR);
             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: reconfigure with new modfreq, if no other channels sending pronto */
-        //irTxChannel[channel].proto.modfreq = (((F_CPU/2000)/IR_NEC_F_MOD) -1);
-        // convert lenghts to bytes
+        /* Convert lenghts to bytes */
         irTxChannel[channel].onceSeqLen = 2*((((uint16_t)rxMsg->Data[4]) << 8) | (((uint16_t)rxMsg->Data[5]) << 0));
         irTxChannel[channel].repSeqLen = 2*((((uint16_t)rxMsg->Data[6]) << 8) | (((uint16_t)rxMsg->Data[7]) << 0));
-        //printf("ONCE%04u", irTxChannel[channel].onceSeqLen);
-        //printf("REQL%04u", irTxChannel[channel].repSeqLen);
         /* Enter prepering pronto state and clear transmit buffer. */
         irTxChannel[channel].state = sns_irTransceive_STATE_PREPARING_PRONTO;
         irTxChannel[channel].txlen = 0;
         irTxChannel[channel].expectedSeqNr = 0;
         activeChannel = channel;
-        /* TODO: Send response frame */
+        /* We're now waiting for pronto data */
+        pronto_sendResponse(channel, PRONTO_RESPONSE_WAITING);
         break;
+    }
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTOP:
+    {
+        /* Get IR channel. */
+        uint8_t channel = rxMsg->Data[0] >> 4;
         /* Sanity check. */
-        if (channel >= IR_SUPPORTED_NUM_CHANNELS) break;
+        if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
+            /* Invalid channel */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ERROR);
+            break;
+        }
         irTxChannel[channel].stopSend = TRUE;
+        /* Pronto transmission was stopped */
+        pronto_sendResponse(channel, PRONTO_RESPONSE_STOPPED);
+        break;
+    }
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOCONTINUE:
+    {
+        /* Get IR channel. */
+        uint8_t channel = rxMsg->Data[0] >> 4;
+        /* Sanity check. */
+        if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
+            /* Invalid channel */
+            pronto_sendResponse(channel, PRONTO_RESPONSE_ERROR);
+            break;
+        }
+        /* State check. We must already be in some transmit state */
-        /* TODO: Send response frame */
+        /* TODO: better way to check this? /jm */
+        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
+            irTxChannel[activeChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
+            irTxChannel[activeChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
+            irTxChannel[activeChannel].state != sns_irTransceive_STATE_PAUSING &&
+            irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_PAUSE)
+        {
+            /* Too late to continue! Not in TX state anymore */
+            pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ALREADY_STOPPED);
-        break;
+            break;
+        }
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOCONTINUE:
-        /* Sanity check. */
-        if (channel >= IR_SUPPORTED_NUM_CHANNELS) break;
         /* Reset repeat counter, i.e. request additional repeats. */
         irTxChannel[channel].repeatCount = 0;
-        /* TODO: Send response frame */
+        /* The repeat period was extended. Still transmitting */
+        pronto_sendResponse(channel, PRONTO_RESPONSE_TRANSMITTING);
         break;
+    }
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA2:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA3:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA4:  /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA5:  /* 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) {
+            /* Invalid state. CAN msg probably out of order */
+            pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
             break;
+        }
-        // unexpected CAN msg, out of order
         if ((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
+            /* Unexpected CAN msg, out of order */
-            printf("SEQERROR");
+            pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
             irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
             break;
+        }
-        // decode pronto data
+        /* Decode pronto data */
         for (uint8_t i = 0; i < rxMsg->Length; i++) {
             if (decodeProntoData(activeChannel, rxMsg->Data[i]) != 1) {
+                /* Decode error */
+                pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
                 irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
-                printf("DECERROR");
                 return;
+            }
+        }
         irTxChannel[activeChannel].expectedSeqNr++;
+        /* We're still waiting for more pronto data, or for pronto end */
+        pronto_sendResponse(activeChannel, PRONTO_RESPONSE_WAITING);
         break;
+    }
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1:   /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND2:   /* Fall through */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND3:   /* Fall through */
     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) {
+            /* Invalid state. CAN msg probably out of order */
+            pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
             break;
+        }
-        // unexpected CAN msg, out of order
         if (((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1) % 16) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
+            /* Unexpected CAN msg, out of order */
-            printf("SEQERROR");
+            pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
             irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
             break;
+        }
-        // decode remaining pronto data (if any). -1 because last byte is repeat count
+        /* 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");
+                /* Decode error */
+                pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
                 irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_IDLE;
                 return;
+            }
+        }
-        // sanity check
+        /* Sanity check */
-        if (irTxChannel[activeChannel].txlen != (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen)))
+        if (irTxChannel[activeChannel].txlen != (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen))) {
-        {
+            /* Length doesn't match the expected length */
+            pronto_sendResponse(activeChannel, PRONTO_RESPONSE_ERROR);
             irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
             break;
+        }
-        // last byte determines nr of repeats. 0xFF means INF, 0 means no repeats
+        /* Last byte determines nr of repeats. 0xFF means INF, 0 means no repeats */
         irTxChannel[activeChannel].proto.repeats = rxMsg->Data[rxMsg->Length - 1];
-        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
+        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
+        /* Convert pronto data to µs */
-        // TODO: calculate value
+        /* TODO: calculate actual value instead of 27 */
         for (uint16_t i = 0; i < irTxChannel[activeChannel].txlen; i++) {
             uint32_t newVal = ((uint32_t)irTxChannel[activeChannel].txbuf[i]) * 27UL;
             if (newVal > 0xFFFFUL) {
                 newVal = 0xFFFFUL;
+            }
             irTxChannel[activeChannel].txbuf[i] = (uint16_t)newVal;
+        }
-        // send
+        /* Send IR data */
         irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
-        /* TODO: Send response frame */
+        /* We're now transmitting the pronto data */
+        pronto_sendResponse(activeChannel, PRONTO_RESPONSE_TRANSMITTING);
         break;
+    }
 /* TODO: In IR state machine add sending a response frame when ir stops sending, also implement pronto repeat */
 #endif
 #endif
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG: {
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG:
+    {
+        /* Get IR channel. */
+        uint8_t channel = rxMsg->Data[0] >> 4;
+        /* Sanity check. */
+        if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
+            /* Invalid channel */
+            break;
+        }
         uint8_t config = rxMsg->Data[0] & 0x0f;
         uint8_t power = rxMsg->Data[1]>>6;
         uint32_t divider = ((uint16_t)rxMsg->Data[2] << 8) | ((uint16_t)rxMsg->Data[3] << 0);
         if (divider == 0) {
-            // invalid modfreq
+            /* Invalid modfreq */
             break;
+        }
         uint32_t modfreq = (sns_irTransceive_BaseFrq / (divider*1000));
         if (modfreq == 0) {
-            // invalid modfreq
+            /* Invalid modfreq */
             break;
+        }
         sns_irTransceive_setConfig(channel, config, power, modfreq);
 #ifdef sns_irTransceive_USEEEPROM

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_irTransceive/sns_irTransceive.c – Rev 1850 → 1854