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

 };
 #endif
 // internal variables
 static uint32_t baudRate = 9600;
-static uint16_t format = CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK;
+//static uint16_t format = CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK;
+static uint16_t format = CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS232;
 static uint8_t databits = 8;
 static uint8_t stopbits = 1;
 static enum {
     PARITY_NONE = 0,
     PARITY_EVEN = 1,
     PARITY_ODD = 2,
-} parityMode;
+} parityMode = 1;
+// filter variables
+static uint8_t dataTimeout = 0;
+static uint8_t packetLength = 0;
+static struct __attribute__ ((packed)) {
+    uint8_t prefixLength:2;
+    uint8_t suffixLength:2;
+    uint8_t prefixPattern[3];
+    uint8_t suffixPattern[3];
+} filter;
 // prepare a new message, in case new data is available
 static StdCan_Msg_t msg;
 #define sns_Serial_DEBUG 0
 #ifndef min
 #define min(_a,_b)      ((_a)<(_b) ? (_a) : (_b))
 #endif
 #ifndef max
 #define max(_a,_b)      ((_a)>(_b) ? (_a) : (_b))
 #endif
 #ifndef lim
 #define lim(_a,_minval,_maxval)     (max(min((_a),(_maxval)),(_minval)))
 #endif
 uint8_t sns_Serial_setSettings(void)
+{
     if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS232)
+    {
 #if sns_Serial_DEBUG==1
         printf("RS232\n");
 #endif
         gpio_clr_pin(sns_Serial_485_CONNECT);   // disable RS485_CONNECT
         gpio_clr_pin(sns_Serial_TERM_EN);       // disable termination
         gpio_clr_pin(sns_Serial_485_232);       // RS232 mode
         gpio_set_pin(sns_Serial_RXEN);          // enable RX
         gpio_set_pin(sns_Serial_ON);            // enable charge pump
+    }
     else if (format == CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_RS485FULLDUPLEX)
     else
+    {
         //invalid format
 #if sns_Serial_DEBUG==1
         printf("ERROR!\n");
 #endif
         //return 0, not successful
         returnval = 0;
+    }
     return returnval;
+}
 void sns_Serial_Init(void)
+{
 #ifdef sns_Serial_USEEEPROM
-    if (EEDATA_OK) {
+    //if (EEDATA_OK) {
+    if (0) {
 #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)
         baudRate = eeprom_read_dword(EEDATA32.baudRate);
 #else
 #warning This version of AVR-libc does not have support for eeprom read dword
 #endif
         format = eeprom_read_word(EEDATA16.format);
         databits = eeprom_read_byte(EEDATA.databits);
         stopbits = eeprom_read_byte(EEDATA.stopbits);
         parityMode = eeprom_read_byte(EEDATA.parityMode);
+        dataTimeout = eeprom_read_byte(EEDATA.dataTimeout);
+        packetLength = eeprom_read_byte(EEDATA.packetLength);
+        filter.prefixLength = lim(eeprom_read_byte(EEDATA.prefixLength), 0, 3);
+        filter.suffixLength = lim(eeprom_read_byte(EEDATA.suffixLength), 0, 3);
+        filter.prefixPattern[0] = eeprom_read_byte(EEDATA.prefixPattern[0]);
+        filter.prefixPattern[1] = eeprom_read_byte(EEDATA.prefixPattern[1]);
+        filter.prefixPattern[2] = eeprom_read_byte(EEDATA.prefixPattern[2]);
+        filter.suffixPattern[0] = eeprom_read_byte(EEDATA.suffixPattern[0]);
+        filter.suffixPattern[1] = eeprom_read_byte(EEDATA.suffixPattern[1]);
+        filter.suffixPattern[2] = eeprom_read_byte(EEDATA.suffixPattern[2]);
+    }
     else {
         //The CRC of the EEPROM is not correct, store default values and update CRC
 #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)
         eeprom_write_dword_crc(EEDATA32.baudRate, 9600, WITHOUT_CRC);
 #endif
         eeprom_write_word_crc(EEDATA16.format, CAN_MODULE_ENUM_SERIAL_SERIALCONFIG_PHYSICALFORMAT_LOOPBACK, WITHOUT_CRC);
         eeprom_write_byte_crc(EEDATA.databits, 8, WITHOUT_CRC);
         eeprom_write_byte_crc(EEDATA.stopbits, 1, WITHOUT_CRC);
         eeprom_write_byte_crc(EEDATA.parityMode, PARITY_NONE, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.dataTimeout, 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.packetLength, 8, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.prefixLength, 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.suffixLength, 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.prefixPattern[0], 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.prefixPattern[1], 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.prefixPattern[2], 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.suffixPattern[0], 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.suffixPattern[1], 0, WITHOUT_CRC);
+        eeprom_write_byte_crc(EEDATA.suffixPattern[2], 0, WITHOUT_CRC);
         EEDATA_UPDATE_CRC;
+    }
 #endif
     uart_setDatabits(databits);
     uart_setStopbits(stopbits);
     uart_setParity(parityMode!=PARITY_NONE, parityMode==PARITY_ODD);
-    // default baudrate
     uart_init(UART_BAUD_SELECT(baudRate, F_CPU));
     // configure control pins to outputs
     gpio_set_out(sns_Serial_RXEN);
     gpio_set_out(sns_Serial_TXEN);
 #if sns_Serial_DEBUG==1
     printf("Serial started!\n");
 #endif
     msg.Length = 0; // no data so far
+    //gpio_set_pin(sns_Serial_TXEN);            // enable TX
+    //uart_putc('7');
+}
 void sns_Serial_Process(void)
+{
     StdCan_Set_class(msg.Header, CAN_MODULE_CLASS_SNS);
 #if sns_Serial_FORCE_SEND_TIME_MS > 0
             Timer_SetTimeout(sns_Serial_FORCE_SEND_TIMER, sns_Serial_FORCE_SEND_TIME_MS , TimerTypeOneShot, 0);
 #endif
+        }
     // keep going until max data length reached, or until uart RXBUF is empty
-    } while (status == 0 && msg.Length < 8);
+    } while (status == 0 && msg.Length < packetLength);
     // check if force send or send-frame full
-    if ((Timer_Expired(sns_Serial_FORCE_SEND_TIMER) && msg.Length>0) || msg.Length == 8 || (sns_Serial_FORCE_SEND_TIME_MS == 0 && msg.Length>0))
+    if ((Timer_Expired(sns_Serial_FORCE_SEND_TIMER) && msg.Length>0) || msg.Length == packetLength || (sns_Serial_FORCE_SEND_TIME_MS == 0 && msg.Length>0))
+    {
         // transmit this chunk of data (max 8 chars)
         while(StdCan_Put(&msg) != StdCan_Ret_OK);
         msg.Length = 0; // no data so far
+    }
+                {
                     uart_putc(rxMsg->Data[i]);
+                }
                 /* TODO Cannot disable TX yet, the data has only been placed in buffer but not sent */
 //              gpio_clr_pin(sns_Serial_TXEN);          // disable TX
                 break;
             case CAN_MODULE_CMD_SERIAL_SERIALCONFIG:
                 baudRate = 10 * (((uint32_t)rxMsg->Data[1] << 0) | ((uint32_t)rxMsg->Data[0] << 8));
                 format = (uint16_t)rxMsg->Data[2];
                 databits = lim(rxMsg->Data[3], 5, 9);
                 parityMode = lim(rxMsg->Data[5], 0, 2);
                 uart_setDatabits(databits);
                 uart_setStopbits(stopbits);
                 uart_setParity(parityMode!=PARITY_NONE, parityMode==PARITY_ODD);
                 uart_init(UART_BAUD_SELECT(baudRate, F_CPU));
                 uint8_t returnval = sns_Serial_setSettings();
                 if (returnval)
+                {
                 // update EEPROM data
 #ifdef sns_Serial_USEEEPROM
 #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)
                 eeprom_write_dword_crc(EEDATA32.baudRate, baudRate, WITHOUT_CRC);
 #else
 #warning This version of AVR-libc does not have support for eeprom read dword
 #endif
                 eeprom_write_word_crc(EEDATA16.format, format, WITHOUT_CRC);
                 eeprom_write_byte_crc(EEDATA.databits, databits, WITHOUT_CRC);
                 eeprom_write_byte_crc(EEDATA.stopbits, stopbits, WITHOUT_CRC);
                 eeprom_write_byte_crc(EEDATA.parityMode, parityMode, WITHOUT_CRC);
                 EEDATA_UPDATE_CRC;
 #endif
+                }
+                break;
+            case CAN_MODULE_CMD_SERIAL_SERIALFILTER:
+                dataTimeout = rxMsg->Data[0];
+                filter.prefixLength = ((rxMsg->Data[1] & 0x0F) >> 0);
+                filter.suffixLength = ((rxMsg->Data[1] & 0x30) >> 4);
+                packetLength = ((rxMsg->Data[1] & 0xC0) >> 6);
+                filter.prefixPattern[2] = rxMsg->Data[2];
+                filter.prefixPattern[1] = rxMsg->Data[3];
+                filter.prefixPattern[0] = rxMsg->Data[4];
+                filter.suffixPattern[2] = rxMsg->Data[5];
+                filter.suffixPattern[1] = rxMsg->Data[6];
+                filter.suffixPattern[0] = rxMsg->Data[7];
+                // update EEPROM data
+                eeprom_write_byte_crc(EEDATA.dataTimeout, dataTimeout, WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.packetLength, packetLength, WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.prefixLength, filter.prefixLength, WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.suffixLength, filter.suffixLength, WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.prefixPattern[0], filter.prefixPattern[0], WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.prefixPattern[1], filter.prefixPattern[1], WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.prefixPattern[2], filter.prefixPattern[2], WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.suffixPattern[0], filter.suffixPattern[0], WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.suffixPattern[1], filter.suffixPattern[1], WITHOUT_CRC);
+                eeprom_write_byte_crc(EEDATA.suffixPattern[2], filter.suffixPattern[2], WITHOUT_CRC);
+                EEDATA_UPDATE_CRC;
                 break;
+        }
+    }
+}

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/module/sns_Serial/sns_Serial.c – Rev 1751 → 1764