Subversion Repositories HomeAutomation

Rev

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

  1.  
  2. #include "sns_irTransceive.h"
  3.  
  4. #if IR_RX_ENABLE==1
  5. struct {
  6.     uint8_t             state;
  7.     uint16_t            *rxbuf;
  8.     uint8_t             rxlen;
  9.     uint8_t             timerNum;
  10.     Ir_Protocol_Data_t  proto;
  11.     uint8_t             newData;
  12. } irRxChannel[IR_SUPPORTED_NUM_CHANNELS];
  13. #endif
  14.  
  15. #if IR_TX_ENABLE==1
  16. struct {
  17.     uint8_t             state;
  18.     uint16_t            *txbuf;
  19.     uint8_t             txlen;
  20.     uint8_t             timerNum;
  21.     uint8_t             repeatCount;
  22.     Ir_Protocol_Data_t  proto;
  23.     uint8_t             stopSend;
  24.     uint8_t             sendComplete;
  25. } irTxChannel[IR_SUPPORTED_NUM_CHANNELS];
  26. #endif
  27.  
  28. uint16_t    buf[3][MAX_NR_TIMES];
  29.  
  30. StdCan_Msg_t        irTxMsg;
  31.  
  32. #if (sns_irTransceive_SEND_DEBUG==1)
  33. void send_debug(uint16_t *buffer, uint8_t len) {
  34.     StdCan_Msg_t dbgIrTxMsg;
  35.     /* the protocol is unknown so the raw ir-data is sent, makes it easier to develop a new protocol */
  36.  
  37.     StdCan_Set_class(dbgIrTxMsg.Header, CAN_MODULE_CLASS_SNS);
  38.     StdCan_Set_direction(dbgIrTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  39.     dbgIrTxMsg.Length = 8;
  40.     dbgIrTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  41.     dbgIrTxMsg.Header.ModuleId = sns_irTransceive_ID;
  42.     dbgIrTxMsg.Header.Command = CAN_MODULE_CMD_IRTRANSCEIVE_IRRAW;
  43.     for (uint8_t i = 0; i < len>>2; i++) {
  44.         uint8_t index = i<<2;
  45.  
  46.         dbgIrTxMsg.Data[0] = (buffer[index]>>8)&0xff;
  47.         dbgIrTxMsg.Data[1] = (buffer[index]>>0)&0xff;
  48.         dbgIrTxMsg.Data[2] = (buffer[index+1]>>8)&0xff;
  49.         dbgIrTxMsg.Data[3] = (buffer[index+1]>>0)&0xff;
  50.         dbgIrTxMsg.Data[4] = (buffer[index+2]>>8)&0xff;
  51.         dbgIrTxMsg.Data[5] = (buffer[index+2]>>0)&0xff;
  52.         dbgIrTxMsg.Data[6] = (buffer[index+3]>>8)&0xff;
  53.         dbgIrTxMsg.Data[7] = (buffer[index+3]>>0)&0xff;
  54.                
  55.         /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
  56.         while (StdCan_Put(&dbgIrTxMsg) != StdCan_Ret_OK) {}
  57.         _delay_ms(1);
  58.     }
  59.    
  60.     uint8_t lastpacketcnt = len&0x03;
  61.     if (lastpacketcnt > 0) {
  62.         dbgIrTxMsg.Length = lastpacketcnt<<1;
  63.         for (uint8_t i = 0; i < lastpacketcnt; i++) {
  64.             dbgIrTxMsg.Data[i<<1] = (buffer[(len&0xfc)|i]>>8)&0xff;
  65.             dbgIrTxMsg.Data[(i<<1)+1] = (buffer[(len&0xfc)|i]>>0)&0xff;
  66.         }
  67.         /* buffers will be filled when sending more than 2-3 messages, so retry until sent */
  68.         while (StdCan_Put(&dbgIrTxMsg) != StdCan_Ret_OK) {}
  69.         _delay_ms(1);
  70.     }
  71.  
  72. }
  73. #endif
  74.  
  75. #if IR_RX_ENABLE==1
  76. void sns_irTransceive_RX_done_callback(uint8_t channel, uint16_t *buffer, uint8_t len)
  77. {
  78.     if (channel < IR_SUPPORTED_NUM_CHANNELS)
  79.     {
  80.         irRxChannel[channel].newData = TRUE;
  81.         irRxChannel[channel].rxlen = len;
  82.     }
  83. }
  84. #endif
  85.  
  86. #if IR_TX_ENABLE==1
  87. void sns_irTransceive_TX_done_callback(uint8_t channel)
  88. {
  89.     if (channel < IR_SUPPORTED_NUM_CHANNELS)
  90.     {
  91.         irTxChannel[channel].sendComplete = TRUE;
  92.     }
  93. }
  94. #endif
  95.  
  96. void sns_irTransceive_Init(void)
  97. {
  98. /* Debug IO, PB7 */
  99. gpio_set_out(GPIO_D7);
  100. gpio_set_pin(GPIO_D7);
  101. gpio_set_out(GPIO_B0);
  102. gpio_set_pin(GPIO_B0);
  103. gpio_set_out(GPIO_B7);
  104. gpio_set_pin(GPIO_B7);
  105.  
  106.     StdCan_Set_class(irTxMsg.Header, CAN_MODULE_CLASS_SNS);
  107.     StdCan_Set_direction(irTxMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  108.     irTxMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  109.     irTxMsg.Header.ModuleId = sns_irTransceive_ID;
  110.     irTxMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_IR;
  111.     irTxMsg.Length = 6;
  112.  
  113.     for (uint8_t i = 0; i < IR_SUPPORTED_NUM_CHANNELS; i++)
  114.     {
  115. #if IR_RX_ENABLE==1
  116.         irRxChannel[i].state = sns_irTransceive_STATE_DISABLED;
  117.         irRxChannel[i].newData = FALSE;
  118.         irRxChannel[i].rxlen = 0;
  119.         irRxChannel[i].proto.timeout=0;
  120.         irRxChannel[i].proto.data=0;
  121.         irRxChannel[i].proto.repeats=0;
  122.         irRxChannel[i].proto.protocol=0;
  123. #endif
  124.  
  125. #if IR_TX_ENABLE==1
  126.         irTxChannel[i].state = sns_irTransceive_STATE_DISABLED;
  127.         irTxChannel[i].sendComplete = FALSE;
  128.         irTxChannel[i].repeatCount = 0;
  129.         irTxChannel[i].txlen = 0;
  130.         irTxChannel[i].proto.data=0;
  131.         irTxChannel[i].proto.repeats=0;
  132.         irTxChannel[i].proto.framecnt=0;
  133.         irTxChannel[i].proto.protocol=0;
  134. #endif
  135.     }
  136.    
  137. #if IR_RX_ENABLE==1
  138.     irRxChannel[0].timerNum=sns_irTransceive_RX0_REPEATE_TIMER;
  139.     irRxChannel[1].timerNum=sns_irTransceive_RX1_REPEATE_TIMER;
  140.     irRxChannel[2].timerNum=sns_irTransceive_RX2_REPEATE_TIMER;
  141. #endif
  142.  
  143. #if IR_TX_ENABLE==1
  144.     irTxChannel[0].timerNum=sns_irTransceive_TX0_REPEATE_TIMER;
  145.     irTxChannel[1].timerNum=sns_irTransceive_TX1_REPEATE_TIMER;
  146.     irTxChannel[2].timerNum=sns_irTransceive_TX2_REPEATE_TIMER;
  147. #endif
  148.    
  149.     IrTransceiver_Init();
  150.     /* Configure all TX VCC pins as outputs and disable them */
  151.     gpio_set_out(sns_irTransceive_VCC_EN0_PIN);
  152.     gpio_set_out(sns_irTransceive_VCC_EN1_PIN);
  153.     gpio_set_out(sns_irTransceive_VCC_EN2_PIN);
  154.     gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
  155.     gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
  156.     gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
  157.  
  158. #if IR_TX_ENABLE==1
  159.     gpio_set_out(sns_irTransceive_MOD_PIN);
  160.     gpio_set_out(sns_irTransceive_TX0_PIN);
  161.     gpio_set_out(sns_irTransceive_TX1_PIN);
  162.     gpio_set_out(sns_irTransceive_TX2_PIN);
  163. #if IR_TX_ACTIVE_LOW==1
  164.     gpio_set_pin(sns_irTransceive_TX0_PIN);
  165.     gpio_set_pin(sns_irTransceive_TX1_PIN);
  166.     gpio_set_pin(sns_irTransceive_TX2_PIN);
  167. #endif
  168. #endif
  169.    
  170.     /* IR tx power pins on PCA95xx */
  171. #if sns_irTransceive_ENABLE_PCA95xx==1
  172.     Pca95xx_Init(0);
  173.     Pca95xx_clr_pin(sns_irTransceive_TX0_PWRl);
  174.     Pca95xx_set_out(sns_irTransceive_TX0_PWRl);
  175.     Pca95xx_clr_pin(sns_irTransceive_TX0_PWRh);
  176.     Pca95xx_set_out(sns_irTransceive_TX0_PWRh);
  177.    
  178.     Pca95xx_clr_pin(sns_irTransceive_TX1_PWRl);
  179.     Pca95xx_set_out(sns_irTransceive_TX1_PWRl);
  180.     Pca95xx_clr_pin(sns_irTransceive_TX1_PWRh);
  181.     Pca95xx_set_out(sns_irTransceive_TX1_PWRh);
  182.    
  183.     Pca95xx_clr_pin(sns_irTransceive_TX2_PWRl);
  184.     Pca95xx_set_out(sns_irTransceive_TX2_PWRl);
  185.     Pca95xx_clr_pin(sns_irTransceive_TX2_PWRh);
  186.     Pca95xx_set_out(sns_irTransceive_TX2_PWRh);
  187. #endif
  188.    
  189. }
  190.  
  191. void sns_irTransceive_Process(void)
  192. {
  193.     for (uint8_t channel=0; channel < IR_SUPPORTED_NUM_CHANNELS; channel++)
  194.     {
  195.  
  196. #if IR_RX_ENABLE==1
  197.         switch (irRxChannel[channel].state)
  198.         {
  199.         case sns_irTransceive_STATE_IDLE:
  200.             irRxChannel[channel].state = sns_irTransceive_STATE_START_RECEIVE;
  201.             break;
  202.  
  203.         case sns_irTransceive_STATE_START_RECEIVE:
  204.             IrTransceiver_ResetRx(channel);
  205.             cli();
  206.             irRxChannel[channel].newData = FALSE;
  207.             sei();
  208.             irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
  209.             break;
  210.        
  211.         case sns_irTransceive_STATE_RECEIVING:
  212.             if (irRxChannel[channel].newData == TRUE) {
  213.                 //TODO: move this line to the RX callback
  214.                 IrTransceiver_DisableRx(channel);
  215.                 cli();
  216.                 irRxChannel[channel].newData = FALSE;
  217.                 sei();
  218.  
  219.                 /* Let protocol driver parse and then send on CAN */
  220.                 uint8_t res2 = parseProtocol(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen, &irRxChannel[channel].proto);
  221.                 if (res2 == IR_OK && irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
  222.                     irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED;
  223.                     irTxMsg.Data[0] |= channel<<4;
  224.                     irTxMsg.Data[1] = irRxChannel[channel].proto.protocol;
  225.                     irTxMsg.Data[2] = (irRxChannel[channel].proto.data>>24)&0xff;
  226.                     irTxMsg.Data[3] = (irRxChannel[channel].proto.data>>16)&0xff;
  227.                     irTxMsg.Data[4] = (irRxChannel[channel].proto.data>>8)&0xff;
  228.                     irTxMsg.Data[5] = irRxChannel[channel].proto.data&0xff;
  229.  
  230.                     StdCan_Put(&irTxMsg);
  231.                 }
  232.                 else if (irRxChannel[channel].proto.protocol == IR_PROTO_UNKNOWN)
  233.                 {
  234. #if (sns_irTransceive_SEND_DEBUG==1)
  235.                     send_debug(irRxChannel[channel].rxbuf, irRxChannel[channel].rxlen);
  236.                     irRxChannel[channel].proto.timeout=300;
  237. #endif
  238.                 }
  239.                
  240.                 /* Enable the receiver again */
  241.                 IrTransceiver_EnableRx(channel);
  242.                
  243.                 irRxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
  244.             }
  245.             break;
  246.  
  247.         case sns_irTransceive_STATE_START_PAUSE:
  248.             /* set a timer so we can send release button event when no new IR is arriving */
  249.             Timer_SetTimeout(irRxChannel[channel].timerNum, irRxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
  250.             irRxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
  251.             break;
  252.  
  253.         case sns_irTransceive_STATE_PAUSING:
  254.             /* reset timer if new IR arrived */
  255.             if (irRxChannel[channel].newData == TRUE || IrTransceiver_GetStoreEnableRx(channel) == TRUE) {
  256.                 cli();
  257.                 irRxChannel[channel].newData = FALSE;
  258.                 sei();
  259.                 Timer_SetTimeout(irRxChannel[channel].timerNum, irRxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
  260.             }
  261.        
  262.             if (Timer_Expired(irRxChannel[channel].timerNum)) {
  263.                 irRxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
  264.             }
  265.             break;
  266.  
  267.         case sns_irTransceive_STATE_START_IDLE:
  268.             if (irRxChannel[channel].proto.protocol != IR_PROTO_UNKNOWN) {
  269.                 /* Send button release command on CAN */
  270.                 irTxMsg.Data[0] = 0xf&CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED;
  271.                 irTxMsg.Data[0] |= channel<<4;
  272.                 irTxMsg.Data[1] = irRxChannel[channel].proto.protocol;
  273.                 irTxMsg.Data[2] = (irRxChannel[channel].proto.data>>24)&0xff;
  274.                 irTxMsg.Data[3] = (irRxChannel[channel].proto.data>>16)&0xff;
  275.                 irTxMsg.Data[4] = (irRxChannel[channel].proto.data>>8)&0xff;
  276.                 irTxMsg.Data[5] = irRxChannel[channel].proto.data&0xff;
  277.  
  278.                 StdCan_Put(&irTxMsg);
  279.             }
  280.             irRxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  281.             break;
  282.  
  283.         default:
  284.             break;
  285.         }
  286. #endif
  287.  
  288. #if IR_TX_ENABLE==1
  289.         switch (irTxChannel[channel].state)
  290.         {
  291.         case sns_irTransceive_STATE_IDLE:
  292.             /* transmission is started when a command is received on can */
  293.             break;
  294.  
  295.         case sns_irTransceive_STATE_START_TRANSMIT:
  296.             if (expandProtocol(irTxChannel[channel].txbuf, &irTxChannel[channel].txlen, &irTxChannel[channel].proto) == IR_OK)
  297.             {
  298.                 IrTransceiver_Transmit(channel, irTxChannel[channel].txbuf, irTxChannel[channel].txlen);
  299.                 irTxChannel[channel].state = sns_irTransceive_STATE_TRANSMITTING;
  300.             }
  301.             else
  302.             {
  303.                 irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  304.             }
  305.             break;
  306.        
  307.         case sns_irTransceive_STATE_TRANSMITTING:
  308.             if (irTxChannel[channel].sendComplete == TRUE)
  309.             {
  310.                 cli();
  311.                 irTxChannel[channel].sendComplete = FALSE;
  312.                 sei();
  313.                 irTxChannel[channel].state = sns_irTransceive_STATE_START_PAUSE;
  314.             }
  315.             break;
  316.  
  317.         case sns_irTransceive_STATE_START_PAUSE:
  318.             if (irTxChannel[channel].repeatCount < irTxChannel[channel].proto.repeats)
  319.             {
  320.                 irTxChannel[channel].repeatCount++;
  321.             }
  322.            
  323.             Timer_SetTimeout(irTxChannel[channel].timerNum, irTxChannel[channel].proto.timeout, TimerTypeOneShot, 0);
  324.  
  325.             if (irTxChannel[channel].proto.framecnt != 255)
  326.             {
  327.                 irTxChannel[channel].proto.framecnt++;
  328.             }
  329.            
  330.             irTxChannel[channel].state = sns_irTransceive_STATE_PAUSING;
  331.             break;
  332.  
  333.         case sns_irTransceive_STATE_PAUSING:
  334.             if (Timer_Expired(irTxChannel[channel].timerNum))
  335.             {
  336.                 irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
  337.             }
  338.            
  339.             /* transmission is stopped when such command is recevied on can */
  340.             if (irTxChannel[channel].stopSend == TRUE && irTxChannel[channel].repeatCount >= irTxChannel[channel].proto.repeats)
  341.             {
  342.                 //TODO maybe send message on can for status? to confirm stopped sending, ready for new command
  343.                 irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
  344.             }
  345.             break;
  346.  
  347.         case sns_irTransceive_STATE_START_IDLE:
  348.             irTxChannel[channel].stopSend = FALSE;
  349.             irTxChannel[channel].repeatCount = 0;
  350.             irTxChannel[channel].proto.framecnt = 0;
  351.            
  352.             irTxChannel[channel].state = sns_irTransceive_STATE_IDLE;
  353.             break;
  354.  
  355.         default:
  356.             break;
  357.         }
  358. #endif
  359.  
  360.     }
  361. }
  362.  
  363. /* Handle incoming CAN data */
  364. void sns_irTransceive_HandleMessage(StdCan_Msg_t *rxMsg)
  365. {
  366.     if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_SNS &&
  367.         StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&
  368.         rxMsg->Header.ModuleType == CAN_MODULE_TYPE_SNS_IRTRANSCEIVE &&
  369.         rxMsg->Header.ModuleId == sns_irTransceive_ID)
  370.     {
  371.         uint8_t channel;
  372.         switch (rxMsg->Header.Command)
  373.         {
  374.         case CAN_MODULE_CMD_PHYSICAL_IR:
  375.             channel = rxMsg->Data[0]>>4;
  376.             if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_PRESSED && channel < IR_SUPPORTED_NUM_CHANNELS)
  377.             {
  378.                 if (irTxChannel[channel].state == sns_irTransceive_STATE_IDLE)
  379.                 {
  380.                     irTxChannel[channel].proto.protocol = rxMsg->Data[1];
  381.  
  382.                     irTxChannel[channel].proto.data = rxMsg->Data[2];
  383.                     irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
  384.                     irTxChannel[channel].proto.data |= rxMsg->Data[3];
  385.                     irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
  386.                     irTxChannel[channel].proto.data |= rxMsg->Data[4];
  387.                     irTxChannel[channel].proto.data = irTxChannel[channel].proto.data<<8;
  388.                     irTxChannel[channel].proto.data |= rxMsg->Data[5];
  389.  
  390.                     irTxChannel[channel].state = sns_irTransceive_STATE_START_TRANSMIT;
  391.                 }
  392.             }
  393.             else if ((0xf&rxMsg->Data[0]) == CAN_MODULE_ENUM_PHYSICAL_IR_STATUS_RELEASED && channel < IR_SUPPORTED_NUM_CHANNELS)
  394.             {
  395.                 if (irTxChannel[channel].state != sns_irTransceive_STATE_IDLE)
  396.                 {
  397.                     irTxChannel[channel].stopSend = TRUE;
  398.                 }
  399.             }
  400.             break;
  401.        
  402.         case CAN_MODULE_CMD_IRTRANSCEIVE_IRCONFIG:
  403.             channel = rxMsg->Data[0]>>4;
  404.             uint8_t config = rxMsg->Data[0] & 0x0f;
  405.             uint8_t power = rxMsg->Data[1]>>6;
  406.  
  407.             if (channel < IR_SUPPORTED_NUM_CHANNELS && config <= CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE && power < 4)
  408.             {
  409. #if IR_RX_ENABLE==1
  410.                 if (config == CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_RECEIVE)
  411.                 {
  412. #if IR_TX_ENABLE==1
  413.                     irTxChannel[channel].state = sns_irTransceive_STATE_DISABLED;
  414. #endif
  415.                     irRxChannel[channel].rxbuf = buf[channel];
  416.                     switch (channel)
  417.                     {
  418.                         case 0:
  419.                             gpio_clr_pin(sns_irTransceive_VCC_EN0_PIN);
  420.                             IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
  421.                             break;
  422.                         case 1:
  423.                             gpio_clr_pin(sns_irTransceive_VCC_EN1_PIN);
  424.                             IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
  425.                             break;
  426.                         case 2:
  427.                             gpio_clr_pin(sns_irTransceive_VCC_EN2_PIN);
  428.                             IrTransceiver_InitRxChannel(channel, irRxChannel[channel].rxbuf, sns_irTransceive_RX_done_callback, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
  429.                             break;
  430.                     }
  431.                     irRxChannel[channel].state = sns_irTransceive_STATE_RECEIVING;
  432.                 }
  433. #endif
  434.  
  435.  
  436.    
  437. //  Pca95xx_set_out(sns_irTransceive_TX1_PWRl);
  438. //  Pca95xx_set_out(sns_irTransceive_TX1_PWRh);
  439.    
  440. //  Pca95xx_set_out(sns_irTransceive_TX2_PWRl);
  441. //  Pca95xx_set_out(sns_irTransceive_TX2_PWRh);
  442.  
  443.  
  444.  
  445. #if IR_TX_ENABLE==1
  446.                 if (config == CAN_MODULE_ENUM_IRTRANSCEIVE_IRCONFIG_DIRECTION_TRANSMIT)
  447.                 {
  448. #if IR_RX_ENABLE==1
  449.                     irRxChannel[channel].state = sns_irTransceive_STATE_DISABLED;
  450. #endif
  451.                    
  452.                     irTxChannel[channel].txbuf = buf[channel];
  453.                     switch (channel)
  454.                     {
  455.                         case 0:
  456. #if IR_RX_ENABLE==1
  457.                             gpio_set_pin(sns_irTransceive_VCC_EN0_PIN);
  458.                             IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX0_PCINT, sns_irTransceive_RX0_PIN);
  459. #endif
  460.                             IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX0_PIN);
  461.  
  462. #if sns_irTransceive_ENABLE_PCA95xx==1
  463.                             Pca95xx_set_out(sns_irTransceive_TX0_PWRl);
  464.                             Pca95xx_set_out(sns_irTransceive_TX0_PWRh);
  465.                             if (power&0x1)
  466.                             {
  467.                                 Pca95xx_set_in(sns_irTransceive_TX0_PWRl);
  468.                             }
  469.                             if (power&0x2)
  470.                             {
  471.                                 Pca95xx_set_in(sns_irTransceive_TX0_PWRh);
  472.                             }
  473. #endif
  474.                             break;
  475.                         case 1:
  476. #if IR_RX_ENABLE==1
  477.                             gpio_set_pin(sns_irTransceive_VCC_EN1_PIN);
  478.                             IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX1_PCINT, sns_irTransceive_RX1_PIN);
  479. #endif
  480.                             IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX1_PIN);
  481.                            
  482. #if sns_irTransceive_ENABLE_PCA95xx==1
  483.                             Pca95xx_set_out(sns_irTransceive_TX1_PWRl);
  484.                             Pca95xx_set_out(sns_irTransceive_TX1_PWRh);
  485.                             if (power&0x1)
  486.                             {
  487.                                 Pca95xx_set_in(sns_irTransceive_TX1_PWRl);
  488.                             }
  489.                             if (power&0x2)
  490.                             {
  491.                                 Pca95xx_set_in(sns_irTransceive_TX1_PWRh);
  492.                             }
  493. #endif
  494.                             break;
  495.                         case 2:
  496. #if IR_RX_ENABLE==1
  497.                             gpio_set_pin(sns_irTransceive_VCC_EN2_PIN);
  498.                             IrTransceiver_DeInitRxChannel(channel, sns_irTransceive_RX2_PCINT, sns_irTransceive_RX2_PIN);
  499. #endif
  500.                             IrTransceiver_InitTxChannel(channel, sns_irTransceive_TX_done_callback, sns_irTransceive_TX2_PIN);
  501.                            
  502. #if sns_irTransceive_ENABLE_PCA95xx==1
  503.                             Pca95xx_set_out(sns_irTransceive_TX2_PWRl);
  504.                             Pca95xx_set_out(sns_irTransceive_TX2_PWRh);
  505.                             if (power&0x1)
  506.                             {
  507.                                 Pca95xx_set_in(sns_irTransceive_TX2_PWRl);
  508.                             }
  509.                             if (power&0x2)
  510.                             {
  511.                                 Pca95xx_set_in(sns_irTransceive_TX2_PWRh);
  512.                             }
  513. #endif
  514.                             break;
  515.                     }
  516.                     irTxChannel[channel].state = sns_irTransceive_STATE_START_IDLE;
  517.                 }
  518. #endif
  519.             }
  520.             break;
  521.         }
  522.     }
  523. }
  524.  
  525. void sns_irTransceive_List(uint8_t ModuleSequenceNumber)
  526. {
  527.     StdCan_Msg_t txMsg;
  528.    
  529.     StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
  530.     StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  531.     txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_IRTRANSCEIVE;
  532.  
  533.     txMsg.Header.ModuleId = sns_irTransceive_ID;
  534.     txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_LIST;
  535.     txMsg.Length = 6;
  536.  
  537.     txMsg.Data[0] = NODE_HW_ID_BYTE0;
  538.     txMsg.Data[1] = NODE_HW_ID_BYTE1;
  539.     txMsg.Data[2] = NODE_HW_ID_BYTE2;
  540.     txMsg.Data[3] = NODE_HW_ID_BYTE3;
  541.    
  542.     txMsg.Data[4] = NUMBER_OF_MODULES;
  543.     txMsg.Data[5] = ModuleSequenceNumber;
  544.    
  545.     while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  546. }
  547.