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

 #include "sns_irTransceive.h"
 #ifdef sns_irTransceive_USEEEPROM
 #include "sns_irTransceive_eeprom.h"
 struct eeprom_sns_irTransceive EEMEM eeprom_sns_irTransceive =
         CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO,
 ,
         CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO,
 ,
     },
-  /* crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts */
+  /* crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts. */
 };
 #endif
 #if IR_RX_ENABLE==1
 struct {
     uint8_t             rxlen;
     uint8_t             timerNum;
     Ir_Protocol_Data_t  proto;
     uint8_t             newData;
 } irRxChannel[IR_SUPPORTED_NUM_CHANNELS];
 #endif
 #if IR_TX_ENABLE==1
 struct {
     uint8_t             state;
     uint16_t            *txbuf;
     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];
 StdCan_Msg_t        irTxMsg;
 #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 */
+    /* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol. */
     StdCan_Set_class(dbgIrTxMsg.Header, CAN_MODULE_CLASS_SNS);
     StdCan_Set_direction(dbgIrTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
     dbgIrTxMsg.Length = 8;
     dbgIrTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
         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 */
+        /* 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 */
+        /* 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);
     }
 }
 #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
     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 */
+    /* 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;
     _delay_ms(1);
+}
 #if sns_irTransceive_PRONTO_SUPPORT==1
 volatile uint32_t sns_irTransceive_LastPronto=0;
-static uint8_t activeChannel = 0;
+static uint8_t prontoAllocatedTxChannel = -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;
+}
 #define sns_irTransceive_MAXTIMING (16*1000)
 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;
     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 timing command */
+    /* 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 */
+        /* 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 */
+        /* 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 */
+    /* Send pronto start. */
     msg.Length = 8;
     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART;
-    msg.Data[0] = ((channel<<4)|0x0);   /* Channel and Prontoformat 0x0000 */
+    msg.Data[0] = ((channel<<4)|0x0);   /* Channel and Prontoformat 0x0000. */
     msg.Data[1] = 0x00;
-    msg.Data[2] = (divider & 0xFF00) >> 8;  /* Freq divider */
+    msg.Data[2] = (divider & 0xFF00) >> 8;  /* Freq divider. */
     msg.Data[3] = (divider & 0x00FF) >> 0;
-    msg.Data[4] = 0x00; /* Once seq length, first byte always 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[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 */
+    /* 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 */
+    /* Counter for buffer. */
     uint8_t i = 0;
-    /* Counter for filling can frame data */
+    /* Counter for filling can frame data. */
     uint8_t j = 0;
-    /* Remember byte if data does not fit 8 bit */
+    /* 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 */
+            /* If byte was memorized then buffer it. */
             msg.Data[j] = mem;
-            /* Clear memory */
+            /* Clear memory. */
             mem = 0;
+        }
         else
+        {
-            /* Convert µs 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 */
+                /* If data does not fit into 8 bit, then split, memorize low byte. */
                 mem = data&0xff;
-                /* Buffer high byte */
+                /* Buffer high byte. */
                 msg.Data[j] = (data>>8)&0xff;
                 j++;
                 if (j==8)
+                {
-                    /* If send buffer is full, send frame */
+                    /* If send buffer is full, send frame. */
-                    /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
+                    /* 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 */
+                /* Set complementary burst pair to 0 to indicate 16bit transmission. */
                 msg.Data[j] = 0;
+            }
             else
+            {
                 msg.Data[j] = data&0xff;
+        }
         j++;
         if (j==8)
+        {
-            /* If send buffer is full, send frame */
+            /* If send buffer is full, send frame. */
-            /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
+            /* 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 */
+    /* 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 */
+        /* If send buffer is full, send frame. */
-        /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
+        /* 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;
     j++;
     msg.Data[j] = (IR_MAX_PULSE_WIDTH/((1000000ULL*109)/sns_irTransceive_BaseFrq))&0xff;
     j++;
     if (j==8)
+    {
-        /* If send buffer is full, send frame */
+        /* If send buffer is full, send frame. */
-        /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
+        /* 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 command kept from for loop, but increase 16 to send ProntoEnd */
+    /* Msg command kept from for loop, but increase 16 to send ProntoEnd. */
     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1 + seqNr;
     msg.Length = j;
-    /* data kept from loop, if any */
+    /* Data kept from loop, if any. */
-    /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
+    /* 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;
 #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)
     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 */
+    /* Configure all TX VCC pins as outputs and disable them. */
     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);
     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
-    /* TX-pins must be set in case transmitter is nexa */
+    /* TX-pins must be set in case transmitter is nexa. */
     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
-    /* IR tx power pins on PCA95xx */
+    /* IR tx power pins on PCA95xx. */
 #if sns_irTransceive_ENABLE_PCA95xx==1
     Pca95xx_Init(0);
     Pca95xx_clr_pin(sns_irTransceive_TX0_PWRl);
     Pca95xx_set_out(sns_irTransceive_TX0_PWRl);
 #endif
 #ifdef sns_irTransceive_USEEEPROM
     if (EEDATA_OK)
+    {
-      /* Use stored data to set initial values for the module */
+      /* Use stored data to set initial values for the module. */
         sns_irTransceive_setConfig(0, eeprom_read_byte(EEDATA.ch0_config), eeprom_read_byte(EEDATA.ch0_txpower), eeprom_read_word(EEDATA16.ch0_modfreq));
         sns_irTransceive_setConfig(1, eeprom_read_byte(EEDATA.ch1_config), eeprom_read_byte(EEDATA.ch1_txpower), eeprom_read_word(EEDATA16.ch1_modfreq));
         sns_irTransceive_setConfig(2, eeprom_read_byte(EEDATA.ch2_config), eeprom_read_byte(EEDATA.ch2_txpower), eeprom_read_word(EEDATA16.ch2_modfreq));
+    }
     else
+    {
-    /* The CRC of the EEPROM is not correct, store default values and update CRC */
+    /* The CRC of the EEPROM is not correct, store default values and update CRC. */
         eeprom_write_byte_crc(EEDATA.ch0_config, CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO, WITHOUT_CRC);
         eeprom_write_byte_crc(EEDATA.ch0_txpower, 0, WITHOUT_CRC);
         eeprom_write_word_crc(EEDATA16.ch0_modfreq, sns_irTransceive_BaseFrq/38000UL, WITHOUT_CRC);
         eeprom_write_byte_crc(EEDATA.ch1_config, CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO, WITHOUT_CRC);
         eeprom_write_byte_crc(EEDATA.ch1_txpower, 0, WITHOUT_CRC);
         switch (irRxChannel[channel].state)
+        {
         case sns_irTransceive_STATE_IDLE:
+        {
             if (irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
-                /* Send button release command on CAN */
+                /* Send button release command on CAN. */
                 irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED;
                 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;
             break;
         case sns_irTransceive_STATE_RECEIVING:
             if (irRxChannel[channel].newData == TRUE) {
 //printf("sRx\n");
-                /* 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();
-                /* Let protocol driver parse and then send on CAN */
+                /* 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;
                     pronto_sendData(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, channel, irRxChannel[channel].proto.modfreq);
                     irRxChannel[channel].proto.timeout=1;
 #endif
+                }
-                /* Enable the receiver again */
+                /* Enable the receiver again. */
                 IrTransceiver_EnableRx(channel);
                 irRxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
 //gpio_clr_pin(EXP_H);
 //gpio_clr_pin(EXP_J);
+            }
             break;
         case sns_irTransceive_STATE_START_PAUSE:
 //printf("sP\n");
-            /* set a timer so we can send release button event when no new IR is arriving */
+            /* 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 */
+            /* Reset timer if new IR arrived. */
             if (irRxChannel[channel].newData == TRUE || IrTransceiver_GetStoreEnableRx(channel) == TRUE) {
 //printf("sT\n");
                 cli();
                 irRxChannel[channel].newData = FALSE;
                 sei();
+            }
             if (Timer_Expired(irRxChannel[channel].timerNum)) {
 //printf("sD\n");
                 irRxChannel[channel].state = sns_irTransceive_STATE_IDLE;
             }
             break;
         default:
             break;
+        }
 #if IR_TX_ENABLE==1
         switch (irTxChannel[channel].state)
+        {
         case sns_irTransceive_STATE_IDLE:
+        {
-            /* transmission is started when a command is received on can */
+            /* Transmission is started when a command is received on can. */
             irTxChannel[channel].stopSend = FALSE;
             irTxChannel[channel].repeatCount = 0;
             irTxChannel[channel].proto.framecnt = 0;
             irTxChannel[channel].sendingPronto = FALSE;
             break;
                 break;
+            }
             /* Start IR transmission. */
             /* TODO Send respone. Function call may fail when different modulation frequencies are used simultaneously. */
             IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen, irTxChannel[channel].proto.modfreq);
             /* Enter transmitting state. */
             irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
             break;
+        }
         case sns_irTransceive_STATE_START_TRANSMIT_PRONTO:
+        {
             /* Once sequence exists? */
             if (irTxChannel[channel].onceSeqLen>0) {
                 /* Start IR transmission of the once sequence. */
+                int res;
-                if(IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].onceSeqLen - 1, irTxChannel[channel].proto.modfreq) < 0) {
+                if((res=IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].onceSeqLen - 1, irTxChannel[channel].proto.modfreq)) < 0) {
-                    /* Send error code. */
+                    /* Send response code. */
+                    switch (res) {
+                        case -1: /* Invalid freq. */
+                        case -2: /* No data. */
+                            /* Generic error code, probably invalid packet. */
-                    pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
+                            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+                            break;
+                        case -3: /* Channel busy. */
+                            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_CHANNELBUSY);
+                            break;
+                        case -4: /* Frequency cannot be changed due to transmission on other channels. */
+                            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_OTHERFREQUENCYLOCKED);
+                            break;
+                    }
                     /* Enter idle state. */
                     irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+                    prontoAllocatedTxChannel = -1;
                     break;
+                }
                 else {
                     /* Enter transmitting state. */
-                                irTxChannel[channel].sendingPronto = TRUE;
+                    irTxChannel[channel].sendingPronto = TRUE;
-                                irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
+                    irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
                     break;
+                }
             }
             /* Repeat sequence exists? */
             else if (irTxChannel[channel].repSeqLen>0) {
                 /* Start IR transmission of the repeat sequence. */
+                int res;
-                    if(IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].repSeqLen - 1, irTxChannel[channel].proto.modfreq) < 0) {
+                if((res=IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].repSeqLen - 1, irTxChannel[channel].proto.modfreq)) < 0) {
+                    /* Send response code. */
+                    switch (res) {
+                        case -1: /* Invalid freq. */
+                        case -2: /* No data. */
-                                        /* Send error code. */
+                            /* Generic error code, probably invalid packet. */
-                                        pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
+                            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+                            break;
+                        case -3: /* Channel busy. */
+                            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_CHANNELBUSY);
+                            break;
+                        case -4: /* Frequency cannot be changed due to transmission on other channels. */
+                            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_OTHERFREQUENCYLOCKED);
+                            break;
+                    }
-                                        /* Enter idle state. */
+                    /* Enter idle state. */
-                                        irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+                    irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
-                                        break;
+                    prontoAllocatedTxChannel = -1;
-                                }
+                    break;
+                }
                 else {
-                                        /* Enter transmitting state. */
+                    /* Enter transmitting state. */
-                                        irTxChannel[channel].sendingPronto = TRUE;
+                    irTxChannel[channel].sendingPronto = TRUE;
-                                        irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
+                    irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
                     break;
-                                }
+                }
+            }
             /* Neither once sequence nor repeat sequence exists! */
-            /* Send error code. */
+            /* Generic error code, probably invalid packet. */
-                        pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
-                        /* Enter idle state. */
+            /* Enter idle state. */
-                        irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+            irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+            prontoAllocatedTxChannel = -1;
-                        break;
+            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) {
-                /* Pronto transmission was stopped/completed */
+                /* Pronto transmission was stopped/completed. */
                 pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_STOPPED);
                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+                prontoAllocatedTxChannel = -1;
                 break;
             }
             if (irTxChannel[channel].repeatCount < 255) {
                 irTxChannel[channel].repeatCount++;
+            }
             /* 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, ((uint16_t)irTxChannel[channel].repSeqLen) - 1, irTxChannel[channel].proto.modfreq);
             }
             /* Once sequence exists? */
             else if (irTxChannel[channel].onceSeqLen > 0) {
-                /* 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].proto.modfreq);
             }
             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;
+                }
             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)
+            {
-                /* Non-pronto transmission was stopped/completed */
+                /* Non-pronto transmission was stopped/completed. */
+                // TODO: use another non-pronto code here? /jm
                 pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_STOPPED);
                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
+            }
             break;
         }
         default:
             break;
         }
 #endif
     }
+}
-/* Handle incoming CAN data */
+/* Handle incoming CAN data. */
 void sns_irTransceive_HandleMessage(StdCan_Msg_t *rxMsg)
 {
     /* 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 button status. */
         uint8_t buttonStatus = rxMsg->Data[0] & 0x0F;
         /* Sanity check. */
         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
-            /* Invalid channel */
+            /* Invalid channel. */
             break;
+        }
-        /* Check if channel is busy sending Pronto */
+        /* Check if channel is busy sending Pronto. */
         if (irTxChannel[channel].sendingPronto) {
-            /* Channel busy */
+            /* Channel busy. */
             break;
+        }
         if (buttonStatus == 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 = irTxChannel[channel].proto.data<<8;
                 irTxChannel[channel].proto.data |= rxMsg->Data[3];
                 irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
                 irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
+            }
+        }
         else if (buttonStatus == 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
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART:
     {
         /* Get IR channel. */
         uint8_t channel = rxMsg->Data[0] >> 4;
         /* Sanity check. */
         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
+            /* Invalid channel. Generic error code. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
+        /* Check channel configuration. */
+        if (irTxChannel[channel].state == sns_irTransceive_STATE_DISABLED) {
-            /* Invalid channel */
+            /* Not a TX channel. */
             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
             break;
         }
+        /* Check if channel is busy. */
         if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) {
-            /* We're already transmitting on this channel */
+            /* We're already transmitting on this channel. */
-            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_CHANNELBUSY);
             break;
         }
         /* Check if format is supported. */
         if ((((uint16_t)(rxMsg->Data[0] & 0x0F) << 8) | (uint16_t)(rxMsg->Data[1])) != 0) {
-            /* Invalid pronto format */
+            /* Invalid pronto format. Generic error code. */
             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
+        /* Check if any other pronto transmission is ongoing (i.e. if the pronto activeChannel is busy). */
+        if (prontoChannelIsAllocated() && irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_IDLE) {
+            /* Pronto data is already being transmitted (or prepared) on another channel. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_ALREADYSENDINGPRONTO);
             break;
+        }
         /* Extract received data. */
         uint32_t divider = (rxMsg->Data[2] << 8) | (rxMsg->Data[3] << 0);
         if (divider == 0) {
-            /* Invalid wFrqDiv value */
+            /* Invalid wFrqDiv value. Generic error code. */
             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
             break;
+        }
         uint32_t freqkHz = (sns_irTransceive_BaseFrq / (divider*1000));
         if (freqkHz == 0) {
-            /* Invalid wFrqDiv value */
+            /* Invalid wFrqDiv value. Generic error code. */
             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
             break;
+        }
         irTxChannel[channel].proto.modfreq = freqkHz;
-        /* TODO: reconfigure with new modfreq, if no other channels sending pronto */
+        /* In case other channels are busy sending with other modfreqs, this will be reported by IrTransceiver_Transmit. */
-        /* 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));
         /* 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;
+        prontoAllocatedTxChannel = channel;
-        /* We're now waiting for pronto data */
+        /* We're now waiting for pronto data. */
         pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_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) {
-            /* Invalid channel */
+            /* Invalid channel. */
             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
+        /* Check channel configuration. */
+        if (irTxChannel[channel].state == sns_irTransceive_STATE_DISABLED) {
+            /* Not a TX channel. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
             break;
         }
         irTxChannel[channel].stopSend = TRUE;
+        if (!prontoChannelIsAllocated()) {
+            /* Nothing to stop. No pronto TX channel allocated right now. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
+            break;
+        }
         /* State check. If we're not currently transmitting anything, the STOPPED reponse will never occur. */
-        /* TODO: better way to check this? /jm */
+        if (prontoChannelIsAllocated() &&
-        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_PAUSING &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_PAUSING &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_PAUSE)
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_START_PAUSE)
+        {
-            /* Nothing to stop. Not in TX state. Respond that we're already stopped */
+            /* Nothing to stop. Not in TX state. Respond that we're already stopped. */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
+            break;
+        }
+        /* Is pronto activeChannel active, but wrong channel specified? */
+        if (prontoChannelIsAllocated() && prontoAllocatedTxChannel != channel) {
+            /* Wrong pronto channel specified. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR_WRONGPRONTOCHANNEL);
             break;
+        }
-        /* Response will be sent when transmission has been completed (i.e. stopped) */
+        /* Response will be sent when transmission has been completed (i.e. 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 */
+            /* Invalid channel. */
             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
             break;
+        }
+        /* Check channel configuration. */
+        if (irTxChannel[channel].state == sns_irTransceive_STATE_DISABLED) {
+            /* Not a TX channel. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
+        /* Check if channel is busy. */
+        if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) {
+            /* We're already transmitting on this channel. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_BUSY_CHANNELBUSY);
+            break;
+        }
+        if (!prontoChannelIsAllocated()) {
+            /* Nothing to continue. No pronto TX channel allocated right now. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
+            break;
+        }
-        /* State check. We must already be in some transmit state */
+        /* State check. We must already be in some transmit state. */
-        /* TODO: better way to check this? /jm */
+        if (prontoChannelIsAllocated() &&
-        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_PAUSING &&
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_PAUSING &&
-            irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_PAUSE)
+            irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_START_PAUSE)
+        {
-            /* Too late to continue! Not in TX state anymore */
+            /* Too late to continue! Not in TX state anymore. */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
+            break;
+        }
+        /* Is pronto activeChannel active, but wrong channel specified? */
+        if (prontoChannelIsAllocated() && prontoAllocatedTxChannel != channel) {
+            /* Wrong pronto channel specified. */
+            pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR_WRONGPRONTOCHANNEL);
             break;
+        }
         /* Reset repeat counter, i.e. request additional repeats. */
         irTxChannel[channel].repeatCount = 0;
-        /* The repeat period was extended. Still transmitting */
+        /* The repeat period was extended. Still transmitting. */
         pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_TRANSMITTING);
         break;
     }
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA2:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA2:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA3:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA3:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA4:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA4:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA5:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA5:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA6:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA6:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA7:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA7:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA8:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA8:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA9:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA9:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA10: /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA10: /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA11: /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA11: /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA12: /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA12: /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA13: /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA13: /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA14: /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA14: /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA15: /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA15: /* Fall through. */
     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA16:
+    {
+        if (!prontoChannelIsAllocated()) {
+            /* Invalid state. */
+            pronto_sendResponse(0, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
-        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
+        if (irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
-            /* Invalid state. CAN msg probably out of order */
+            /* Invalid state. CAN msg probably out of order. */
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
+        if ((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1) != (irTxChannel[prontoAllocatedTxChannel].expectedSeqNr % 16)) {
+            /* Unexpected CAN msg, out of order. */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            irTxChannel[prontoAllocatedTxChannel].state = sns_irTransceive_STATE_IDLE;
             break;
+        }
-        if ((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
-            /* Unexpected CAN msg, out of order */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
-            irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
-            break;
-        }
-        /* Decode pronto data */
+        /* Decode pronto data. */
         for (uint8_t i = 0; i < rxMsg->Length; i++) {
-            if (decodeProntoData(activeChannel, rxMsg->Data[i]) != 1) {
+            if (decodeProntoData(prontoAllocatedTxChannel, rxMsg->Data[i]) != 1) {
-                /* Decode error */
+                /* Decode error. */
-                pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+                pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
-                irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
+                irTxChannel[prontoAllocatedTxChannel].state = sns_irTransceive_STATE_IDLE;
                 return;
             }
         }
-        irTxChannel[activeChannel].expectedSeqNr++;
+        irTxChannel[prontoAllocatedTxChannel].expectedSeqNr++;
-        /* We're still waiting for more pronto data, or for pronto end */
+        /* We're still waiting for more pronto data, or for pronto end. */
-        pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_WAITING);
+        pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_WAITING);
         break;
+    }
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND2:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND2:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND3:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND3:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND4:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND4:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND5:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND5:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND6:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND6:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND7:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND7:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND8:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND8:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND9:   /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND9:   /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND10:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND10:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND11:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND11:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND12:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND12:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND13:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND13:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND14:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND14:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND15:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND15:  /* Fall through. */
-    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND16:  /* Fall through */
+    case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND16:  /* Fall through. */
+    {
+        if (!prontoChannelIsAllocated()) {
+            /* Invalid state. */
+            pronto_sendResponse(0, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            break;
+        }
-        if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
+        if (irTxChannel[prontoAllocatedTxChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
-            /* Invalid state. CAN msg probably out of order */
+            /* Invalid state. CAN msg probably out of order. */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
             break;
         }
-        if (((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1) % 16) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
+        if (((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1) % 16) != (irTxChannel[prontoAllocatedTxChannel].expectedSeqNr % 16)) {
-            /* Unexpected CAN msg, out of order */
+            /* Unexpected CAN msg, out of order. */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
-            irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
+            irTxChannel[prontoAllocatedTxChannel].state = sns_irTransceive_STATE_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) {
+            if (decodeProntoData(prontoAllocatedTxChannel, rxMsg->Data[i]) < 0) {
-                /* Decode error */
+                /* Decode error. */
-                pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+                pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
-                irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
+                irTxChannel[prontoAllocatedTxChannel].state = sns_irTransceive_STATE_IDLE;
                 return;
+            }
         }
-        /* Sanity check */
+        /* Sanity check. */
-        if (irTxChannel[activeChannel].txlen != (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen))) {
+        if (irTxChannel[prontoAllocatedTxChannel].txlen != (((uint16_t)irTxChannel[prontoAllocatedTxChannel].onceSeqLen + (uint16_t)irTxChannel[prontoAllocatedTxChannel].repSeqLen))) {
-            /* Length doesn't match the expected length */
+            /* Length doesn't match the expected length. */
-            pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
+            pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
-            irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
+            irTxChannel[prontoAllocatedTxChannel].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[prontoAllocatedTxChannel].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[prontoAllocatedTxChannel].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 µs */
+        /* Convert pronto data to µs. */
-        uint32_t nsPerTick = 1000000UL / ((uint32_t)irTxChannel[activeChannel].proto.modfreq);
+        uint32_t nsPerTick = 1000000UL / ((uint32_t)irTxChannel[prontoAllocatedTxChannel].proto.modfreq);
-        for (uint16_t i = 0; i < irTxChannel[activeChannel].txlen; i++) {
+        for (uint16_t i = 0; i < irTxChannel[prontoAllocatedTxChannel].txlen; i++) {
-            uint32_t us = (((uint32_t)irTxChannel[activeChannel].txbuf[i]) * nsPerTick) / 1000UL;
+            uint32_t us = (((uint32_t)irTxChannel[prontoAllocatedTxChannel].txbuf[i]) * nsPerTick) / 1000UL;
             if (us > 0xFFFFUL) {
                 us = 0xFFFFUL;
+            }
-            irTxChannel[activeChannel].txbuf[i] = (uint16_t)us;
+            irTxChannel[prontoAllocatedTxChannel].txbuf[i] = (uint16_t)us;
+        }
-        /* Send IR data */
+        /* Send IR data. */
-        irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
+        irTxChannel[prontoAllocatedTxChannel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
-        /* We're now transmitting the pronto data */
+        /* We're now transmitting the pronto data. */
-        pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_TRANSMITTING);
+        pronto_sendResponse(prontoAllocatedTxChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_TRANSMITTING);
         break;
+    }
-/* TODO: In IR state machine add sending a response frame when ir stops sending, also implement pronto repeat */
+/* 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:
+    {
         /* Get IR channel. */
         uint8_t channel = rxMsg->Data[0] >> 4;
         /* Sanity check. */
         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
-            /* Invalid channel */
+            /* 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 1938 → 1941