namespace BatCharging.Service
{
    public class SBMUCanRecvMsg
    {     
        private object lockObj = new object(); //线程同步锁

        #region 电池标准CAN信号 S2MStatus字段
        private S2MSTATUS s2MSTATUS;
        public S2MSTATUS S2MStatus
        {
            get
            {
                return s2MSTATUS;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MSTATUS = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MALARM1字段
        private S2MALARM1 s2MALARM1;
        public S2MALARM1 S2MALARM1
        {
            get
            {
                return s2MALARM1;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MALARM1 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MALARM2字段
        private S2MALARM2 s2MALARM2;
        public S2MALARM2 S2MALARM2
        {
            get
            {
                return s2MALARM2;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MALARM2 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MPACKINFO字段
        private S2MPACKINFO s2MPACKINFO;
        public S2MPACKINFO S2MPACKINFO
        {
            get
            {
                return s2MPACKINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MPACKINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBRANCHCURR字段
        private S2MBRANCHCURR s2MBRANCHCURR;
        public S2MBRANCHCURR S2MBRANCHCURR
        {
            get
            {
                return s2MBRANCHCURR;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBRANCHCURR = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MRELAYSTATUS字段
        private S2MRELAYSTATUS s2MRELAYSTATUS;
        public S2MRELAYSTATUS S2MRELAYSTATUS
        {
            get
            {
                return s2MRELAYSTATUS;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MRELAYSTATUS = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MPACKCURRLMT字段
        private S2MPACKCURRLMT s2MPACKCURRLMT;
        public S2MPACKCURRLMT S2MPACKCURRLMT
        {
            get
            {
                return s2MPACKCURRLMT;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MPACKCURRLMT = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MRUNSTATUSINFO字段
        private S2MRUNSTATUSINFO s2MRUNSTATUSINFO;
        public S2MRUNSTATUSINFO S2MRUNSTATUSINFO
        {
            get
            {
                return s2MRUNSTATUSINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MRUNSTATUSINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MSUMVOLT字段
        private S2MSUMVOLT s2MSUMVOLT;
        public S2MSUMVOLT S2MSUMVOLT
        {
            get
            {
                return s2MSUMVOLT;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MSUMVOLT = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MSUMTEMP字段
        private S2MSUMTEMP s2MSUMTEMP;
        public S2MSUMTEMP S2MSUMTEMP
        {
            get
            {
                return s2MSUMTEMP;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MSUMTEMP = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MCHRGACCUINFO字段
        private S2MCHRGACCUINFO s2MCHRGACCUINFO;
        public S2MCHRGACCUINFO S2MCHRGACCUINFO
        {
            get
            {
                return s2MCHRGACCUINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MCHRGACCUINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MDISCHRGACCUINFO字段
        private S2MDISCHRGACCUINFO s2MDISCHRGACCUINFO;
        public S2MDISCHRGACCUINFO S2MDISCHRGACCUINFO
        {
            get
            {
                return s2MDISCHRGACCUINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MDISCHRGACCUINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MRECHRGACCUINFO字段
        private S2MRECHRGACCUINFO s2MRECHRGACCUINFO;
        public S2MRECHRGACCUINFO S2MRECHRGACCUINFO
        {
            get
            {
                return s2MRECHRGACCUINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MRECHRGACCUINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MISOINFO字段
        private S2MISOINFO s2MISOINFO;
        public S2MISOINFO S2MISOINFO
        {
            get
            {
                return s2MISOINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MISOINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBRACHSUMVOLT1字段
        private S2MBRACHSUMVOLT1 s2MBRACHSUMVOLT1;
        public S2MBRACHSUMVOLT1 S2MBRACHSUMVOLT1
        {
            get
            {
                return s2MBRACHSUMVOLT1;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBRACHSUMVOLT1 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBRACHSUMVOLT2字段
        private S2MBRACHSUMVOLT2 s2MBRACHSUMVOLT2;
        public S2MBRACHSUMVOLT2 S2MBRACHSUMVOLT2
        {
            get
            {
                return s2MBRACHSUMVOLT2;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBRACHSUMVOLT2 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBRACHSUMVOTL3字段
        private S2MBRACHSUMVOTL3 s2MBRACHSUMVOTL3;
        public S2MBRACHSUMVOTL3 S2MBRACHSUMVOTL3
        {
            get
            {
                return s2MBRACHSUMVOTL3;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBRACHSUMVOTL3 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBRACHSUMTEMP1字段
        private S2MBRACHSUMTEMP1 s2MBRACHSUMTEMP1;
        public S2MBRACHSUMTEMP1 S2MBRACHSUMTEMP1
        {
            get
            {
                return s2MBRACHSUMTEMP1;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBRACHSUMTEMP1 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBRACHSUMTEMP2字段
        private S2MBRACHSUMTEMP2 s2MBRACHSUMTEMP2;
        public S2MBRACHSUMTEMP2 S2MBRACHSUMTEMP2
        {
            get
            {
                return s2MBRACHSUMTEMP2;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBRACHSUMTEMP2 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT1字段
        private S2MVOLT1 s2MVOLT1;
        public S2MVOLT1 S2MVOLT1
        {
            get
            {
                return s2MVOLT1;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT1 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT2字段
        private S2MVOLT2 s2MVOLT2;
        public S2MVOLT2 S2MVOLT2
        {
            get
            {
                return s2MVOLT2;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT2 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT3字段
        private S2MVOLT3 s2MVOLT3;
        public S2MVOLT3 S2MVOLT3
        {
            get
            {
                return s2MVOLT3;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT3 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT4字段
        private S2MVOLT4 s2MVOLT4;
        public S2MVOLT4 S2MVOLT4
        {
            get
            {
                return s2MVOLT4;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT4 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT5字段
        private S2MVOLT5 s2MVOLT5;
        public S2MVOLT5 S2MVOLT5
        {
            get
            {
                return s2MVOLT5;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT5 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT6字段
        private S2MVOLT6 s2MVOLT6;
        public S2MVOLT6 S2MVOLT6
        {
            get
            {
                return s2MVOLT6;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT6 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT7字段
        private S2MVOLT7 s2MVOLT7;
        public S2MVOLT7 S2MVOLT7
        {
            get
            {
                return s2MVOLT7;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT7 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT8字段
        private S2MVOLT8 s2MVOLT8;
        public S2MVOLT8 S2MVOLT8
        {
            get
            {
                return s2MVOLT8;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT8 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT9字段
        private S2MVOLT9 s2MVOLT9;
        public S2MVOLT9 S2MVOLT9
        {
            get
            {
                return s2MVOLT9;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT9 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT10字段
        private S2MVOLT10 s2MVOLT10;
        public S2MVOLT10 S2MVOLT10
        {
            get
            {
                return s2MVOLT10;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT10 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT11字段
        private S2MVOLT11 s2MVOLT11;
        public S2MVOLT11 S2MVOLT11
        {
            get
            {
                return s2MVOLT11;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT11 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT12字段
        private S2MVOLT12 s2MVOLT12;
        public S2MVOLT12 S2MVOLT12
        {
            get
            {
                return s2MVOLT12;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT12 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT13字段
        private S2MVOLT13 s2MVOLT13;
        public S2MVOLT13 S2MVOLT13
        {
            get
            {
                return s2MVOLT13;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT13 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT14字段
        private S2MVOLT14 s2MVOLT14;
        public S2MVOLT14 S2MVOLT14
        {
            get
            {
                return s2MVOLT14;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT14 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT15字段
        private S2MVOLT15 s2MVOLT15;
        public S2MVOLT15 S2MVOLT15
        {
            get
            {
                return s2MVOLT15;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT15 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT16字段
        private S2MVOLT16 s2MVOLT16;
        public S2MVOLT16 S2MVOLT16
        {
            get
            {
                return s2MVOLT16;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT16 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT17字段
        private S2MVOLT17 s2MVOLT17;
        public S2MVOLT17 S2MVOLT17
        {
            get
            {
                return s2MVOLT17;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT17 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT18字段
        private S2MVOLT18 s2MVOLT18;
        public S2MVOLT18 S2MVOLT18
        {
            get
            {
                return s2MVOLT18;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                   s2MVOLT18 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT19字段
        private S2MVOLT19 s2MVOLT19;
        public S2MVOLT19 S2MVOLT19
        {
            get
            {
                return s2MVOLT19;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT19 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT20字段
        private S2MVOLT20 s2MVOLT20;
        public S2MVOLT20 S2MVOLT20
        {
            get
            {
                return s2MVOLT20;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT20 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT21字段
        private S2MVOLT21 s2MVOLT21;
        public S2MVOLT21 S2MVOLT21
        {
            get
            {
                return s2MVOLT21;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT21 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT22字段
        private S2MVOLT22 s2MVOLT22;
        public S2MVOLT22 S2MVOLT22
        {
            get
            {
                return s2MVOLT22;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT22 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT23字段
        private S2MVOLT23 s2MVOLT23;
        public S2MVOLT23 S2MVOLT23
        {
            get
            {
                return s2MVOLT23;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT23 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT24字段
        private S2MVOLT24 s2MVOLT24;
        public S2MVOLT24 S2MVOLT24
        {
            get
            {
                return s2MVOLT24;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT24 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT25字段
        private S2MVOLT25 s2MVOLT25;
        public S2MVOLT25 S2MVOLT25
        {
            get
            {
                return s2MVOLT25;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT25 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT26字段
        private S2MVOLT26 s2MVOLT26;
        public S2MVOLT26 S2MVOLT26
        {
            get
            {
                return s2MVOLT26;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT26 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT27字段
        private S2MVOLT27 s2MVOLT27;
        public S2MVOLT27 S2MVOLT27
        {
            get
            {
                return s2MVOLT27;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT27 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT28字段
        private S2MVOLT28 s2MVOLT28;
        public S2MVOLT28 S2MVOLT28
        {
            get
            {
                return s2MVOLT28;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT28 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT29字段
        private S2MVOLT29 s2MVOLT29;
        public S2MVOLT29 S2MVOLT29
        {
            get
            {
                return s2MVOLT29;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT29 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MVOLT30字段
        private S2MVOLT30 s2MVOLT30;
        public S2MVOLT30 S2MVOLT30
        {
            get
            {
                return s2MVOLT30;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MVOLT30 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTEMP1字段
        private S2MTEMP1 s2MTEMP1;
        public S2MTEMP1 S2MTEMP1
        {
            get
            {
                return s2MTEMP1;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTEMP1 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTEMP2字段
        private S2MTEMP2 s2MTEMP2;
        public S2MTEMP2 S2MTEMP2
        {
            get
            {
                return s2MTEMP2;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTEMP2 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTEMP3字段
        private S2MTEMP3 s2MTEMP3;
        public S2MTEMP3 S2MTEMP3
        {
            get
            {
                return s2MTEMP3;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTEMP3 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTEMP4字段
        private S2MTEMP4 s2MTEMP4;
        public S2MTEMP4 S2MTEMP4
        {
            get
            {
                return s2MTEMP4;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTEMP4 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTEMP5字段
        private S2MTEMP5 s2MTEMP5;
        public S2MTEMP5 S2MTEMP5
        {
            get
            {
                return s2MTEMP5;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTEMP5 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTEMP6字段
        private S2MTEMP6 s2MTEMP6;
        public S2MTEMP6 S2MTEMP6
        {
            get
            {
                return s2MTEMP6;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTEMP6 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MCSCSUMVOLT字段
        private S2MCSCSUMVOLT s2MCSCSUMVOLT;
        public S2MCSCSUMVOLT S2MCSCSUMVOLT
        {
            get
            {
                return s2MCSCSUMVOLT;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MCSCSUMVOLT = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MCSCSUMTEMP字段
        private S2MCSCSUMTEMP s2MCSCSUMTEMP;
        public S2MCSCSUMTEMP S2MCSCSUMTEMP
        {
            get
            {
                return s2MCSCSUMTEMP;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MCSCSUMTEMP = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MTIMINGINFO字段
        private S2MTIMINGINFO s2MTIMINGINFO;
        public S2MTIMINGINFO S2MTIMINGINFO
        {
            get
            {
                return s2MTIMINGINFO;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MTIMINGINFO = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBATTENERGYINFO1字段
        private S2MBATTENERGYINFO1 s2MBATTENERGYINFO1;
        public S2MBATTENERGYINFO1 S2MBATTENERGYINFO1
        {
            get
            {
                return s2MBATTENERGYINFO1;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBATTENERGYINFO1 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBATTENERGYINFO2字段
        private S2MBATTENERGYINFO2 s2MBATTENERGYINFO2;
        public S2MBATTENERGYINFO2 S2MBATTENERGYINFO2
        {
            get
            {
                return s2MBATTENERGYINFO2;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBATTENERGYINFO2 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBATTENERGYINFO3字段
        private S2MBATTENERGYINFO3 s2MBATTENERGYINFO3;
        public S2MBATTENERGYINFO3 S2MBATTENERGYINFO3
        {
            get
            {
                return s2MBATTENERGYINFO3;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBATTENERGYINFO3 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBATTENERGYINFO4字段
        private S2MBATTENERGYINFO4 s2MBATTENERGYINFO4;
        public S2MBATTENERGYINFO4 S2MBATTENERGYINFO4
        {
            get
            {
                return s2MBATTENERGYINFO4;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBATTENERGYINFO4 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBATTENERGYINFO5字段
        private S2MBATTENERGYINFO5 s2MBATTENERGYINFO5;
        public S2MBATTENERGYINFO5 S2MBATTENERGYINFO5
        {
            get
            {
                return s2MBATTENERGYINFO5;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBATTENERGYINFO5 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MBATTENERGYINFO6字段
        private S2MBATTENERGYINFO6 s2MBATTENERGYINFO6;
        public S2MBATTENERGYINFO6 S2MBATTENERGYINFO6
        {
            get
            {
                return s2MBATTENERGYINFO6;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MBATTENERGYINFO6 = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

        #region 电池标准CAN信号 S2MSYSCODE字段
        private S2MSYSCODE s2MSYSCODE;
        public S2MSYSCODE S2MSYSCODE
        {
            get
            {
                return s2MSYSCODE;  // 返回一般不需要锁，.net可以保证操作的原子性
            }
            set
            {
                lock (lockObj)
                {
                    s2MSYSCODE = value;
                }
            }
        }
        #endregion 电池标准CAN信号1参数字段

 
    }
}