/// <summary>
/// HDLC层接收数据
/// </summary>
/// <param name="b">字节数据</param>
private void InputWrite(byte b)
{
try
{
if (b == HDLC_ESCAPE)
{
m_bInputEscaping = true;
}
else
{
if (m_bInputEscaping == true)
{
// Kous: 注意一下转化时候按思路执行的
b = (byte)(b ^ HDLC_ESCAPE_MASK);
m_bInputEscaping = false;
}
// add byte to input buffer
m_u8aInputBuf[m_u8InputBufFill] = b;
m_u8InputBufFill++;
// iterate through CRC calculator
m_u16InputCrc = FCS.Fcs16CalcByte(m_u16InputCrc, b);
}
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eHdlc, "InputBuf(" + m_u8InputBufFill + ") " + ex.ToString());
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("EventPingResponse.Unserialize take invalid parameter");
}
if (stream.Length < (offset + Len))
{
throw new Exception("EventPingResponse.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
u32CallbackId = DataTypeConverter.MeshByteArrToUInt32(stream, offset + CBID_OFFSET);
Array.Copy(stream, offset + MACADDR_OFFSET, Mac.u8aData, 0, tMAC.LEN);
u32Delay = DataTypeConverter.MeshByteArrToUInt32(stream, offset + DELAY_OFFSET);
u16Voltage = DataTypeConverter.MeshByteArrToUInt16(stream, offset + VOLTAGE_OFFSET);
u8Temperature = stream[offset + TEMP_OFFSET];
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
/// <summary>
/// 打开CLI通信设备
/// </summary>
public void OpenCli()
{
if (cfgbCliExist)
{
try
{
m_CliDevice.PortName = System.Configuration.ConfigurationManager.AppSettings["CliPortName"].ToString();
m_CliDevice.BaudRate = int.Parse(System.Configuration.ConfigurationManager.AppSettings["CliBaudRate"].ToString());
m_CliDevice.Parity = Parity.None;
m_CliDevice.StopBits = StopBits.One;
m_CliDevice.DataBits = 8;
m_CliDevice.Handshake = Handshake.None;
// 数据接收方法注册
m_CliDevice.DataReceived += new SerialDataReceivedEventHandler(cli_DataReceived);
m_CliDevice.Open();
Thread.Sleep(10);
MoniterCli();
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("NotifDeviceHR.Unserialize take invalid parameter");
}
if (stream.Length < (offset + Len))
{
throw new Exception("NotifDeviceHR.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
u32Charge = DataTypeConverter.MeshByteArrToUInt32(stream, offset + CHARGE_OFFSET);
u8QueueOcc = stream[offset + QUEUEOCC_OFFSET];
u8Temperature = (sbyte)stream[offset + TMP_OFFSET];
u16BatteryVoltage = DataTypeConverter.MeshByteArrToUInt16(stream, offset + BAT_VOL_OFFSET);
u16NumTxOk = DataTypeConverter.MeshByteArrToUInt16(stream, offset + NUMTXOK_OFFSET);
u16NumTxFail = DataTypeConverter.MeshByteArrToUInt16(stream, offset + NUMTXFAIL_OFFSET);
u16NumRxOk = DataTypeConverter.MeshByteArrToUInt16(stream, offset + NUMRXOK_OFFSET);
u16NumRxLost = DataTypeConverter.MeshByteArrToUInt16(stream, offset + NUMRXLOST_OFFSET);
u8NumMacDropped = stream[offset + NUMMACDROP_OFFSET];
u8NumTxBad = stream[offset + NUMTXBAD_OFFSET];
u8BadLinkFrameId = stream[offset + BADLINKFRMID_OFFSET];
u32BadLinkSlot = DataTypeConverter.MeshByteArrToUInt32(stream, offset + BADLINKSLOT_OFFSET);
u8BadLinkOffset = stream[offset + BADLINKOFFS_OFFSET];
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("NotifDiscoveredNeighborsHR.Unserialize take invalid parameter");
}
if (stream.Length < (offset + MinLen))
{
throw new Exception("NotifDiscoveredNeighborsHR.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
u8NumJoinParents = stream[offset + NUMJOINPARENTS_OFFSET];
u8NumItems = stream[offset + NUMITEMS_OFFSET];
if (u8NumItems > 0)
{
neighborHRData = new tDiscoveredNeighborHRData[u8NumItems];
for (int i = 0; i < u8NumItems; i++)
{
neighborHRData[i] = new tDiscoveredNeighborHRData();
neighborHRData[i].Unserialize(stream, offset + NEIGHBORDATA_OFFSET + i * tDiscoveredNeighborHRData.Len);
}
}
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("NotifIpData.Unserialize take invalid parameter");
}
if (stream.Length < (offset + MinLen))
{
throw new Exception("NotifIpData.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
tUTCTime.u64Seconds = DataTypeConverter.MeshByteArrToUInt64(stream, offset + UTCSECS_OFFSET);
tUTCTime.u32Microseconds = DataTypeConverter.MeshByteArrToUInt32(stream, offset + UTCUSECS_OFFSET);
Array.Copy(stream, offset + MAC_OFFSET, Mac.u8aData, 0, tMAC.LEN);
// 提取通知数据
u8DataLen = (byte)(stream.Length - MinLen);
if (u8DataLen > 0)
{
u8aData = new byte[u8DataLen];
Array.Copy(stream, offset + DATA_OFFSET, u8aData, 0, u8DataLen);
}
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("NotifLog.Unserialize take invalid parameter");
}
if (stream.Length < (offset + MinLen))
{
throw new Exception("NotifLog.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
// 提取MAC地址
Array.Copy(stream, offset + MAC_ADRR_OFFSET, Mac.u8aData, 0, tMAC.LEN);
// 提取日志信息
u8LogMsgLen = (byte)(stream.Length - MinLen);
if (u8LogMsgLen > 0)
{
u8aLogMsg = new byte[u8LogMsgLen];
Array.Copy(stream, offset + LOG_OFFSET, u8aLogMsg, 0, u8LogMsgLen);
}
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
/// <summary>
/// 分发响应
/// </summary>
/// <param name="cmdId">响应报文命令ID</param>
/// <param name="payload">响应负载</param>
/// <param name="length">响应负载长度</param>
private void dispatchResponse(enCmd cmdId, byte[] payload, byte length)
{
eRC rc = (eRC)payload[0];
m_u8RxDataLen = (byte)(length - 1);
Array.Copy(payload, 1, m_u8aRxData, 0, m_u8RxDataLen);
// 检查接收到的命令id是否与请求的id相同
if (cmdId == m_ReqCmdId)
{
if (m_evReplyArrived != null)
{
// call the callback
m_evReplyArrived(cmdId, rc, m_u8aRxData, m_u8RxDataLen);
// reset
m_ReqCmdId = enCmd.CMDID_END;
// Kous: 注销事件处理函数的方式可能存在问题
m_evReplyArrived = null;
// Kous: 清空接收数据缓存
Array.Clear(m_u8aRxData, 0, m_u8RxDataLen);
m_u8RxDataLen = 0;
}
else
{
CommStackLog.RecordErr(enLogLayer.eSerial, "m_evReplyArrived=null");
}
}
else
{
CommStackLog.RecordErr(enLogLayer.eSerial, "cmdId=" + cmdId.ToString() + " m_ReqCmdId=" + m_ReqCmdId.ToString());
}
}
/// <summary>
/// 打开API通信设备
/// </summary>
public void OpenApi()
{
try
{
m_ApiDevice.PortName = System.Configuration.ConfigurationManager.AppSettings["ApiPortName"].ToString();
m_ApiDevice.BaudRate = 115200;
m_ApiDevice.Parity = Parity.None;
m_ApiDevice.StopBits = StopBits.One;
m_ApiDevice.DataBits = 8;
m_ApiDevice.Handshake = Handshake.None;
m_ApiDevice.Open();
Dtr(false);
Rts(true);
Dtr(true);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("EventNetworkTime.Unserialize take invalid parameter");
}
if (stream.Length < (offset + Len))
{
throw new Exception("EventNetworkTime.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
u32Uptime = DataTypeConverter.MeshByteArrToUInt32(stream, offset + UPTIME_OFFSET);
tUTCTime.u64Seconds = DataTypeConverter.MeshByteArrToUInt64(stream, offset + UTCSECS_OFFSET);
tUTCTime.u32Microseconds = DataTypeConverter.MeshByteArrToUInt32(stream, offset + UTCUSECS_OFFSET);
Array.Copy(stream, offset + ASN_OFFSET, tAsn.u8aData, 0, tASN.LEN);
u16AsnOffset = DataTypeConverter.MeshByteArrToUInt16(stream, offset + ASN_OFF_OFFSET);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
/// <summary>
/// 进行WS固件升级前的“终曲”工作
/// </summary>
public bool PostludeUpdate()
{
m_asigSetNwCfg.Reset();
m_asigResetSys.Reset();
m_bSetNwCfgTimeout = false;
m_bResetSysTimeout = false;
CommStackLog.RecordInf(enLogLayer.eAdapter, "PostludeUpdate");
/*
* if (!dismuteWsUpstream())
* {
* CommStackLog.RecordErr(enLogLayer.eAdapter, "allowUpstream failed");
* return false;
* }*/
// 关闭双向主干网模式
SetBackboneMode(enBBMode.Off, 1);
m_asigSetNwCfg.WaitOne();
// 关闭主干网超时
if (m_bSetNwCfgTimeout)
{
m_bSetNwCfgTimeout = false;
CommStackLog.RecordErr(enLogLayer.eAdapter, "SetBackboneMode failed");
return(false);
}
// 重启网络，以使设置生效
ResetSystem(true);
m_asigResetSys.WaitOne();
// 重启网络超时
if (m_bResetSysTimeout)
{
m_bResetSysTimeout = false;
CommStackLog.RecordErr(enLogLayer.eAdapter, "ResetSystem failed");
return(false);
}
lock (m_dicOnLineWs)
{
for (int i = 0; i < m_dicOnLineWs.Count; i++)
{
var item = m_dicOnLineWs.ElementAt(i);
if (item.Value)
{
m_dicOnLineWs[item.Key] = false;
}
}
}
m_bUpdating = false;
// 启动心跳
startHeartbeat();
return(true);
}
public void Initialize()
{
if (m_Ser != null)
{
m_Ser.Initialize();
}
else
{
CommStackLog.RecordErr(enLogLayer.eMesh, "Serial is not bound to MESH");
}
}
/// <summary>
/// 建立新的会话，直到会话建立返回
/// </summary>
public bool Open()
{
m_sigConnected.Reset();
m_Ser.InitiateConnect();
if (!m_sigConnected.WaitOne(NEW_SESSION_TIMEOUT))
{
CommStackLog.RecordErr(enLogLayer.eSession, "Open session timeout(" + NEW_SESSION_TIMEOUT + "ms)");
return(false);
}
return(true);
}
public void Reset()
{
try
{
m_ApiDevice.DiscardInBuffer();
m_ApiDevice.DiscardOutBuffer();
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eDevice, ex.ToString());
}
}
/// <summary>
/// MeshAdapter层初始化函数
/// </summary>
public void Initialize()
{
m_Mesh.Initialize();
m_Session.Initialize();
m_dicOnLineWs.Clear();
ReqBuffer.Reset();
if (!preludeSystem(true))
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "PreludeSystem failed in MeshAdapter.Initialize()!");
throw new Exception("PreludeSystem failed in MeshAdapter.Initialize()!");
}
}
/// <summary>
/// 刷新输出缓冲区
/// </summary>
public void FlushTx()
{
try
{
m_ApiDevice.DiscardOutBuffer();
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
}
/// <summary>
/// 软件重启Manager
/// </summary>
public void ResetManager()
{
if (cfgbCliExist)
{
if (m_CliDevice.IsOpen)
{
m_CliDevice.WriteLine("reset system");
}
else
{
CommStackLog.RecordErr(enLogLayer.eDevice, "WriteCliCom not open");
}
}
}
/// 流控之Rts，目前只支持硬件流控
/// </summary>
/// <param name="enable">设置Rts状态</param>
public void Rts(bool enable)
{
try
{
m_ApiDevice.RtsEnable = enable;
//CommStackLog.RecordInf(enLogLayer.eDevice, "Rts " + ((enable) ? "true" : "false"));
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
}
/// <summary>
/// HDLC注册给底层数据收发外设(UART)的字节接受回调函数
/// </summary>
/// <param name="rxByte">接受的新字节数据</param>
private void Rx1Byte(byte rxByte)
{
// lock the module
// start of frame
if (m_bBusyRevHdlcFrame == false && m_u8LastRxByte == HDLC_FLAG && rxByte != HDLC_FLAG)
{
// I'm now receiving
m_bBusyRevHdlcFrame = true;
// create the HDLC frame
InputOpen();
// add the byte just received
InputWrite(rxByte);
}
// middle of frame
else if (m_bBusyRevHdlcFrame == true && rxByte != HDLC_FLAG)
{
// add the byte just received
InputWrite(rxByte);
if (m_u8InputBufFill + 1 > HDLC_MAX_BUFFER_SIZE)
{
m_u8InputBufFill = 0;
m_bBusyRevHdlcFrame = false;
// input buffer overflow, drop the incoming fram
CommStackLog.RecordErr(enLogLayer.eHdlc, "Rx overflow frame: " + CommStackLog.ToHexString(m_u8aInputBuf, m_u8InputBufFill));
}
}
// end of frame
else if (m_bBusyRevHdlcFrame == true && rxByte == HDLC_FLAG)
{
// finalize the HDLC frame
InputClose();
if (m_u8InputBufFill >= 4)
{
// hand over frame to upper layer
if (m_evHDLCFrameArrived != null)
{
m_evHDLCFrameArrived(m_u8aInputBuf, m_u8InputBufFill);
m_u8InputBufFill = 0;
}
}
m_bBusyRevHdlcFrame = false;
}
m_u8LastRxByte = rxByte;
}
/// <summary>
/// 发送字节数组
/// </summary>
/// <param name="arr">发送数据</param>
/// <param name="len">发送数据长度</param>
public void SendArr(byte[] arr, int len)
{
if (m_ApiDevice.IsOpen)
{
try
{
if (cfgAPIMode == enAPIMode.Mod2)
{
Dtr(true);//Dtr(true) = 低电平
while (!Cts())
{
CommStackLog.RecordInf(enLogLayer.eDevice, "Cts is invalid!");
Thread.Sleep(2);
continue;
}
m_ApiDevice.Write(arr, 0, len);
while (m_ApiDevice.BytesToWrite != 0)
{
CommStackLog.RecordInf(enLogLayer.eDevice, "BytesToWrite = " + m_ApiDevice.BytesToWrite.ToString());
Thread.Sleep(1);
continue;
}
Thread.Sleep(5);
Dtr(false);
}
else
{
m_ApiDevice.Write(arr, 0, len);
}
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
}
else
{
CommStackLog.RecordErr(enLogLayer.eDevice, "SendArr not open");
}
}
/// <summary>
/// 进行WS固件升级
/// </summary>
/// <param name="macList">请求升级的WS列表</param>
/// <param name="firmware">请求升级的固件信息</param>
/// <returns>请求成功与否</returns>
public bool Update(List <tMAC> macList, tFirmware firmware)
{
if (macList == null ||
macList.Count == 0 ||
firmware == null ||
firmware.DicFwBlockDat == null ||
firmware.DicFwBlockDat.Count == 0)
{
return(false);
}
try
{
// 复制一份升级mote列表
lstUpdWs = new List <tMAC>();
foreach (tMAC mote in macList)
{
tMAC addMote = new tMAC();
addMote.Assign(mote);
lstUpdWs.Add(addMote);
}
// 复制一份固件信息
fw = new tFirmware(firmware);
// 构造升级线程
Thread threadUpdateWorker = new Thread(UpdateHandler);
threadUpdateWorker.Name = "UpdateHandler";
threadUpdateWorker.Priority = ThreadPriority.AboveNormal;
// 线程升级线程
threadUpdateWorker.Start();
return(true);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
return(false);
}
}
/// <summary>
/// 输出一帧数据
/// </summary>
/// <param name="control">输出帧的控制字段</param>
/// <param name="cmdId">输出帧的命令ID</param>
/// <param name="packetId">输出帧的报文ID</param>
/// <param name="len">输出帧的负载长度</param>
/// <param name="payload">输出帧的负载</param>
/// <param name="isAck">输出帧是否为响应报文</param>
/// <returns>输出成功与否</returns>
private bool output1Frame(byte control,
byte cmdId,
byte packetId,
byte len,
byte[] payload,
bool isAck = false)
{
lock (lockOutpacket)
{
if (payload.Length < len)
{
CommStackLog.RecordErr(enLogLayer.eSerial, "Frame payload length is shorter than expected");
return(false);
}
TimeSpan tsSendInterval = DateTime.Now - m_dtLastSend;
if (tsSendInterval.TotalMilliseconds < cfgMinOutFrameInterval)
{
Thread.Sleep((int)(cfgMinOutFrameInterval - tsSendInterval.TotalMilliseconds + 1));
}
try
{
m_hdlcore.OutputOpen();
m_hdlcore.OutputWrite(control); // Control
m_hdlcore.OutputWrite(cmdId); // Packet Type
m_hdlcore.OutputWrite(packetId); // Seq. Number
m_hdlcore.OutputWrite(len); // Payload Length
for (int i = 0; i < len; i++) // Payload
{
m_hdlcore.OutputWrite(payload[i]);
}
m_hdlcore.OutputClose();
// 更新最近发送的时刻值
m_dtLastSend = DateTime.Now;
return(true);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eSerial, ex.ToString());
return(false);
}
}
}
/// <summary>
/// 流控之Cts，目前只支持硬件流控
/// </summary>
/// <param name="enable">获取Cts状态</param>
public bool Cts()
{
bool CtsState = false;
try
{
CtsState = m_ApiDevice.CtsHolding;
// CommStackLog.RecordInf(enLogLayer.eDevice, "Cts = " + CtsState.ToString());
return(CtsState);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
return(false);
}
}
public void Dispose()
{
if (m_ApiDevice != null && m_ApiDevice.IsOpen)
{
try
{
m_bKeepReading = false;
m_ApiDevice.Close();
m_ApiDevice.Dispose();
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
finally
{
// 通过调用GC.SuppressFinalize(this)来告诉GC，让它不用再调用对象的析构函数中
//GC.SuppressFinalize(this);
}
}
if (cfgbCliExist)
{
if (m_CliDevice != null && m_CliDevice.IsOpen)
{
try
{
m_CliDevice.Close();
m_CliDevice.Dispose();
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
}
}
}
}
/// <summary>
/// HDLC层接收数据结束
/// </summary>
private void InputClose()
{
lock (CommStackLog.LockLog)
{
if (m_u16InputCrc == HDLC_CRCGOOD)
{
// remove the CRC from the input buffer
m_u8InputBufFill -= 2;
CommStackLog.RecordInf(enLogLayer.eHdlc, "Rx: " + CommStackLog.ToHexString(m_u8aInputBuf, m_u8InputBufFill));
}
else
{
CommStackLog.RecordErr(enLogLayer.eHdlc, "Rx crc error: " + m_u16InputCrc.ToString("X4"));
m_u8InputBufFill = 0;
}
// reset escaping
m_bInputEscaping = false;
}
}
/// <summary>
/// 流控之Dsr控制，目前只支持硬件流控
/// </summary>
/// <param name="enable">获取Dsr状态</param>
public bool Dsr()
{
bool DsrState = true;
try
{
DsrState = m_ApiDevice.DsrHolding;
//CommStackLog.RecordInf(enLogLayer.eDevice, "Dsr = " + DsrState.ToString());
return(DsrState);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, "Message:" + ex.Message);
CommStackLog.RecordErr(enLogLayer.eAdapter, "Source: " + ex.Source);
CommStackLog.RecordErr(enLogLayer.eAdapter, "StackTrace: " + ex.StackTrace);
CommStackLog.RecordErr(enLogLayer.eAdapter, "ToString: " + ex.ToString());
return(true);
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("EventNetworkReset.Unserialize take invalid parameter");
}
if (stream.Length < (offset + Len))
{
throw new Exception("EventNetworkReset.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
public void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("NotifBase.Unserialize take invalid parameter");
}
if (stream.Length < (offset + Len))
{
throw new Exception("NotifBase.Unserialize take invalid Index");
}
NotifyType = (enNotifyType)stream[offset];
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
public new void Unserialize(byte[] stream, int offset = 0)
{
try
{
if (stream == null || stream.Length <= 0)
{
throw new Exception("EventMoteLost.Unserialize take invalid parameter");
}
if (stream.Length < (offset + Len))
{
throw new Exception("EventMoteLost.Unserialize take invalid Index");
}
base.Unserialize(stream, offset);
Array.Copy(stream, offset + MAC_OFFSET, Mac.u8aData, 0, tMAC.LEN);
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eAdapter, ex.Message);
}
}
/// <summary>
/// 监控CLI
/// </summary>
public void MoniterCli()
{
if (cfgbCliExist)
{
if (m_CliDevice.IsOpen)
{
string strCmd = System.Configuration.ConfigurationManager.AppSettings["CliCommand"].ToString();
strCmd = strCmd.Trim();
char[] delimiterChars = { '|' };
string[] cmds = strCmd.Split(delimiterChars);
foreach (string cmd in cmds)
{
m_CliDevice.WriteLine(cmd.Trim());
}
}
else
{
CommStackLog.RecordErr(enLogLayer.eDevice, "WriteCliCom not open");
}
}
}
