Subversion Repositories HomeAutomation

Rev

Rev 1937 | Rev 1944 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | SVN | RSS feed

  1.  
  2. #include "sns_irTransceive.h"
  3.  
  4. #ifdef sns_irTransceive_USEEEPROM
  5. #include "sns_irTransceive_eeprom.h"
  6. struct eeprom_sns_irTransceive EEMEM eeprom_sns_irTransceive =
  7. {
  8.     {
  9.         /* Define initialization values on the EEPROM variables here.
  10.         This will generate a *.eep file that can be used to store this values to the node, can in future be done with a EEPROM module and the make-scrips.
  11.         Write the values in the exact same order as the struct is defined in the *.h file. */
  12.         CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO,
  13.         0,
  14.         CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO,
  15.         0,
  16.         CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO,
  17.         0,
  18.     },
  19.     0   /* crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts */
  20. };
  21. #endif
  22.  
  23. #if IR_RX_ENABLE==1
  24. struct {
  25.     uint8_t             state;
  26.     uint16_t            *rxbuf;
  27.     uint8_t             rxlen;
  28.     uint8_t             timerNum;
  29.     Ir_Protocol_Data_t  proto;
  30.     uint8_t             newData;
  31. } irRxChannel[IR_SUPPORTED_NUM_CHANNELS];
  32. #endif
  33.  
  34. #if IR_TX_ENABLE==1
  35. struct {
  36.     uint8_t             state;
  37.     uint16_t            *txbuf;
  38.     uint8_t             txlen;
  39.     uint8_t             timerNum;
  40.     uint8_t             repeatCount;
  41.     Ir_Protocol_Data_t  proto;
  42.     uint8_t             stopSend;
  43.     uint8_t             sendComplete;
  44.     /* Pronto params */
  45.     uint8_t             sendingPronto;
  46.     uint8_t             onceSeqLen;
  47.     uint8_t             repSeqLen;
  48.     uint8_t             expectedSeqNr;
  49. } irTxChannel[IR_SUPPORTED_NUM_CHANNELS];
  50. #endif
  51.  
  52. uint16_t    buf[IR_SUPPORTED_NUM_CHANNELS][MAX_NR_TIMES];
  53.  
  54. StdCan_Msg_t        irTxMsg;
  55.  
  56. #if (sns_irTransceive_SEND_DEBUG==1)
  57. void send_debug(uint16_t *buffer, uint8_t len) {
  58.     StdCan_Msg_t dbgIrTxMsg;
  59.     /* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
  60.  
  61.     StdCan_Set_class(dbgIrTxMsg.Header, CAN_MODULE_CLASS_SNS);
  62.     StdCan_Set_direction(dbgIrTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  63.     dbgIrTxMsg.Length = 8;
  64.     dbgIrTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  65.     dbgIrTxMsg.Header.ModuleId = sns_irTransceive_ID;
  66.     dbgIrTxMsg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRRAW;
  67.     for (uint8_t i = 0; i < len>>2; i++) {
  68.         uint8_t index = i<<2;
  69.  
  70.         dbgIrTxMsg.Data[0] = (buffer[index]>>8)&0xff;
  71.         dbgIrTxMsg.Data[1] = (buffer[index]>>0)&0xff;
  72.         dbgIrTxMsg.Data[2] = (buffer[index+1]>>8)&0xff;
  73.         dbgIrTxMsg.Data[3] = (buffer[index+1]>>0)&0xff;
  74.         dbgIrTxMsg.Data[4] = (buffer[index+2]>>8)&0xff;
  75.         dbgIrTxMsg.Data[5] = (buffer[index+2]>>0)&0xff;
  76.         dbgIrTxMsg.Data[6] = (buffer[index+3]>>8)&0xff;
  77.         dbgIrTxMsg.Data[7] = (buffer[index+3]>>0)&0xff;
  78.  
  79.         /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
  80.         while (StdCan_Put(&dbgIrTxMsg) != StdCan_Ret_OK) {}
  81.         _delay_ms(1);
  82.     }
  83.  
  84.     uint8_t lastpacketcnt = len&0x03;
  85.     if (lastpacketcnt > 0) {
  86.         dbgIrTxMsg.Length = lastpacketcnt<<1;
  87.         for (uint8_t i = 0; i < lastpacketcnt; i++) {
  88.             dbgIrTxMsg.Data[i<<1] = (buffer[(len&0xfc)|i]>>8)&0xff;
  89.             dbgIrTxMsg.Data[(i<<1)+1] = (buffer[(len&0xfc)|i]>>0)&0xff;
  90.         }
  91.         /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
  92.         while (StdCan_Put(&dbgIrTxMsg) != StdCan_Ret_OK) {}
  93.         _delay_ms(1);
  94.     }
  95.  
  96. }
  97. #endif
  98.  
  99. #define sns_irTransceive_BaseFrq (4145146UL)
  100.  
  101. #ifndef sns_irTransceive_PRONTO_SUPPORT
  102. #define sns_irTransceive_PRONTO_SUPPORT 0
  103. #endif
  104.  
  105. /*
  106.  * PRONTO HEX Routines
  107.  */
  108. static void pronto_sendResponse(uint8_t channel, uint8_t responseValue)
  109. {
  110.     StdCan_Msg_t msg;
  111.     StdCan_Set_class(msg.Header, CAN_MODULE_CLASS_SNS);
  112.     StdCan_Set_direction(msg.Header, DIRECTIONFLAG_FROM_OWNER);
  113.     msg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  114.     msg.Header.ModuleId = sns_irTransceive_ID;
  115.     /* Send response command */
  116.     msg.Length = 3;
  117.     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTORESPONSE;
  118.     msg.Data[0] = ((channel<<4)|0xf);
  119.     msg.Data[1] = 0xF0;
  120.     msg.Data[2] = (uint8_t)responseValue;
  121.     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  122.     _delay_ms(1);
  123. }
  124.  
  125. #if sns_irTransceive_PRONTO_SUPPORT==1
  126. volatile uint32_t sns_irTransceive_LastPronto=0;
  127. static uint8_t activeChannel = 0;
  128. #define sns_irTransceive_MAXTIMING (16*1000)
  129.  
  130. static void pronto_sendData(uint16_t *buffer, uint8_t len, uint8_t channel, uint16_t modfreq)
  131. {
  132.     uint32_t currentTime = Timer_GetTicks();
  133.  
  134.     StdCan_Msg_t msg;
  135.  
  136.     StdCan_Set_class(msg.Header, CAN_MODULE_CLASS_SNS);
  137.     StdCan_Set_direction(msg.Header, DIRECTIONFLAG_FROM_OWNER);
  138.     msg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  139.     msg.Header.ModuleId = sns_irTransceive_ID;
  140.  
  141.     /* Send timing command */
  142.     msg.Length = 5;
  143.     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOTIMING;
  144.  
  145.     if ((currentTime < sns_irTransceive_LastPronto+sns_irTransceive_MAXTIMING) && (sns_irTransceive_LastPronto != 0))
  146.     {
  147.         /* Calculate elapsed time since last pronto packet */
  148.         uint32_t elapsedTime = ((currentTime - sns_irTransceive_LastPronto) * 1000) & 0x00FFFFFFUL; /* 24bit value */
  149.  
  150.         /* Remove length of the last received sequence */
  151.         uint32_t sequenceLength = IR_MAX_PULSE_WIDTH; /* timeout value not included in buffer */
  152.         for (uint8_t i = 0; i < len; i++) {
  153.             sequenceLength += (uint32_t)buffer[i];
  154.         }
  155.         if (sequenceLength <= elapsedTime) {
  156.             elapsedTime -= sequenceLength;
  157.         }
  158.  
  159.         msg.Data[0] = ((channel<<4)|0xf);
  160.         msg.Data[1] = 0x10;
  161.         msg.Data[2] = (uint8_t)(elapsedTime >> 16);
  162.         msg.Data[3] = (uint8_t)(elapsedTime >> 8);
  163.         msg.Data[4] = (uint8_t)(elapsedTime >> 0);
  164.         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  165.         _delay_ms(1);
  166.     }
  167.     sns_irTransceive_LastPronto = currentTime;
  168.  
  169.     /* Calculate frequency divider */
  170.     uint16_t divider = (uint16_t)(sns_irTransceive_BaseFrq / (1000*(uint32_t)modfreq));
  171.  
  172.     /* Send pronto start */
  173.     msg.Length = 8;
  174.     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART;
  175.  
  176.     msg.Data[0] = ((channel<<4)|0x0);   /* Channel and Prontoformat 0x0000 */
  177.     msg.Data[1] = 0x00;
  178.     msg.Data[2] = (divider & 0xFF00) >> 8;  /* Freq divider */
  179.     msg.Data[3] = (divider & 0x00FF) >> 0;
  180.     msg.Data[4] = 0x00; /* Once seq length, first byte always 0 */
  181.     msg.Data[5] = (len + 1) / 2;
  182.     msg.Data[6] = 0x00; /* Repeat seq length, always 0 for ir receive */
  183.     msg.Data[7] = 0x00;
  184.  
  185.     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  186.     _delay_ms(1);
  187.  
  188.     /* Send pronto data */
  189.     //uint16_t divider = ((1000000ULL*modfreq)/sns_irTransceive_BaseFrq);
  190.     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1;
  191.     uint8_t seqNr = 0;
  192.     /* Counter for buffer */
  193.     uint8_t i = 0;
  194.     /* Counter for filling can frame data */
  195.     uint8_t j = 0;
  196.     /* Remember byte if data does not fit 8 bit */
  197.     uint8_t mem = 0;
  198.     while (i < len)
  199.     {
  200.         if (mem > 0)
  201.         {
  202.             /* If byte was memorized then buffer it */
  203.             msg.Data[j] = mem;
  204.             /* Clear memory */
  205.             mem = 0;
  206.         }
  207.         else
  208.         {
  209.             /* Convert µs to pronto hex modulation pulses */
  210.             uint16_t data = (uint16_t)(((uint32_t)buffer[i] * (uint32_t)modfreq) / 1000);
  211.  
  212.             /* Protocol compression */
  213.             if (data >= 256)
  214.             {
  215.                 /* If data does not fit into 8 bit, then split, memorize low byte */
  216.                 mem = data&0xff;
  217.                 /* Buffer high byte */
  218.                 msg.Data[j] = (data>>8)&0xff;
  219.                 j++;
  220.                 if (j==8)
  221.                 {
  222.                     /* If send buffer is full, send frame */
  223.                     /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
  224.                     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  225.                     _delay_ms(1);
  226.                     j=0;
  227.                     seqNr = (seqNr + 1) % 16;
  228.                     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
  229.                 }
  230.                 /* Set complementary burst pair to 0 to indicate 16bit transmission */
  231.                 msg.Data[j] = 0;
  232.             }
  233.             else
  234.             {
  235.                 msg.Data[j] = data&0xff;
  236.             }
  237.  
  238.             i++;
  239.         }
  240.  
  241.         j++;
  242.         if (j==8)
  243.         {
  244.             /* If send buffer is full, send frame */
  245.             /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
  246.             while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  247.             _delay_ms(1);
  248.             j=0;
  249.             seqNr = (seqNr + 1) % 16;
  250.             msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
  251.         }
  252.     }
  253.  
  254.     /* End with max pulse TODO fix uglyness */
  255.     msg.Data[j] = ((IR_MAX_PULSE_WIDTH/((1000000ULL*109)/sns_irTransceive_BaseFrq))>>8) & 0xFF;
  256.     j++;
  257.     if (j==8)
  258.     {
  259.         /* If send buffer is full, send frame */
  260.         /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
  261.         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  262.         _delay_ms(1);
  263.         j=0;
  264.         seqNr = (seqNr + 1) % 16;
  265.         msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
  266.     }
  267.     msg.Data[j] = 0;
  268.     j++;
  269.     msg.Data[j] = (IR_MAX_PULSE_WIDTH/((1000000ULL*109)/sns_irTransceive_BaseFrq))&0xff;
  270.     j++;
  271.     if (j==8)
  272.     {
  273.         /* If send buffer is full, send frame */
  274.         /* can buffers will be filled when sending more than 2-3 messages, so retry until sent */
  275.         while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  276.         _delay_ms(1);
  277.         j=0;
  278.         seqNr = (seqNr + 1) % 16;
  279.         msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1 + seqNr;
  280.     }
  281.  
  282.     /* Msg command kept from for loop, but increase 16 to send ProntoEnd */
  283.     msg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1 + seqNr;
  284.     msg.Length = j;
  285.     /* data kept from loop, if any */
  286.     /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
  287.     while (StdCan_Put(&msg) != StdCan_Ret_OK) {}
  288.     _delay_ms(1);
  289. }
  290.  
  291.  
  292. static int decodeProntoData(int channel, uint8_t data)
  293. {
  294.     static uint8_t waitingForLSB = FALSE;
  295.     static uint8_t previousValueWas16bit = FALSE;
  296.  
  297.     if (irTxChannel[channel].txlen >= MAX_NR_TIMES) {
  298.         /* Max length exceeded */
  299.         return -1;
  300.     }
  301.  
  302.     if (irTxChannel[channel].txlen == 0) {
  303.         waitingForLSB = FALSE;
  304.         if (data == 0) {
  305.             /* Cannot start with 0x00 */
  306.             return -2;
  307.         }
  308.     }
  309.  
  310.     /* 0x00 means that previously received time is MSB of 16bit value, and that next byte will be LSB */
  311.     if (data == 0 && !waitingForLSB && previousValueWas16bit==FALSE) {
  312.         /* Convert previous time to MSB of the 16bit value. next received byte will become LSB */
  313.         irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1] <<= 8;
  314.  
  315.         /* Flag that next received byte is LSB rather than a new timing value */
  316.         waitingForLSB = TRUE;
  317.     }
  318.  
  319.     /* Non-zero value! is this part of a 16bit-value? use the data as LSB for previously received time */
  320.     else if (waitingForLSB) {
  321.         /* Let this byte be LSB of previous 16bit value */
  322.         irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1] |= data;
  323.  
  324.         /* We've now completed reception of the 16bit value */
  325.         waitingForLSB = FALSE;
  326.  
  327.         previousValueWas16bit = TRUE;
  328.     }
  329.  
  330.     /* Non-zero value! simply new 8bit value */
  331.     else {
  332.         /* Check if we're already done */
  333.         if (irTxChannel[channel].txlen >= (((uint16_t)irTxChannel[channel].onceSeqLen + (uint16_t)irTxChannel[channel].repSeqLen))) {
  334.             /* Too much data received, not necessarily a problem in case frames are padded */
  335.             return 2;
  336.         }
  337.  
  338.         irTxChannel[channel].txbuf[irTxChannel[channel].txlen] = data;
  339.  
  340.         previousValueWas16bit = FALSE;
  341.  
  342.         irTxChannel[channel].txlen++;
  343.     }
  344.  
  345.     return 1;
  346. }
  347.  
  348. #endif
  349.  
  350.  
  351. #if IR_RX_ENABLE==1
  352. void sns_irTransceive_RX_done_callback(uint8_t channel, uint16_t *buffer, uint8_t len)
  353. {
  354.     if (channel < IR_SUPPORTED_NUM_CHANNELS)
  355.     {
  356.         irRxChannel[channel].newData = TRUE;
  357.         irRxChannel[channel].rxlen = len;
  358.     }
  359. }
  360. #endif
  361.  
  362.  
  363. #if IR_TX_ENABLE==1
  364. void sns_irTransceive_TX_done_callback(uint8_t channel)
  365. {
  366.     if (channel < IR_SUPPORTED_NUM_CHANNELS)
  367.     {
  368.         irTxChannel[channel].sendComplete = TRUE;
  369.     }
  370. }
  371. #endif
  372.  
  373.  
  374. static void sns_irTransceive_setConfig(uint8_t channel, uint8_t config, uint8_t power, uint16_t modfreq)
  375. {
  376.     if (channel < IR_SUPPORTED_NUM_CHANNELS && config <= CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE && power < 4)
  377.     {
  378. #if IR_RX_ENABLE==1
  379.         if (config == CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE)
  380.         {
  381. #if IR_TX_ENABLE==1
  382.             irTxChannel[channel].state = sns_irTransceive_STATE_DISABLED;
  383. #endif
  384.             irRxChannel[channel].proto.modfreq = modfreq;
  385.             irRxChannel[channel].rxbuf = buf[channel];
  386.             switch (channel)
  387.             {
  388.                 case 0:
  389.                     gpio_clr_pin(sns_irTransceive_VCC_EN0_PIN);
  390.                     IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
  391.                     break;
  392.                 case 1:
  393.                     gpio_clr_pin(sns_irTransceive_VCC_EN1_PIN);
  394.                     IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
  395.                     break;
  396.                 case 2:
  397.                     gpio_clr_pin(sns_irTransceive_VCC_EN2_PIN);
  398.                     IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
  399.                     break;
  400.             }
  401.             irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
  402.         }
  403. #endif
  404.  
  405. #if IR_TX_ENABLE==1
  406.         if (config == CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_TRANSMIT)
  407.         {
  408. #if IR_RX_ENABLE==1
  409.             irRxChannel[channel].state = sns_irTransceive_STATE_DISABLED;
  410. #endif
  411.             irTxChannel[channel].txbuf = buf[channel];
  412.             switch (channel)
  413.             {
  414.                 case 0:
  415. #if IR_RX_ENABLE==1
  416.                     gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
  417.                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
  418. #endif
  419.                     IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX0_PIN);
  420.  
  421. #if sns_irTransceive_ENABLE_PCA95xx==1
  422.                     Pca95xx_set_out(sns_irTransceive_TX0_PWRl);
  423.                     Pca95xx_set_out(sns_irTransceive_TX0_PWRh);
  424.                     if (power&0x1)
  425.                     {
  426.                         Pca95xx_set_in(sns_irTransceive_TX0_PWRl);
  427.                     }
  428.                     if (power&0x2)
  429.                     {
  430.                         Pca95xx_set_in(sns_irTransceive_TX0_PWRh);
  431.                     }
  432. #endif
  433.                     break;
  434.                 case 1:
  435. #if IR_RX_ENABLE==1
  436.                     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
  437.                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
  438. #endif
  439.                     IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX1_PIN);
  440.  
  441. #if sns_irTransceive_ENABLE_PCA95xx==1
  442.                     Pca95xx_set_out(sns_irTransceive_TX1_PWRl);
  443.                     Pca95xx_set_out(sns_irTransceive_TX1_PWRh);
  444.                     if (power&0x1)
  445.                     {
  446.                         Pca95xx_set_in(sns_irTransceive_TX1_PWRl);
  447.                     }
  448.                     if (power&0x2)
  449.                     {
  450.                         Pca95xx_set_in(sns_irTransceive_TX1_PWRh);
  451.                     }
  452. #endif
  453.                     break;
  454.                 case 2:
  455. #if IR_RX_ENABLE==1
  456.                     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
  457.                     IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
  458. #endif
  459.                     IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX2_PIN);
  460.  
  461. #if sns_irTransceive_ENABLE_PCA95xx==1
  462.                     Pca95xx_set_out(sns_irTransceive_TX2_PWRl);
  463.                     Pca95xx_set_out(sns_irTransceive_TX2_PWRh);
  464.                     if (power&0x1)
  465.                     {
  466.                         Pca95xx_set_in(sns_irTransceive_TX2_PWRl);
  467.                     }
  468.                     if (power&0x2)
  469.                     {
  470.                         Pca95xx_set_in(sns_irTransceive_TX2_PWRh);
  471.                     }
  472. #endif
  473.                     break;
  474.             }
  475.             irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  476.         }
  477. #endif
  478.     }
  479. }
  480.  
  481.  
  482. void sns_irTransceive_Init(void)
  483. {
  484.     StdCan_Set_class(irTxMsg.Header, CAN_MODULE_CLASS_SNS);
  485.     StdCan_Set_direction(irTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  486.     irTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  487.     irTxMsg.Header.ModuleId = sns_irTransceive_ID;
  488.     irTxMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_IR;
  489.     irTxMsg.Length = 6;
  490.  
  491.     for (uint8_t i = 0; i < IR_SUPPORTED_NUM_CHANNELS; i++)
  492.     {
  493. #if IR_RX_ENABLE==1
  494.         irRxChannel[i].state = sns_irTransceive_STATE_DISABLED;
  495.         irRxChannel[i].newData = FALSE;
  496.         irRxChannel[i].rxlen = 0;
  497.         irRxChannel[i].proto.timeout=0;
  498.         irRxChannel[i].proto.data=0;
  499.         irRxChannel[i].proto.repeats=0;
  500.         irRxChannel[i].proto.protocol=0;
  501. #endif
  502.  
  503. #if IR_TX_ENABLE==1
  504.         irTxChannel[i].state = sns_irTransceive_STATE_DISABLED;
  505.         irTxChannel[i].sendComplete = FALSE;
  506.         irTxChannel[i].repeatCount = 0;
  507.         irTxChannel[i].txlen = 0;
  508.         irTxChannel[i].proto.data=0;
  509.         irTxChannel[i].proto.repeats=0;
  510.         irTxChannel[i].proto.framecnt=0;
  511.         irTxChannel[i].proto.protocol=0;
  512. #endif
  513.     }
  514.  
  515. #if IR_RX_ENABLE==1
  516.     if (IR_SUPPORTED_NUM_CHANNELS>=1) irRxChannel[0].timerNum=sns_irTransceive_RX0_REPEATE_TIMER;
  517.     if (IR_SUPPORTED_NUM_CHANNELS>=2) irRxChannel[1].timerNum=sns_irTransceive_RX1_REPEATE_TIMER;
  518.     if (IR_SUPPORTED_NUM_CHANNELS>=3) irRxChannel[2].timerNum=sns_irTransceive_RX2_REPEATE_TIMER;
  519. #endif
  520.  
  521. #if IR_TX_ENABLE==1
  522.     if (IR_SUPPORTED_NUM_CHANNELS>=1) irTxChannel[0].timerNum=sns_irTransceive_TX0_REPEATE_TIMER;
  523.     if (IR_SUPPORTED_NUM_CHANNELS>=2) irTxChannel[1].timerNum=sns_irTransceive_TX1_REPEATE_TIMER;
  524.     if (IR_SUPPORTED_NUM_CHANNELS>=3) irTxChannel[2].timerNum=sns_irTransceive_TX2_REPEATE_TIMER;
  525. #endif
  526.  
  527.     IrTransceiver_Init();
  528.     /* Configure all TX VCC pins as outputs and disable them */
  529.     gpio_set_out(sns_irTransceive_VCC_EN0_PIN);
  530.     gpio_set_out(sns_irTransceive_VCC_EN1_PIN);
  531.     gpio_set_out(sns_irTransceive_VCC_EN2_PIN);
  532.     gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
  533.     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
  534.     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
  535.  
  536.     /* TX-pins must be set in case transmitter is nexa */
  537.     gpio_set_out(sns_irTransceive_MOD_PIN);
  538.     gpio_set_out(sns_irTransceive_TX0_PIN);
  539.     gpio_set_out(sns_irTransceive_TX1_PIN);
  540.     gpio_set_out(sns_irTransceive_TX2_PIN);
  541. #if IR_TX_ACTIVE_LOW==1
  542.     gpio_set_pin(sns_irTransceive_TX0_PIN);
  543.     gpio_set_pin(sns_irTransceive_TX1_PIN);
  544.     gpio_set_pin(sns_irTransceive_TX2_PIN);
  545. #endif
  546.  
  547.     /* IR tx power pins on PCA95xx */
  548. #if sns_irTransceive_ENABLE_PCA95xx==1
  549.     Pca95xx_Init(0);
  550.  
  551.     Pca95xx_clr_pin(sns_irTransceive_TX0_PWRl);
  552.     Pca95xx_set_out(sns_irTransceive_TX0_PWRl);
  553.     Pca95xx_clr_pin(sns_irTransceive_TX0_PWRh);
  554.     Pca95xx_set_out(sns_irTransceive_TX0_PWRh);
  555.  
  556.     Pca95xx_clr_pin(sns_irTransceive_TX1_PWRl);
  557.     Pca95xx_set_out(sns_irTransceive_TX1_PWRl);
  558.     Pca95xx_clr_pin(sns_irTransceive_TX1_PWRh);
  559.     Pca95xx_set_out(sns_irTransceive_TX1_PWRh);
  560.  
  561.     Pca95xx_clr_pin(sns_irTransceive_TX2_PWRl);
  562.     Pca95xx_set_out(sns_irTransceive_TX2_PWRl);
  563.     Pca95xx_clr_pin(sns_irTransceive_TX2_PWRh);
  564.     Pca95xx_set_out(sns_irTransceive_TX2_PWRh);
  565. #endif
  566.  
  567. #ifdef sns_irTransceive_USEEEPROM
  568.     if (EEDATA_OK)
  569.     {
  570.       /* Use stored data to set initial values for the module */
  571.         sns_irTransceive_setConfig(0, eeprom_read_byte(EEDATA.ch0_config), eeprom_read_byte(EEDATA.ch0_txpower), eeprom_read_word(EEDATA16.ch0_modfreq));
  572.         sns_irTransceive_setConfig(1, eeprom_read_byte(EEDATA.ch1_config), eeprom_read_byte(EEDATA.ch1_txpower), eeprom_read_word(EEDATA16.ch1_modfreq));
  573.         sns_irTransceive_setConfig(2, eeprom_read_byte(EEDATA.ch2_config), eeprom_read_byte(EEDATA.ch2_txpower), eeprom_read_word(EEDATA16.ch2_modfreq));
  574.     }
  575.     else
  576.     {
  577.     /* The CRC of the EEPROM is not correct, store default values and update CRC */
  578.         eeprom_write_byte_crc(EEDATA.ch0_config, CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO, WITHOUT_CRC);
  579.         eeprom_write_byte_crc(EEDATA.ch0_txpower, 0, WITHOUT_CRC);
  580.         eeprom_write_word_crc(EEDATA16.ch0_modfreq, sns_irTransceive_BaseFrq/38000UL, WITHOUT_CRC);
  581.         eeprom_write_byte_crc(EEDATA.ch1_config, CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO, WITHOUT_CRC);
  582.         eeprom_write_byte_crc(EEDATA.ch1_txpower, 0, WITHOUT_CRC);
  583.         eeprom_write_word_crc(EEDATA16.ch1_modfreq, sns_irTransceive_BaseFrq/38000UL, WITHOUT_CRC);
  584.         eeprom_write_byte_crc(EEDATA.ch2_config, CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_AUTO, WITHOUT_CRC);
  585.         eeprom_write_byte_crc(EEDATA.ch2_txpower, 0, WITHOUT_CRC);
  586.         eeprom_write_word_crc(EEDATA16.ch2_modfreq, sns_irTransceive_BaseFrq/38000UL, WITHOUT_CRC);
  587.         EEDATA_UPDATE_CRC;
  588.     }
  589. #endif
  590.  
  591. /*gpio_clr_pin(EXP_K);
  592. gpio_set_out(EXP_K);
  593. gpio_clr_pin(EXP_J);
  594. gpio_set_out(EXP_J);
  595. gpio_clr_pin(EXP_H);
  596. gpio_set_out(EXP_H);*/
  597. }
  598.  
  599. void sns_irTransceive_Process(void)
  600. {
  601.     for (uint8_t channel=0; channel < IR_SUPPORTED_NUM_CHANNELS; channel++)
  602.     {
  603.  
  604. #if IR_RX_ENABLE==1
  605.         switch (irRxChannel[channel].state)
  606.         {
  607.         case sns_irTransceive_STATE_IDLE:
  608.         {
  609.             if (irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
  610.                 /* Send button release command on CAN */
  611.                 irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED;
  612.                 irTxMsg.Data[0] |= channel<<4;
  613.                 irTxMsg.Data[1] = irRxChannel[channel].proto.protocol;
  614.                 irTxMsg.Data[2] = (irRxChannel[channel].proto.data>>24)&0xff;
  615.                 irTxMsg.Data[3] = (irRxChannel[channel].proto.data>>16)&0xff;
  616.                 irTxMsg.Data[4] = (irRxChannel[channel].proto.data>>8)&0xff;
  617.                 irTxMsg.Data[5] = irRxChannel[channel].proto.data&0xff;
  618.  
  619.                 StdCan_Put(&irTxMsg);
  620.             }
  621.             irRxChannel[channel].state = sns_irTransceive_STATE_START_RECEIVE;
  622.             break;
  623.         }
  624.  
  625.         case sns_irTransceive_STATE_START_RECEIVE:
  626.             IrTransceiver_ResetRx(channel);
  627.             cli();
  628.             irRxChannel[channel].newData = FALSE;
  629.             sei();
  630.             irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
  631. //gpio_set_pin(EXP_J);
  632.             break;
  633.  
  634.         case sns_irTransceive_STATE_RECEIVING:
  635.             if (irRxChannel[channel].newData == TRUE) {
  636. //printf("sRx\n");
  637.                 /* TODO: move this line to the RX callback */
  638.                 IrTransceiver_DisableRx(channel);
  639.                 cli();
  640.                 irRxChannel[channel].newData = FALSE;
  641.                 sei();
  642.  
  643.                 /* Let protocol driver parse and then send on CAN */
  644.                 uint8_t res2 = parseProtocol(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, &irRxChannel[channel].proto);
  645.                 if (res2 == IR_OK && irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
  646.                     irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED;
  647.                     irTxMsg.Data[0] |= channel<<4;
  648.                     irTxMsg.Data[1] = irRxChannel[channel].proto.protocol;
  649.                     irTxMsg.Data[2] = (irRxChannel[channel].proto.data>>24)&0xff;
  650.                     irTxMsg.Data[3] = (irRxChannel[channel].proto.data>>16)&0xff;
  651.                     irTxMsg.Data[4] = (irRxChannel[channel].proto.data>>8)&0xff;
  652.                     irTxMsg.Data[5] = irRxChannel[channel].proto.data&0xff;
  653.  
  654.                     StdCan_Put(&irTxMsg);
  655.                 }
  656.                 else if (irRxChannel[channel].proto.protocol == IR_PROTO_UNKNOWN)
  657.                 {
  658. #if (sns_irTransceive_SEND_DEBUG==1)
  659.                     send_debug(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen);
  660.                     irRxChannel[channel].proto.timeout=300;
  661. #elif sns_irTransceive_PRONTO_SUPPORT==1
  662.                     pronto_sendData(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, channel, irRxChannel[channel].proto.modfreq);
  663.                     irRxChannel[channel].proto.timeout=1;
  664. #endif
  665.                 }
  666.  
  667.                 /* Enable the receiver again */
  668.                 IrTransceiver_EnableRx(channel);
  669.  
  670.                 irRxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
  671. //gpio_clr_pin(EXP_H);
  672. //gpio_clr_pin(EXP_J);
  673.             }
  674.             break;
  675.  
  676.         case sns_irTransceive_STATE_START_PAUSE:
  677. //printf("sP\n");
  678.             /* set a timer so we can send release button event when no new IR is arriving */
  679.             Timer_SetTimeout(irRxChannel[channel].timerNum, irRxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
  680.             irRxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
  681.             break;
  682.  
  683.         case sns_irTransceive_STATE_PAUSING:
  684.             /* reset timer if new IR arrived */
  685.             if (irRxChannel[channel].newData == TRUE || IrTransceiver_GetStoreEnableRx(channel) == TRUE) {
  686. //printf("sT\n");
  687.                 cli();
  688.                 irRxChannel[channel].newData = FALSE;
  689.                 sei();
  690.                 Timer_SetTimeout(irRxChannel[channel].timerNum, irRxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
  691.             }
  692.  
  693.             if (Timer_Expired(irRxChannel[channel].timerNum)) {
  694. //printf("sD\n");
  695.                 irRxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  696.             }
  697.             break;
  698.  
  699.         default:
  700.             break;
  701.         }
  702. #endif
  703.  
  704. #if IR_TX_ENABLE==1
  705.         switch (irTxChannel[channel].state)
  706.         {
  707.         case sns_irTransceive_STATE_IDLE:
  708.         {
  709.             /* transmission is started when a command is received on can */
  710.             irTxChannel[channel].stopSend = FALSE;
  711.             irTxChannel[channel].repeatCount = 0;
  712.             irTxChannel[channel].proto.framecnt = 0;
  713.             irTxChannel[channel].sendingPronto = FALSE;
  714.             break;
  715.         }
  716.  
  717.         case sns_irTransceive_STATE_START_TRANSMIT:
  718.         {
  719.             /* Expand protocol. */
  720.             if (expandProtocol(irTxChannel[channel].txbuf, &irTxChannel[channel].txlen, &irTxChannel[channel].proto) != IR_OK) {
  721.                 /* Failed to expand protocol -> enter idle state. */
  722.                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  723.                 break;
  724.             }
  725.  
  726.             /* Start IR transmission. */
  727.             /* TODO Send respone. Function call may fail when different modulation frequencies are used simultaneously. */
  728.             IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen, irTxChannel[channel].proto.modfreq);
  729.  
  730.             /* Enter transmitting state. */
  731.             irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
  732.             break;
  733.         }
  734.  
  735.         case sns_irTransceive_STATE_START_TRANSMIT_PRONTO:
  736.         {
  737.             /* Once sequence exists? */
  738.             if (irTxChannel[channel].onceSeqLen>0) {
  739.                 /* Start IR transmission of the once sequence. */
  740.                 if(IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].onceSeqLen - 1, irTxChannel[channel].proto.modfreq) < 0) {
  741.                     /* Send error code. */
  742.                     pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
  743.  
  744.                     /* Enter idle state. */
  745.                     irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  746.                     break;
  747.                 }
  748.                 else {
  749.                     /* Enter transmitting state. */
  750.                                 irTxChannel[channel].sendingPronto = TRUE;
  751.                                 irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
  752.                     break;
  753.                 }
  754.             }
  755.             /* Repeat sequence exists? */
  756.             else if (irTxChannel[channel].repSeqLen>0) {
  757.                 /* Start IR transmission of the repeat sequence. */
  758.                     if(IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].repSeqLen - 1, irTxChannel[channel].proto.modfreq) < 0) {
  759.                                         /* Send error code. */
  760.                                         pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
  761.  
  762.                                         /* Enter idle state. */
  763.                                         irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  764.                                         break;
  765.                                 }
  766.                 else {
  767.                                         /* Enter transmitting state. */
  768.                                         irTxChannel[channel].sendingPronto = TRUE;
  769.                                         irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
  770.                     break;
  771.                                 }
  772.             }
  773.             /* Neither once sequence nor repeat sequence exists! */
  774.             /* Send error code. */
  775.                         pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
  776.                         /* Enter idle state. */
  777.                         irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  778.                         break;
  779.         }
  780.  
  781.         case sns_irTransceive_STATE_PRONTO_REPEAT:
  782.         {
  783.             /* Check if done. */
  784.             if ((irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats && irTxChannel[channel].proto.repeats != 0xFF) || irTxChannel[channel].stopSend) {
  785.                 /* Pronto transmission was stopped/completed */
  786.                 pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_STOPPED);
  787.                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  788.                 break;
  789.             }
  790.  
  791.             if (irTxChannel[channel].repeatCount < 255) {
  792.                 irTxChannel[channel].repeatCount++;
  793.             }
  794.  
  795.             /* Repeat sequence exists? */
  796.             if (irTxChannel[channel].repSeqLen > 0) {
  797.                 /* Use repeat seq */
  798.                 uint16_t offset = ((uint16_t)irTxChannel[channel].onceSeqLen);
  799.                 /* Don't transmit last passive. last passive handled by timer */
  800.                 IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, offset, ((uint16_t)irTxChannel[channel].repSeqLen) - 1, irTxChannel[channel].proto.modfreq);
  801.             }
  802.             /* Once sequence exists? */
  803.             else if (irTxChannel[channel].onceSeqLen > 0) {
  804.                 /* Use once seq */
  805.                 /* Don't transmit last passive. last passive handled by timer */
  806.                 IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, 0, irTxChannel[channel].txlen - 1, irTxChannel[channel].proto.modfreq);
  807.             }
  808.             irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
  809.         }
  810.  
  811.         case sns_irTransceive_STATE_TRANSMITTING:
  812.         {
  813.             if (irTxChannel[channel].sendComplete == TRUE)
  814.             {
  815.                 cli();
  816.                 irTxChannel[channel].sendComplete = FALSE;
  817.                 sei();
  818.  
  819.                 if (irTxChannel[channel].sendingPronto)
  820.                 {
  821.                     /* First repeat, or no repeat sequence defined => use last passive time in once seq */
  822.                     if(irTxChannel[channel].repeatCount == 0 || irTxChannel[channel].repSeqLen == 0)
  823.                     {
  824.                         /* Use last passive time as timeout */
  825.                         uint16_t lastPasTime = irTxChannel[channel].txbuf[irTxChannel[channel].onceSeqLen - 1] / 1000;
  826.                         Timer_SetTimeout(irTxChannel[channel].timerNum, lastPasTime==0 ? 1 : lastPasTime, TimerTypeOneShot, 0);
  827.                     }
  828.                     /* Second, or later repeat => use last passive time in repeat seq */
  829.                     else
  830.                     {
  831.                         /* Use last passive time as timeout */
  832.                         uint16_t lastPasTime = irTxChannel[channel].txbuf[irTxChannel[channel].txlen - 1]  / 1000;
  833.                         Timer_SetTimeout(irTxChannel[channel].timerNum, lastPasTime==0 ? 1 : lastPasTime, TimerTypeOneShot, 0);
  834.                     }
  835.                     irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
  836.                 }
  837.                 else
  838.                 {
  839.                     irTxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
  840.                 }
  841.             }
  842.             break;
  843.         }
  844.  
  845.         case sns_irTransceive_STATE_START_PAUSE:
  846.         {
  847.             if (irTxChannel[channel].repeatCount < irTxChannel[channel].proto.repeats)
  848.             {
  849.                 irTxChannel[channel].repeatCount++;
  850.             }
  851.  
  852.             Timer_SetTimeout(irTxChannel[channel].timerNum, irTxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
  853.  
  854.             if (irTxChannel[channel].proto.framecnt != 255)
  855.             {
  856.                 irTxChannel[channel].proto.framecnt++;
  857.             }
  858.  
  859.             irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
  860.             break;
  861.         }
  862.  
  863.         case sns_irTransceive_STATE_PAUSING:
  864.         {
  865.             if (irTxChannel[channel].sendingPronto)
  866.             {
  867.                 if (Timer_Expired(irTxChannel[channel].timerNum))
  868.                 {
  869.                     irTxChannel[channel].state = sns_irTransceive_STATE_PRONTO_REPEAT;
  870.                 }
  871.                 break;
  872.             }
  873.  
  874.             if (Timer_Expired(irTxChannel[channel].timerNum))
  875.             {
  876.                 irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
  877.             }
  878.  
  879.             /* Transmission is stopped when such command is recevied on can */
  880.             if (irTxChannel[channel].stopSend == TRUE && irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
  881.             {
  882.                 /* Non-pronto transmission was stopped/completed */
  883.                 pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_STOPPED);
  884.  
  885.                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  886.             }
  887.             break;
  888.         }
  889.         default:
  890.             break;
  891.         }
  892. #endif
  893.  
  894.     }
  895. }
  896.  
  897.  
  898. /* Handle incoming CAN data */
  899. void sns_irTransceive_HandleMessage(StdCan_Msg_t *rxMsg)
  900. {
  901.     /* Sanity check. */
  902.     if (StdCan_Ret_class(rxMsg->Header) != CAN_MODULE_CLASS_SNS ||
  903.         StdCan_Ret_direction(rxMsg->Header) != DIRECTIONFLAG_TO_OWNER ||
  904.         rxMsg->Header.ModuleType != CAN_MODULE_TYPE_SNS_IRTRANSCEIVE ||
  905.         rxMsg->Header.ModuleId != sns_irTransceive_ID) return;
  906.  
  907.     switch (rxMsg->Header.Command)
  908.     {
  909. #if IR_TX_ENABLE==1
  910.     case CAN_MODULE_CMD_PHYSICAL_IR:
  911.     {
  912.         /* Get IR channel. */
  913.         uint8_t channel = rxMsg->Data[0] >> 4;
  914.  
  915.         /* Get button status. */
  916.         uint8_t buttonStatus = rxMsg->Data[0] & 0x0F;
  917.  
  918.         /* Sanity check. */
  919.         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
  920.             /* Invalid channel */
  921.             break;
  922.         }
  923.  
  924.         /* Check if channel is busy sending Pronto */
  925.         if (irTxChannel[channel].sendingPronto) {
  926.             /* Channel busy */
  927.             break;
  928.         }
  929.  
  930.         if (buttonStatus == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED)
  931.         {
  932.             if (irTxChannel[channel].state == sns_irTransceive_STATE_IDLE)
  933.             {
  934.                 irTxChannel[channel].proto.protocol = rxMsg->Data[1];
  935.                 irTxChannel[channel].proto.data = rxMsg->Data[2];
  936.                 irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
  937.                 irTxChannel[channel].proto.data |= rxMsg->Data[3];
  938.                 irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
  939.                 irTxChannel[channel].proto.data |= rxMsg->Data[4];
  940.                 irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
  941.                 irTxChannel[channel].proto.data |= rxMsg->Data[5];
  942.  
  943.                 irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
  944.             }
  945.         }
  946.         else if (buttonStatus == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED)
  947.         {
  948.             if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE)
  949.             {
  950.                 irTxChannel[channel].stopSend = TRUE;
  951.             }
  952.         }
  953.         break;
  954.     }
  955.  
  956. #if sns_irTransceive_PRONTO_SUPPORT==1
  957.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTART:
  958.     {
  959.         /* Get IR channel. */
  960.         uint8_t channel = rxMsg->Data[0] >> 4;
  961.  
  962.         /* Sanity check. */
  963.         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
  964.             /* Invalid channel */
  965.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  966.             break;
  967.         }
  968.         if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE) {
  969.             /* We're already transmitting on this channel */
  970.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ABORTED);
  971.             break;
  972.         }
  973.  
  974.         /* Check if format is supported. */
  975.         if ((((uint16_t)(rxMsg->Data[0] & 0x0F) << 8) | (uint16_t)(rxMsg->Data[1])) != 0) {
  976.             /* Invalid pronto format */
  977.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  978.             break;
  979.         }
  980.  
  981.         /* Extract received data. */
  982.  
  983.         uint32_t divider = (rxMsg->Data[2] << 8) | (rxMsg->Data[3] << 0);
  984.         if (divider == 0) {
  985.             /* Invalid wFrqDiv value */
  986.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  987.             break;
  988.         }
  989.         uint32_t freqkHz = (sns_irTransceive_BaseFrq / (divider*1000));
  990.         if (freqkHz == 0) {
  991.             /* Invalid wFrqDiv value */
  992.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  993.             break;
  994.         }
  995.         irTxChannel[channel].proto.modfreq = freqkHz;
  996.  
  997.         /* TODO: reconfigure with new modfreq, if no other channels sending pronto */
  998.  
  999.         /* Convert lenghts to bytes */
  1000.         irTxChannel[channel].onceSeqLen = 2*((((uint16_t)rxMsg->Data[4]) << 8) | (((uint16_t)rxMsg->Data[5]) << 0));
  1001.         irTxChannel[channel].repSeqLen = 2*((((uint16_t)rxMsg->Data[6]) << 8) | (((uint16_t)rxMsg->Data[7]) << 0));
  1002.  
  1003.         /* Enter prepering pronto state and clear transmit buffer. */
  1004.         irTxChannel[channel].state = sns_irTransceive_STATE_PREPARING_PRONTO;
  1005.         irTxChannel[channel].txlen = 0;
  1006.         irTxChannel[channel].expectedSeqNr = 0;
  1007.         activeChannel = channel;
  1008.  
  1009.         /* We're now waiting for pronto data */
  1010.         pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_WAITING);
  1011.         break;
  1012.     }
  1013.  
  1014.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOSTOP:
  1015.     {
  1016.         /* Get IR channel. */
  1017.         uint8_t channel = rxMsg->Data[0] >> 4;
  1018.  
  1019.         /* Sanity check. */
  1020.         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
  1021.             /* Invalid channel */
  1022.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1023.             break;
  1024.         }
  1025.  
  1026.         irTxChannel[channel].stopSend = TRUE;
  1027.  
  1028.         /* State check. If we're not currently transmitting anything, the STOPPED reponse will never occur. */
  1029.         /* TODO: better way to check this? /jm */
  1030.         if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
  1031.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
  1032.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
  1033.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_PAUSING &&
  1034.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_PAUSE)
  1035.         {
  1036.             /* Nothing to stop. Not in TX state. Respond that we're already stopped */
  1037.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
  1038.             break;
  1039.         }
  1040.  
  1041.         /* Response will be sent when transmission has been completed (i.e. stopped) */
  1042.         break;
  1043.     }
  1044.  
  1045.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOCONTINUE:
  1046.     {
  1047.         /* Get IR channel. */
  1048.         uint8_t channel = rxMsg->Data[0] >> 4;
  1049.  
  1050.         /* Sanity check. */
  1051.         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
  1052.             /* Invalid channel */
  1053.             pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1054.             break;
  1055.         }
  1056.  
  1057.         /* State check. We must already be in some transmit state */
  1058.         /* TODO: better way to check this? /jm */
  1059.         if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_TRANSMIT_PRONTO &&
  1060.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_TRANSMITTING &&
  1061.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_PRONTO_REPEAT &&
  1062.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_PAUSING &&
  1063.             irTxChannel[activeChannel].state != sns_irTransceive_STATE_START_PAUSE)
  1064.         {
  1065.             /* Too late to continue! Not in TX state anymore */
  1066.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ALREADYSTOPPED);
  1067.             break;
  1068.         }
  1069.  
  1070.         /* Reset repeat counter, i.e. request additional repeats. */
  1071.         irTxChannel[channel].repeatCount = 0;
  1072.  
  1073.         /* The repeat period was extended. Still transmitting */
  1074.         pronto_sendResponse(channel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_TRANSMITTING);
  1075.         break;
  1076.     }
  1077.  
  1078.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1:  /* Fall through */
  1079.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA2:  /* Fall through */
  1080.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA3:  /* Fall through */
  1081.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA4:  /* Fall through */
  1082.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA5:  /* Fall through */
  1083.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA6:  /* Fall through */
  1084.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA7:  /* Fall through */
  1085.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA8:  /* Fall through */
  1086.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA9:  /* Fall through */
  1087.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA10: /* Fall through */
  1088.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA11: /* Fall through */
  1089.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA12: /* Fall through */
  1090.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA13: /* Fall through */
  1091.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA14: /* Fall through */
  1092.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA15: /* Fall through */
  1093.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA16:
  1094.     {
  1095.         if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
  1096.             /* Invalid state. CAN msg probably out of order */
  1097.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1098.             break;
  1099.         }
  1100.  
  1101.         if ((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTODATA1) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
  1102.             /* Unexpected CAN msg, out of order */
  1103.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1104.             irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
  1105.             break;
  1106.         }
  1107.  
  1108.         /* Decode pronto data */
  1109.         for (uint8_t i = 0; i < rxMsg->Length; i++) {
  1110.             if (decodeProntoData(activeChannel, rxMsg->Data[i]) != 1) {
  1111.                 /* Decode error */
  1112.                 pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1113.                 irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
  1114.                 return;
  1115.             }
  1116.         }
  1117.  
  1118.         irTxChannel[activeChannel].expectedSeqNr++;
  1119.  
  1120.         /* We're still waiting for more pronto data, or for pronto end */
  1121.         pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_WAITING);
  1122.         break;
  1123.     }
  1124.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1:   /* Fall through */
  1125.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND2:   /* Fall through */
  1126.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND3:   /* Fall through */
  1127.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND4:   /* Fall through */
  1128.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND5:   /* Fall through */
  1129.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND6:   /* Fall through */
  1130.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND7:   /* Fall through */
  1131.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND8:   /* Fall through */
  1132.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND9:   /* Fall through */
  1133.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND10:  /* Fall through */
  1134.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND11:  /* Fall through */
  1135.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND12:  /* Fall through */
  1136.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND13:  /* Fall through */
  1137.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND14:  /* Fall through */
  1138.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND15:  /* Fall through */
  1139.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND16:  /* Fall through */
  1140.     {
  1141.         if (irTxChannel[activeChannel].state != sns_irTransceive_STATE_PREPARING_PRONTO) {
  1142.             /* Invalid state. CAN msg probably out of order */
  1143.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1144.             break;
  1145.         }
  1146.  
  1147.         if (((rxMsg->Header.Command - CAN_MODULE_CMD_IRTRANSCEIVE_IRPRONTOEND1) % 16) != (irTxChannel[activeChannel].expectedSeqNr % 16)) {
  1148.             /* Unexpected CAN msg, out of order */
  1149.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1150.             irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
  1151.             break;
  1152.         }
  1153.  
  1154.         /* Decode remaining pronto data (if any). -1 because last byte is repeat count */
  1155.         for (uint16_t i = 0; i < rxMsg->Length - 1; i++) {
  1156.             if (decodeProntoData(activeChannel, rxMsg->Data[i]) < 0) {
  1157.                 /* Decode error */
  1158.                 pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1159.                 irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
  1160.                 return;
  1161.             }
  1162.         }
  1163.  
  1164.         /* Sanity check */
  1165.         if (irTxChannel[activeChannel].txlen != (((uint16_t)irTxChannel[activeChannel].onceSeqLen + (uint16_t)irTxChannel[activeChannel].repSeqLen))) {
  1166.             /* Length doesn't match the expected length */
  1167.             pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_ERROR);
  1168.             irTxChannel[activeChannel].state = sns_irTransceive_STATE_IDLE;
  1169.             break;
  1170.         }
  1171.  
  1172.         /* Last byte determines nr of repeats. 0xFF means INF, 0 means no repeats */
  1173.         irTxChannel[activeChannel].proto.repeats = rxMsg->Data[rxMsg->Length - 1];
  1174.         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 */
  1175.  
  1176.         /* Convert pronto data to µs */
  1177.         uint32_t nsPerTick = 1000000UL / ((uint32_t)irTxChannel[activeChannel].proto.modfreq);
  1178.         for (uint16_t i = 0; i < irTxChannel[activeChannel].txlen; i++) {
  1179.             uint32_t us = (((uint32_t)irTxChannel[activeChannel].txbuf[i]) * nsPerTick) / 1000UL;
  1180.             if (us > 0xFFFFUL) {
  1181.                 us = 0xFFFFUL;
  1182.             }
  1183.             irTxChannel[activeChannel].txbuf[i] = (uint16_t)us;
  1184.         }
  1185.  
  1186.         /* Send IR data */
  1187.         irTxChannel[activeChannel].state = sns_irTransceive_STATE_START_TRANSMIT_PRONTO;
  1188.  
  1189.         /* We're now transmitting the pronto data */
  1190.         pronto_sendResponse(activeChannel, CAN_MODULE_ENUM_IRTRANSCEIVE_IRPRONTORESPONSE_RESPONSE_TRANSMITTING);
  1191.         break;
  1192.     }
  1193.  
  1194. /* TODO: In IR state machine add sending a response frame when ir stops sending, also implement pronto repeat */
  1195. #endif
  1196. #endif
  1197.  
  1198.     case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG:
  1199.     {
  1200.         /* Get IR channel. */
  1201.         uint8_t channel = rxMsg->Data[0] >> 4;
  1202.  
  1203.         /* Sanity check. */
  1204.         if (channel >= IR_SUPPORTED_NUM_CHANNELS) {
  1205.             /* Invalid channel */
  1206.             break;
  1207.         }
  1208.  
  1209.         uint8_t config = rxMsg->Data[0] & 0x0f;
  1210.         uint8_t power = rxMsg->Data[1]>>6;
  1211.         uint32_t divider = ((uint16_t)rxMsg->Data[2] << 8) | ((uint16_t)rxMsg->Data[3] << 0);
  1212.         if (divider == 0) {
  1213.             /* Invalid modfreq */
  1214.             break;
  1215.         }
  1216.         uint32_t modfreq = (sns_irTransceive_BaseFrq / (divider*1000));
  1217.         if (modfreq == 0) {
  1218.             /* Invalid modfreq */
  1219.             break;
  1220.         }
  1221.         sns_irTransceive_setConfig(channel, config, power, modfreq);
  1222.  
  1223. #ifdef sns_irTransceive_USEEEPROM
  1224.         if (channel < IR_SUPPORTED_NUM_CHANNELS && config <= CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE && power < 4)
  1225.         {
  1226.             switch (channel)
  1227.             {
  1228.                 case 0:
  1229.                     eeprom_write_byte_crc(EEDATA.ch0_config, config, WITHOUT_CRC);
  1230.                     eeprom_write_byte_crc(EEDATA.ch0_txpower, power, WITHOUT_CRC);
  1231.                     eeprom_write_word_crc(EEDATA16.ch0_modfreq, modfreq, WITHOUT_CRC);
  1232.                     break;
  1233.                 case 1:
  1234.                     eeprom_write_byte_crc(EEDATA.ch1_config, config, WITHOUT_CRC);
  1235.                     eeprom_write_byte_crc(EEDATA.ch1_txpower, power, WITHOUT_CRC);
  1236.                     eeprom_write_word_crc(EEDATA16.ch1_modfreq, modfreq, WITHOUT_CRC);
  1237.                     break;
  1238.                 case 2:
  1239.                     eeprom_write_byte_crc(EEDATA.ch2_config, config, WITHOUT_CRC);
  1240.                     eeprom_write_byte_crc(EEDATA.ch2_txpower, power, WITHOUT_CRC);
  1241.                     eeprom_write_word_crc(EEDATA16.ch2_modfreq, modfreq, WITHOUT_CRC);
  1242.                     break;
  1243.                 default:
  1244.                     break;
  1245.             }
  1246.             EEDATA_UPDATE_CRC;
  1247.         }
  1248. #endif
  1249.         break;
  1250.     }
  1251.  
  1252.     default:
  1253.         break;
  1254.  
  1255.     }
  1256.  
  1257. }
  1258.  
  1259. void sns_irTransceive_List(uint8_t ModuleSequenceNumber)
  1260. {
  1261.     StdCan_Msg_t txMsg;
  1262.  
  1263.     StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
  1264.     StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  1265.     txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  1266.  
  1267.     txMsg.Header.ModuleId = sns_irTransceive_ID;
  1268.     txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_LIST;
  1269.     txMsg.Length = 6;
  1270.  
  1271.     uint32_t HwId=BIOS_GetHwId();
  1272.     txMsg.Data[0] = HwId&0xff;
  1273.     txMsg.Data[1] = (HwId>>8)&0xff;
  1274.     txMsg.Data[2] = (HwId>>16)&0xff;
  1275.     txMsg.Data[3] = (HwId>>24)&0xff;
  1276.  
  1277.     txMsg.Data[4] = NUMBER_OF_MODULES;
  1278.     txMsg.Data[5] = ModuleSequenceNumber;
  1279.  
  1280.     while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  1281. }
  1282.