Subversion Repositories HomeAutomation

Rev

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

  1.  
  2. #include "sns_Serial.h"
  3.  
  4. #ifdef sns_Serial_USEEEPROM
  5. #include "sns_Serial_eeprom.h"
  6. struct eeprom_sns_Serial EEMEM eeprom_sns_Serial =
  7. {
  8.     {
  9.         ///TODO: Define initialization values on the EEPROM variables here, 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. Write the values in the exact same order as the struct is defined in the *.h file.
  10.         0xAB,   // x
  11.         0x1234  // y
  12.     },
  13.     0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
  14. };
  15. #endif
  16.  
  17. // internal variables
  18. static uint32_t baudRate = 9600;
  19. static uint16_t format = CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK;
  20.  
  21. // prepare a new message, in case new data is available
  22. static StdCan_Msg_t msg;
  23.  
  24. #define sns_Serial_DEBUG 0
  25.  
  26. void sns_Serial_Init(void)
  27. {
  28. #ifdef sns_Serial_USEEEPROM
  29.     if (EEDATA_OK) {
  30. #if ((__AVR_LIBC_MAJOR__ == 1  && __AVR_LIBC_MINOR__ == 6 && __AVR_LIBC_REVISION__ >=2)||(__AVR_LIBC_MAJOR__ == 1  && __AVR_LIBC_MINOR__ > 6)||__AVR_LIBC_MAJOR__ > 1)
  31.         baudRate = eeprom_read_dword(EEDATA32.baudRate);
  32. #else
  33. #warning This version of AVR-libc does not have support for eeprom read dword
  34. #endif
  35.         format = eeprom_read_word(EEDATA16.format);
  36.     }
  37.     else {
  38.         //The CRC of the EEPROM is not correct, store default values and update CRC
  39. #if ((__AVR_LIBC_MAJOR__ == 1  && __AVR_LIBC_MINOR__ == 6 && __AVR_LIBC_REVISION__ >=2)||(__AVR_LIBC_MAJOR__ == 1  && __AVR_LIBC_MINOR__ > 6)||__AVR_LIBC_MAJOR__ > 1)
  40.         eeprom_write_dword_crc(EEDATA32.baudRate, 9600, WITHOUT_CRC);
  41. #else
  42. #warning This version of AVR-libc does not have support for eeprom write dword
  43. #endif
  44.         eeprom_write_word_crc(EEDATA16.format, CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK, WITHOUT_CRC);
  45.         EEDATA_UPDATE_CRC;
  46.     }
  47. #endif
  48.     // default baudrate
  49.     uart_init(UART_BAUD_SELECT(baudRate, F_CPU));
  50.     // configure control pins
  51.     gpio_set_out(sns_Serial_RXEN);
  52.     gpio_set_out(sns_Serial_TXEN);
  53.     gpio_set_out(sns_Serial_ON);
  54.     gpio_set_out(sns_Serial_485_232);
  55.     gpio_set_out(sns_Serial_TERM_EN);
  56.     gpio_set_out(sns_Serial_485_CONNECT);
  57.     //default to loopback mode until config command received
  58.     gpio_clr_pin(sns_Serial_ON);
  59.     gpio_clr_pin(sns_Serial_485_232);
  60.     gpio_clr_pin(sns_Serial_485_CONNECT);   // disable RS485_CONNECT
  61.     gpio_clr_pin(sns_Serial_TERM_EN);       // disable termination
  62.     gpio_set_pin(sns_Serial_485_232);       // RS232 mode
  63.     gpio_set_pin(sns_Serial_RXEN);          // enable RX
  64.     gpio_set_pin(sns_Serial_TXEN);          // enable TX
  65.  
  66.     // to use PCINt lib, call this function: (the callback function look as a timer callback function)
  67.     // Pcint_SetCallbackPin(sns_Serial_PCINT, EXP_C , &sns_Serial_pcint_callback);
  68.  
  69. #if sns_Serial_DEBUG==1
  70.     printf("Serial started!\n");
  71. #endif
  72.  
  73.     msg.Length = 0; // no data so far
  74. }
  75.  
  76. //unsigned char sData[8];
  77. //uint8_t dataCnt=0;
  78.  
  79. void sns_Serial_Process(void)
  80. {
  81.     StdCan_Set_class(msg.Header, CAN_MODULE_CLASS_SNS);
  82.     StdCan_Set_direction(msg.Header, DIRECTIONFLAG_TO_OWNER);
  83.     msg.Header.ModuleType = CAN_MODULE_TYPE_SNS_SERIAL;
  84.     msg.Header.ModuleId = sns_Serial_ID;
  85.     msg.Header.Command = CAN_MODULE_CMD_SERIAL_SERIALDATA;
  86.    
  87.     unsigned char status;
  88.    
  89.     do
  90.     {
  91.         // ask uart driver for more data
  92.         unsigned int data = uart_getc();
  93.         // character is contained in LSB
  94.         unsigned char c = (unsigned char)(data & 0x00FF);
  95.         // status is contained in MSB
  96.         status = (unsigned char)((data & 0xFF00) >> 8);
  97.        
  98.         // status == 0 means we just received a new char
  99.         if (status == 0)
  100.         {
  101. #if sns_Serial_DEBUG==1
  102.             printf("RX\n");
  103. #endif
  104.             // insert it into the message
  105.             msg.Data[(uint8_t)msg.Length] = c;
  106.             msg.Length++;
  107.            
  108. #if sns_Serial_FORCE_SEND_TIME_MS > 0
  109.             Timer_SetTimeout(sns_Serial_FORCE_SEND_TIMER, sns_Serial_FORCE_SEND_TIME_MS , TimerTypeOneShot, 0);
  110. #endif
  111.         }
  112.     // keep going until max data length reached, or until uart RXBUF is empty
  113.     } while (status == 0 && msg.Length < 8);
  114.    
  115.     // check if force send or send-frame full
  116.     if (Timer_Expired(sns_Serial_FORCE_SEND_TIMER) || msg.Length == 8 || (sns_Serial_FORCE_SEND_TIME_MS == 0 && msg.Length>0))
  117.     {
  118.         // transmit this chunk of data (max 8 chars)
  119.         while(StdCan_Put(&msg) != StdCan_Ret_OK);
  120.         msg.Length = 0; // no data so far
  121.     }
  122. }
  123.  
  124. void sns_Serial_HandleMessage(StdCan_Msg_t *rxMsg)
  125. {
  126.     if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_SNS &&
  127.         StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_FROM_OWNER &&
  128.         rxMsg->Header.ModuleType == CAN_MODULE_TYPE_SNS_SERIAL &&
  129.         rxMsg->Header.ModuleId == sns_Serial_ID)
  130.     {
  131.         switch (rxMsg->Header.Command)
  132.         {
  133.             case CAN_MODULE_CMD_SERIAL_SERIALDATA:
  134. #if sns_Serial_DEBUG==1
  135.                 printf("TX\n");
  136. #endif
  137.                 gpio_set_pin(sns_Serial_TXEN);          // enable TX
  138.                 for (uint8_t i=0; i<rxMsg->Length; i++)
  139.                 {
  140.                     uart_putc(rxMsg->Data[i]);
  141.                 }
  142.                 /* TODO Cannot disable TX yet, the data has only been placed in buffer but not sent */
  143. //              gpio_clr_pin(sns_Serial_TXEN);          // disable TX
  144.                 break;
  145.             case CAN_MODULE_CMD_SERIAL_SERIALCONFIG:
  146.                 baudRate = 10 * (((uint32_t)rxMsg->Data[1] << 0) | ((uint32_t)rxMsg->Data[0] << 8));
  147.                 format = (uint16_t)rxMsg->Data[2];
  148.                 uart_init(UART_BAUD_SELECT(baudRate, F_CPU));
  149.                 if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS232)
  150.                 {
  151. #if sns_Serial_DEBUG==1
  152.                     printf("RS232\n");
  153. #endif
  154.                     gpio_clr_pin(sns_Serial_485_CONNECT);   // disable RS485_CONNECT
  155.                     gpio_clr_pin(sns_Serial_TERM_EN);       // disable termination
  156.                     gpio_clr_pin(sns_Serial_485_232);       // RS232 mode
  157.                     gpio_set_pin(sns_Serial_RXEN);          // enable RX
  158.                     gpio_set_pin(sns_Serial_ON);            // enable charge pump
  159.                 }
  160.                 else if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS485FULLDUPLEX)
  161.                 {
  162. #if sns_Serial_DEBUG==1
  163.                     printf("RS485FD\n");
  164. #endif
  165.                     gpio_clr_pin(sns_Serial_485_CONNECT);   // disable RS485_CONNECT
  166.                     gpio_clr_pin(sns_Serial_TERM_EN);       // disable termination
  167.                     gpio_set_pin(sns_Serial_485_232);       // RS485 mode
  168.                     gpio_set_pin(sns_Serial_RXEN);          // enable RX
  169.                     gpio_set_pin(sns_Serial_TXEN);          // enable TX
  170.                     gpio_set_pin(sns_Serial_ON);            // enable charge pump
  171.                 }
  172.                 else if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS485HALFDUPLEX)
  173.                 {
  174. #if sns_Serial_DEBUG==1
  175.                     printf("RS485HD\n");
  176. #endif
  177.                     gpio_set_pin(sns_Serial_485_CONNECT);   // enable RS485_CONNECT
  178.                     gpio_clr_pin(sns_Serial_TERM_EN);       // disable termination
  179.                     gpio_set_pin(sns_Serial_485_232);       // RS485 mode
  180.                     gpio_set_pin(sns_Serial_RXEN);          // enable RX
  181.                 /* TODO shoud the TX really be enabled in half duplex? */
  182.                     gpio_set_pin(sns_Serial_TXEN);          // enable TX
  183.                     gpio_set_pin(sns_Serial_ON);            // enable charge pump
  184.                 }
  185.                 else if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS485HALFDUPLEXWITHTERMINATION)
  186.                 {
  187. #if sns_Serial_DEBUG==1
  188.                     printf("485HDT\n");
  189. #endif
  190.                     gpio_set_pin(sns_Serial_485_CONNECT);   // enable RS485_CONNECT
  191.                     gpio_set_pin(sns_Serial_TERM_EN);       // enable termination
  192.                     gpio_set_pin(sns_Serial_485_232);       // RS485 mode
  193.                 /* TODO shoud the TX really be enabled in half duplex? */
  194.                     gpio_set_pin(sns_Serial_RXEN);          // enable RX
  195.                     gpio_set_pin(sns_Serial_TXEN);          // enable TX
  196.                     gpio_set_pin(sns_Serial_ON);            // enable charge pump
  197.                 }
  198.                 else if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK)
  199.                 {
  200. #if sns_Serial_DEBUG==1
  201.                     printf("LPMODE\n");
  202. #endif
  203.                     gpio_clr_pin(sns_Serial_485_CONNECT);   // disable RS485_CONNECT
  204.                     gpio_clr_pin(sns_Serial_TERM_EN);       // disable termination
  205.                     gpio_set_pin(sns_Serial_485_232);       // RS232 mode
  206.                     gpio_set_pin(sns_Serial_RXEN);          // enable RX
  207.                     gpio_set_pin(sns_Serial_TXEN);          // enable TX
  208.                     gpio_clr_pin(sns_Serial_ON);            // disable charge pump (i.e. enable loopback)
  209.                 }
  210.                 else
  211.                 {
  212.                     //invalid format
  213. #if sns_Serial_DEBUG==1
  214.                     printf("ERROR!\n");
  215. #endif
  216.                     //break prematurely, to prevent data from being saved in EEPROM
  217.                     break;
  218.                 }
  219.                
  220.                 // update EEPROM data
  221. #ifdef sns_Serial_USEEEPROM
  222. #if ((__AVR_LIBC_MAJOR__ == 1  && __AVR_LIBC_MINOR__ == 6 && __AVR_LIBC_REVISION__ >=2)||(__AVR_LIBC_MAJOR__ == 1  && __AVR_LIBC_MINOR__ > 6)||__AVR_LIBC_MAJOR__ > 1)
  223.                 eeprom_write_dword_crc(EEDATA32.baudRate, 9600, WITHOUT_CRC);
  224. #else
  225. #warning This version of AVR-libc does not have support for eeprom read dword
  226. #endif
  227.                 eeprom_write_word_crc(EEDATA16.format, CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK, WITHOUT_CRC);
  228.                 EEDATA_UPDATE_CRC;
  229. #endif
  230.                
  231.                 break;
  232.         }
  233.     }
  234. }
  235.  
  236. void sns_Serial_List(uint8_t ModuleSequenceNumber)
  237. {
  238.     StdCan_Msg_t txMsg;
  239.  
  240.     StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_SNS);
  241.     StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  242.     txMsg.Header.ModuleType = CAN_MODULE_TYPE_SNS_SERIAL;
  243.     txMsg.Header.ModuleId = sns_Serial_ID;
  244.     txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_LIST;
  245.     txMsg.Length = 6;
  246.  
  247.     txMsg.Data[0] = NODE_HW_ID_BYTE0;
  248.     txMsg.Data[1] = NODE_HW_ID_BYTE1;
  249.     txMsg.Data[2] = NODE_HW_ID_BYTE2;
  250.     txMsg.Data[3] = NODE_HW_ID_BYTE3;
  251.  
  252.     txMsg.Data[4] = NUMBER_OF_MODULES;
  253.     txMsg.Data[5] = ModuleSequenceNumber;
  254.  
  255.     while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  256. }
  257.  
  258.