Subversion Repositories HomeAutomation

Rev

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