示例#1
0
 public override CommResultState ProcessReceived(byte[] data)
 {
     return(GRCommandMaker.CheckReceivedData(Station.Address,
                                             GRDef.DEVICE_TYPE,
                                             GRDef.FC_ANSWER,
                                             data));
 }
示例#2
0
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 public override byte[] MakeCommand()
 {
     return(GRCommandMaker.MakeCommand(this.Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_READ_SETTINGS,
                                       new byte[] { GRDef.MC_RE_PRESS }));
 }
示例#3
0
 public override byte[] MakeCommand()
 {
     return(GRCommandMaker.MakeCommand(Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_READ_SETTINGS,
                                       GetInnerDatas()));
 }
示例#4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public override CommResultState ProcessReceived(byte[] data)
        {
            CommResultState r = GRCommandMaker.CheckReceivedData(Station.Address,
                                                                 GRDef.DEVICE_TYPE, GRDef.FC_READ_SETTINGS,
                                                                 data);

            if (r == CommResultState.Correct)
            {
                byte[] inner = GRCommandMaker.GetReceivedInnerData(data);
                if (inner.Length < 10)
                {
                    return(CommResultState.LengthError);
                }

                if (inner[0] == GRDef.MC_RE_PRESS)
                {
//					byte mode = inner[1];
                    _mode       = (RePumpMode)inner[1];
                    _rePressSet = BitConverter.ToSingle(inner, 2);
                }
                else
                {
                    return(CommResultState.DataError);
                }
            }
            return(r);
        }
示例#5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public override CommResultState ProcessReceived(byte[] data)
        {
            CommResultState r = GRCommandMaker.CheckReceivedData(this.Station.Address,
                                                                 GRDef.DEVICE_TYPE,
                                                                 GRDef.FC_READ_SETTINGS,
                                                                 data);

            if (r == CommResultState.Correct)
            {
                byte[] ids = GRCommandMaker.GetReceivedInnerData(data);
                if (ids != null && ids.Length == 4)
                {
                    if (ids[0] == GRDef.MC_OPENDEGREE)
                    {
                        this._minod = ids[1];
                        this._maxod = ids[2];
                    }
                    else
                    {
                        return(CommResultState.DataError);
                    }
                }
            }
            return(r);
        }
示例#6
0
        public override CommResultState ProcessReceived(byte[] data)
        {
            CommResultState r = GRCommandMaker.CheckReceivedData(Station.Address,
                                                                 GRDef.DEVICE_TYPE,
                                                                 GRDef.FC_READ_SETTINGS,
                                                                 data);

            if (r == CommResultState.Correct)
            {
                byte[] innerDatas = GRCommandMaker.GetReceivedInnerData(data);
                System.Diagnostics.Debug.Assert(innerDatas != null &&
                                                innerDatas.Length == 13);

                if (innerDatas[0] == GRDef.MC_TEMPERATURE_ALARM)
                {
                    _oneGiveTempLoSetV = BitConverter.ToSingle(innerDatas, 0 * 4 + 1);
                    _twoGiveTempHiSetV = BitConverter.ToSingle(innerDatas, 1 * 4 + 1);
                    _wlLoSetV          = BitConverter.ToSingle(innerDatas, 2 * 4 + 1);
                }
                else
                {
                    return(CommResultState.DataError);
                }
            }
            return(r);
        }
示例#7
0
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 public override byte[] MakeCommand()
 {
     byte[] datas = new byte[] { GRDef.MC_OPENDEGREE };
     return(GRCommandMaker.MakeCommand(this.Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_READ_SETTINGS,
                                       datas));
 }
示例#8
0
 public override byte[] MakeCommand()
 {
     byte [] datas = new byte[] { GRDef.MC_TWOPRESS_CHA };
     return(GRCommandMaker.MakeCommand(Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_READ_SETTINGS,
                                       datas));
 }
示例#9
0
 public override byte[] MakeCommand()
 {
     byte[] bs = new byte[] { GRDef.MC_OUTSIDE_TEMPERATURE };
     return(GRCommandMaker.MakeCommand(this.Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_READ_SETTINGS,
                                       bs));
 }
示例#10
0
 public override byte[] MakeCommand()
 {
     byte[] ids = new byte[] { GRDef.MC_OPENDEGREE, _min, _max, 0 };
     return(GRCommandMaker.MakeCommand(this.Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_WRITE_SETTINGS,
                                       ids));
 }
示例#11
0
文件: GRPumpOP.cs 项目: wwkkww1983/bt
 public override byte[] MakeCommand()
 {
     return(GRCommandMaker.MakeCommand(Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       //GRDef.FC_REPUMP_START,
                                       GetFC(),
                                       null));
 }
 public override byte[] MakeCommand()
 {
     byte[] bs = new byte[1];
     bs[0] = (byte)_workMode;
     return(GRCommandMaker.MakeCommand(Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_SET_OUTSIDE_MODE,
                                       bs));
 }
示例#13
0
 /// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 public override byte[] MakeCommand()
 {
     //1.上位下传温度曲线
     //上位下传:21 58 44 00 A0 3C 10 + 数据 +  CRC(高字节+低字节)
     //返回内容:21 58 44 00 A0 0A 00 CRC16(接收正确)
     byte[] bs = this._ttl.GetBytes();
     return(GRCommandMaker.MakeCommand(Station.Address,
                                       GRDef.DEVICE_TYPE,
                                       GRDef.FC_WRITE_TIME_TEMPERATURE_LINE,
                                       bs));
 }
示例#14
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public override byte[] MakeCommand()
        {
            byte[] bs = new byte[10];
            bs[0] = GRDef.MC_RE_PRESS;
            bs[1] = (byte)this.RepumpMode;
            byte[] temp = BitConverter.GetBytes(this._perssset);
            Array.Copy(temp, 0, bs, 2, 4);

            return(GRCommandMaker.MakeCommand(Station.Address,
                                              GRDef.DEVICE_TYPE,
                                              GRDef.FC_WRITE_SETTINGS,
                                              bs));
        }
示例#15
0
        /// <summary>
        /// return a grRealData or null
        /// </summary>
        /// <returns></returns>
        public override object ToValue()
        {
            byte[] data = _bytes;

            if (data == null || data.Length == 0)
            {
                _commResultState = CommResultState.NullData;
                return(null);
            }

            if (data.Length != 113)
            {
                _commResultState = CommResultState.LengthError;
                return(null);
            }

            // dev type and fc
            if (data[4] != 0xA0 || data[5] != 0x1E)
            {
                _commResultState = CommResultState.DataError;
                return(null);
            }

            byte cachi, caclo;

            CRC16.CalculateCRC(data, 113 - 2, out cachi, out caclo);

            byte hi = data[113 - 1];
            byte lo = data[113 - 2];

            if (cachi != hi || caclo != lo)
            {
                _commResultState = CommResultState.CheckError;
                return(null);
            }

            int address = -1;

            address = data[GRDef.ADDRESS_POS];

            byte[]     innerData = GRCommandMaker.GetReceivedInnerData(data);
            GRRealData realData  = GRRealData.Parse(innerData, address);

            if (realData != null)
            {
                _commResultState = CommResultState.Correct;
            }
            _value = realData;
            return(realData);
        }
示例#16
0
        public override byte[] MakeCommand()
        {
            //byte[] bs = new byte[]{};
            byte[] kbs = BitConverter.GetBytes(_k);
            byte[] bbs = BitConverter.GetBytes(_b);

            Array.Copy(kbs, 0, _readids, 11, 4);
            Array.Copy(bbs, 0, _readids, 15, 4);

            return(GRCommandMaker.MakeCommand(this.Station.Address,
                                              GRDef.DEVICE_TYPE,
                                              GRDef.FC_WRITE_SETTINGS,
                                              this._readids));
        }
示例#17
0
        public override byte[] MakeCommand()
        {
            if (!_isSpecify)
            {
                GRStation grSt = (GRStation)Station;
                if (grSt.OSTWorkMode == OutSideTempWorkMode.SetByComputer)
                {
                    _outSideTemp = Singles.S.OutSideTemperature;
                }
            }

            byte[] datas = BitConverter.GetBytes(_outSideTemp);
            return(GRCommandMaker.MakeCommand(Station.Address,
                                              GRDef.DEVICE_TYPE,         //0xA0,
                                              GRDef.FC_SET_OUTSIDE_TEMP, //41,
                                              datas));
        }
示例#18
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public override CommResultState ProcessReceived(byte[] data)
        {
            if (data == null || data.Length == 0)
            {
                return(CommResultState.NullData);
            }
            if (data.Length != 9 + 0x0A)
            {
                return(CommResultState.LengthError);
            }

            if (data[4] != 0xA0 || data[5] != 0x14)
            {
                return(CommResultState.DataError);
            }

            if (data[6] != 0x0A)
            {
                return(CommResultState.DataError);
            }

            byte cachi, caclo;

            CRC16.CalculateCRC(data, data.Length - 2, out cachi, out caclo);

            byte hi = data[data.Length - 1];
            byte lo = data[data.Length - 2];

            if (cachi != hi || caclo != lo)
            {
                return(CommResultState.CheckError);
            }

            byte[] innerData = GRCommandMaker.GetReceivedInnerData(data);

            if (innerData[0] != GRDef.MC_GIVETEMP_MODE)
            {
                return(CommResultState.DataError);
            }

            _giveTempMode  = GetGiveTempMode(innerData[1]);
            _giveTempValue = BitConverter.ToSingle(innerData, 2);

            return(CommResultState.Correct);
        }
示例#19
0
        //
        static public CommResultState ProcessAutoReport(byte[] datas, out GRAlarmData alarmData)
        {
            //if ( datas == null )
            //    return CommResultState.NullData;
            //if ( datas.Length != 11 )
            //    return CommResultState.LengthError;
            CommResultState result = GRCommandMaker.CheckReceivedData(0xA0, 0x20, datas);

            if (result != CommResultState.Correct)
            {
                alarmData = null;
            }
            else
            {
                int addr = datas[GRDef.ADDRESS_POS];
                alarmData = Parse(GRCommandMaker.GetReceivedInnerData(datas), addr);
            }
            return(result);
        }
示例#20
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public override CommResultState ProcessReceived(byte[] data)
        {
            CommResultState r = GRCommandMaker.CheckReceivedData(Station.Address,
                                                                 GRDef.DEVICE_TYPE, GRDef.FC_READ_SETTINGS, data);

            if (r == CommResultState.Correct)
            {
                byte[] innerDatas = GRCommandMaker.GetReceivedInnerData(data);

                byte mc = innerDatas[0];
                if (mc == GRDef.MC_TEMPERATURE_LINE)
                {
                    _tl = TemperatureLine.Parse(innerDatas, 1);
                    this._timetempline = TimeTempLine.Parse(innerDatas, 1 + 16);
                }
                else
                {
                    return(CommResultState.DataError);
                }
            }
            return(r);
        }
示例#21
0
        public override CommResultState ProcessReceived(byte[] data)
        {
            CommResultState r = GRCommandMaker.CheckReceivedData(this.Station.Address,
                                                                 GRDef.DEVICE_TYPE,
                                                                 GRDef.FC_READ_SETTINGS,
                                                                 data);

            if (r == CommResultState.Correct)
            {
                byte[] ids = GRCommandMaker.GetReceivedInnerData(data);
                if (ids != null && ids.Length == 19)
                {
                    _b   = BitConverter.ToSingle(ids, 15);
                    _k   = BitConverter.ToSingle(ids, 11);
                    _ids = ids;
                }
                else
                {
                    return(CommResultState.LengthError);
                }
            }
            return(r);
        }
示例#22
0
        public override CommResultState ProcessReceived(byte[] data)
        {
            CommResultState r = GRCommandMaker.CheckReceivedData(Station.Address,
                                                                 GRDef.DEVICE_TYPE,
                                                                 GRDef.FC_READ_SETTINGS,
                                                                 data);

            if (r == CommResultState.Correct)
            {
                byte[] innerDatas = GRCommandMaker.GetReceivedInnerData(data);

//                System.Diagnostics.Debug.Assert ( innerDatas != null &&
//                    innerDatas.Length == 10 );
                if (innerDatas.Length < 10)
                {
                    return(CommResultState.LengthError);
                }

                if (innerDatas [0] == GRDef.MC_TWOPRESS_CHA)
                {
                    _cycPumpCtrlMode = (CyclePumpMode)innerDatas[1];
                    //                    byte[] pressChaSetValue = new byte[ 4 ];
                    //                    byte[] backPressSetValue = new byte[ 4 ];
                    //                    Array.Copy( innerDatas,2, pressChaSetValue, 0, 4 );
                    //                    Array.Copy( innerDatas,6, backPressSetValue, 0, 4 );

                    _pressChaSetValue  = BitConverter.ToSingle(innerDatas, 2);
                    _backPressSetValue = BitConverter.ToSingle(innerDatas, 6);
                }
                else
                {
                    return(CommResultState.DataError);
                }
            }

            return(r);
        }