public override CommResultState ProcessReceived(byte[] data)
{
CommResultState state = XGCommandMaker.CheckReceivedData(this.Station.Address,
XGDefinition.DEVICE_TYPE,
XGDefinition.FC_READ_RECORD,
data);
// 正确时处理记录数据，错误时保留上次读取的数据不变。
//
if (state == CommResultState.Correct)
{
byte[] innerDatas = XGCommandMaker.GetReceivedInnerData(data);
int innerDataLen = innerDatas.Length;
//
if (innerDataLen == XGDefinition.RECODE_DATA_LENGTH)
{
// analyse recode data
//
_record = Record.Analyze(innerDatas);
_recordTotalCount = -1;
}
else if (innerDataLen == 1) // recode index error
{
_recordTotalCount = innerDatas[0];
}
else
{
throw new Exception("Read recode inner data error.");
}
}
return(state);
}
/// <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);
}
/// <summary>
///
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
private string GetCommResultTextDetail(CommResultState state)
{
string r = string.Empty;
switch (state)
{
case CommResultState.CheckError:
r = "校验错";
break;
case CommResultState.Correct:
r = "成功";
break;
case CommResultState.DataError:
r = "接收数据错误";
break;
case CommResultState.LengthError:
r = "接收数据长度错误";
break;
case CommResultState.NullData:
r = "未接收到数据";
break;
default:
r = "未知错误";
break;
}
return(r);
}
/// <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);
}
/// <summary>
/// 处理接收到的数据
/// </summary>
/// <param name="received"></param>
public void ProcessReceived(byte[] received)
{
m_LastReceived = received;
// 2006.12.15 Added, save last received byte[] data.
//
m_LastReceivedDateTime = DateTime.Now;
// before proecee
//
if (m_BeforeProcessReceivedDelegate != null)
{
m_BeforeProcessReceivedDelegate(this, EventArgs.Empty);
}
// process and save last execute result.
//
// 2006.12.13
//
//m_LastCommResultState = OnProcessReceived ( Station, Parameters , received );
m_LastCommResultState = OnProcessReceived(received);
// after process
//
if (m_AfterProcessReceivedDelegate != null)
{
m_AfterProcessReceivedDelegate(this, EventArgs.Empty);
}
}
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);
}
public override CommResultState ProcessReceived(byte[] data)
{
CommResultState r = GRCommandMaker.CheckReceivedData(this.Station.Address,
GRDef.DEVICE_TYPE,
GRDef.FC_ANSWER,
data);
return(r);
}
public override CommResultState ProcessReceived(byte[] data)
{
CommResultState r = XGCommandMaker.CheckReceivedData(Station.Address,
XGDefinition.DEVICE_TYPE,
XGDefinition.FC_QUERY_ADDRESS,
data);
System.Windows.Forms.MessageBox.Show("re" + data.Length + r.ToString());
return(r);
}
public override CommResultState ProcessReceived(byte[] data)
{
CommResultState state = XGCommandMaker.CheckReceivedData(Station.Address,
XGDefinition.DEVICE_TYPE,
XGDefinition.FC_READ_TOTALCOUNT,
data);
if (state == CommResultState.Correct)
{
byte[] innerDatas = XGCommandMaker.GetReceivedInnerData(data);
_totalCount = innerDatas[0];
}
return(state);
}
/// <summary>
/// reutrn xgdata or null
/// </summary>
/// <returns></returns>
public override object ToValue()
{
byte[] data = _bytes;
CommResultState state = XGCommandMaker.CheckReceivedData(// this.Station.Address,
XGDefinition.DEVICE_TYPE,
XGDefinition.FC_READ_RECORD,
data);
_commResultState = state;
// 正确时处理记录数据，错误时保留上次读取的数据不变。
//
if (state == CommResultState.Correct)
{
int address = data[XGDefinition.ADDRESS_POS];
byte[] innerDatas = XGCommandMaker.GetReceivedInnerData(data);
int innerDataLen = innerDatas.Length;
//
if (innerDataLen == XGDefinition.RECODE_DATA_LENGTH)
{
// analyse recode data
//
Record record = Record.Analyze(innerDatas);
if (record == null)
{
return(null);
}
XGData xgdata = new XGData(record.CardSN, address, record.DateTime, false);
_value = xgdata;
return(xgdata);
}
else if (innerDataLen == 1) // recode index error
{
//_recordTotalCount = innerDatas[0];
return(null);
}
else
{
//throw new Exception("Read recode inner data error.");
return(null);
}
}
else
{
return(null);
}
}
/// <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);
}
private string GetCommResultText(CommResultState state)
{
string r = string.Empty;
if (state == CommResultState.Correct)
{
return(" 成功");
}
else
{
r = " 失败(";
}
switch (state)
{
case CommResultState.CheckError:
r += "校验错";
break;
// case CommResultState.Correct:
// r = "成功";
// break;
case CommResultState.DataError:
r += "接收数据错误";
break;
case CommResultState.LengthError:
r += "接收数据长度错误";
break;
case CommResultState.NullData:
r += "未接收到数据";
break;
default:
r += "未知错误";
break;
}
r += ")";
return(r);
}
//private string getlogstring( int commport, task task )
private string GetLogString(string remoteIP, Task task)
{
CommCmdBase cmd = task.CommCmd;
CommResultState commResultState = task.LastCommResultState;
string sLastReceive = string.Empty;
if (task.LastReceived != null)
{
sLastReceive = CT.BytesToString(task.LastReceived);
}
string s = string.Format("Send\t\t: {0}, {1}\r\nReceived\t: {2}, {3}\r\nCommResult\t: {4}\r\nCmdType\t\t: {5}\r\nRemoteIP\t: {6}\r\n",
task.LastSendDateTime, CT.BytesToString(task.LastSendDatas),
//task.LastReceivedDateTime, CT.BytesToString( task.LastReceived),
task.LastReceivedDateTime, sLastReceive,
commResultState.ToString(), cmd.GetType().Name, remoteIP);
return(s);
}
//
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);
}
public void t1()
{
GRReadGiveModeCommand cmd = new GRReadGiveModeCommand(grst);
byte[] bscmd = cmd.MakeCommand();
Assert.IsNotNull(bscmd);
Assert.AreEqual(10, bscmd.Length);
string s = "21 58 44 00 A0 14 0A 47 01 00 00 00 00 06 07 08 09 1e bb";
byte[] bsrece = new byte[] {
};
bsrece = Utilities.CT.StringToBytes(s, null, StringFormat.Hex);
CommResultState r = cmd.ProcessReceived(bsrece);
Assert.AreEqual(CommResultState.Correct, r);
Assert.AreEqual(GiveTempMode.TempLine, cmd.GiveTempMode);
Assert.AreEqual(0, cmd.GiveTempValue);
}
public override CommResultState ProcessReceived(byte[] data)
{
CommResultState state = XGCommandMaker.CheckReceivedData(
Station.Address,
XGDefinition.DEVICE_TYPE,
XGDefinition.FC_READ_DATE,
data);
if (state == CommResultState.Correct)
{
byte[] innerDatas = XGCommandMaker.GetReceivedInnerData(data);
_day = BCDConvert.BCDToDec(innerDatas[0]);
_month = BCDConvert.BCDToDec(innerDatas[1]);
_year = BCDConvert.BCDToDec(innerDatas[2]);
}
else
{
SetInvalidValue();
}
return(state);
}
/// <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);
}
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);
}
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);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void Process(object sender, EventArgs e)
{
ArgumentChecker.CheckNotNull(sender);
TaskScheduler sch = (TaskScheduler)sender;
Task task = sch.ActiveTask;
ArgumentChecker.CheckNotNull(task);
CommCmdBase cmd = task.CommCmd;
CommResultState commResultState = task.LastCommResultState;
if (commResultState != CommResultState.Correct)
{
if (XGConfig.Default.LogCommFail)
{
string s = string.Format("Send\t\t: {0}, {1}\r\nReceived\t: {2}, {3}\r\nCommResult\t: {4}\r\nCmdType\t\t: {5}\r\n",
task.LastSendDateTime, CT.BytesToString(task.LastSendDatas),
task.LastReceivedDateTime, CT.BytesToString(task.LastReceived),
commResultState.ToString(), cmd.GetType().Name);
FileLog.CommFail.Add(s);
}
return;
}
if (cmd is ReadRecordCommand)
{
ReadRecordCommand readRecordCmd = cmd as ReadRecordCommand;
ProcessReadRecordCmd(readRecordCmd);
}
if (cmd is ReadTotalCountCommand)
{
ReadTotalCountCommand readCountCmd = cmd as ReadTotalCountCommand;
ProcessReadTotalCountCmd(readCountCmd, task);
}
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
// private void Process( string remoteIP, Task task )
private void Process(Task task)
{
ArgumentChecker.CheckNotNull(task);
string remoteIP = task.CommCmd.Station.DestinationIP;
CommCmdBase cmd = task.CommCmd;
Station st = cmd.Station;
CommResultState commResultState = task.LastCommResultState;
string s = null;
if (XGConfig.Default.LogCommIO)
{
if (s == null)
{
//s = GetLogString( commPort, task );
s = GetLogString(remoteIP, task);
}
FileLog.CommIO.Add(s);
if (XGConfig.Default.ShowLogForm)
{
frmLogs.Default.AddLog(s);
}
}
// log fail comm
// 所有通讯失败情况在此处理
//
if (commResultState != CommResultState.Correct)
{
if (XGConfig.Default.LogCommFail)
{
if (s == null)
{
s = GetLogString(remoteIP, task);
}
if (XGConfig.Default.LogCommFail)
{
FileLog.CommFail.Add(s);
}
if (XGConfig.Default.ShowLogForm)
{
//frmLogs.FailForm.AddLog( s );
frmLogs.Default.AddLogCommFail(s);
}
}
ProcessFreeData(task.CommCmd.Station.DestinationIP, task.LastReceived); //, task);
return;
}
// 以下只是处理通讯成功的情况
//
// 4. XG real total count command
//
if (cmd is ReadTotalCountCommand)
{
ReadTotalCountCommand readCountCmd = cmd as ReadTotalCountCommand;
ProcessReadTotalCountCmd(readCountCmd, task);
}
// 5. XG real record
//
if (cmd is ReadRecordCommand)
{
ReadRecordCommand readRecordCmd = cmd as ReadRecordCommand;
ProcessReadRecordCmd(readRecordCmd);
}
// 6. XG clear record command
//
// 读取供热控制器实时数据
// 1. GR real data command
//
if (cmd is GRRealDataCommand)
{
GRRealDataCommand realDataCmd = ( GRRealDataCommand )cmd;
//ProcessGRRealDataCmd( commPort, realDataCmd );
ProcessGRRealDataCmd(remoteIP, realDataCmd);
}
// 2. GR set out side temperature command
//
if (cmd is GRSetOutSideTempCommand)
{
GRSetOutSideTempCommand c = (GRSetOutSideTempCommand)cmd;
ProcessGRSetOutSideTempCmd(c);
}
// 3. GR remote set control params
//
}
/// <summary>
///
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
private string GetCommResultText(CommResultState state)
{
return(state == CommResultState.Correct ? "成功" : "失败");
}
internal void _set_comm_result(CommResultState st)
{
m_LastCommResultState = st;
}
