/// <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("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("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);
}
}
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("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);
}
}
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>
/// 分发响应
/// </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());
}
}
/// <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());
}
}
}
/// <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);
}
/// <summary>
/// Dispose
/// </summary>
public void Dispose()
{
if (m_Mesh != null)
{
m_Mesh.Dispose();
}
m_bKeepRunning = false;
CommStackLog.Exit();
}
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);
}
private void moniterNewSessinWorker()
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "Wait 1 munites for new session");
Thread.Sleep(60000);
if (m_Session.Status != enSerStatus.SER_ST_CONNECTED)
{
managerLost();
CommStackLog.RecordInf(enLogLayer.eAdapter, "managerLost");
}
m_ThreadMoniterNewSessin = null;
}
/// <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()!");
}
}
public void Reset()
{
try
{
m_ApiDevice.DiscardInBuffer();
m_ApiDevice.DiscardOutBuffer();
}
catch (Exception ex)
{
CommStackLog.RecordErr(enLogLayer.eDevice, ex.ToString());
}
}
/// <summary>
/// 停止心跳
/// </summary>
private bool stopHeartbeat()
{
m_bHaultHeartbeat = true;
if (m_asigHaultHeartbeat.WaitOne(SYC_WAIT_MAX_TIME))
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "Stop heartbeatHandler ok");
return(true);
}
else
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "Stop heartbeatHandler failed");
return(false);
}
}
/// <summary>
/// 日志处理主线程函数
/// </summary>
private static void CommStackLogger()
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "CommStackLogger running");
while (!bExit && logQ.HaveLogElement)
{
LogElement logElem = logQ.DeQ();
if (logElem != null)
{
WriteLog(logElem.LogType, logElem.ToString(), logElem.NewLine);
}
}
asigThreadExit.Set();
}
/// <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>
/// 整理日志线程主函数
/// </summary>
private static void NeatenLog()
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "NeatenLog running");
DeleteExpiredLog();
// 如果当前时间以上次压缩间隔超过配置的压缩频率，则进行日志压缩
if ((DateTime.Now.Date - LastCompressDate.Date).Days >= cfgLogCopressFreq)
{
CompressInfoLog();
CompressErrLog();
CompressCLILog();
LastCompressDate = DateTime.Now;
}
bNeatening = false;
}
/// <summary>
/// 构造函数
/// </summary>
public MeshAdapter()
{
CommStackLog.Run();
m_Serial = new Serial();
m_Mesh = new MESH(m_Serial);
m_Session = new Session(m_Serial);
m_Manager = new ManagerOperator(m_Serial);
m_Manager.StabilizeManager();
m_Session.SessionLost = sessnLost;
m_Session.SessionBuilt = sessnConnected;
// 向mesh层注册通知到达处理方法
m_Mesh.NotifyArrived += notifyHandler;
m_Mesh.ReplyArrived = normalApiResponse;
// 将用户请求处理线程的优先级设置为最高
// 在Windows系统中：
// 线程的基本优先级 = [进程的基本优先级 - 2，进程的基本优先级 + 2]，由应用程序控制,
// Highest，AboveNormal，Normal，BelowNormal，Lowest
// 线程的动态优先级 = [ 进程的基本优先级 - 2, 31]，由NT核心控制
// 时间配额，是一个线程从进入运行状态到系统检查是否有其他优先级相同的线程需要开始运行之间的时间总和
// 系统线程userRequestQueueHandler
m_threadUserRequestWorker = new Thread(userRequestQueueHandler);
m_threadUserRequestWorker.Name = "userRequestQueueHandler";
m_threadUserRequestWorker.Priority = ThreadPriority.AboveNormal;
m_threadUserRequestWorker.Start();
// 系统线程asynCmdResponseHandler
m_threadMshResponseWork = new Thread(asynCmdResponseHandler);
m_threadMshResponseWork.Name = "asynCmdResponseHandler";
m_threadMshResponseWork.Priority = ThreadPriority.AboveNormal;
m_threadMshResponseWork.Start();
// 系统线程appCmdResponseHandler
m_threadWaitWsRspWorker = new Thread(appCmdResponseHandler);
m_threadWaitWsRspWorker.Name = "appCmdResponseHandler";
m_threadWaitWsRspWorker.Priority = ThreadPriority.Normal;
m_threadWaitWsRspWorker.Start();
// 系统线程appCmdResponseHandler
m_threadHeartbeatWorker = new Thread(heartbeatHandler);
m_threadHeartbeatWorker.Name = "heartbeatHandler";
m_threadHeartbeatWorker.Priority = ThreadPriority.BelowNormal;
m_threadHeartbeatWorker.Start();
}
/// <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>
/// HDLC层发送数据结束
/// </summary>
public void OutputClose()
{
UInt16 u16finalCrc = 0;
u16finalCrc = (UInt16)(~m_u16OutputCrc);
// write the CRC value
OutputWrite((byte)((u16finalCrc >> 0) & 0xFF));
OutputWrite((byte)((u16finalCrc >> 8) & 0xFF));
// write closing HDLC flag
lock (CommStackLog.LockLog)
{
//m_Com.Send(HDLC_FLAG);
m_u8aOutputBuf[m_u8OutputBufFill++] = HDLC_FLAG;
m_Com.SendArr(m_u8aOutputBuf, m_u8OutputBufFill);
CommStackLog.RecordInf(enLogLayer.eHdlc, "Tx: " + CommStackLog.ToHexString(m_u8aOutputPacketBuf, m_u8OutputPacketFill));
}
}
/// <summary>
/// 建立新会话的线程处理主函数
/// </summary>
/// <param name="threadParam"></param>
private void createNewSessionWorker()
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "Creating new session...");
m_asigAutoNwResetEvt.Reset();
// 重新构建系统及会话
if (preludeSystem(false))
{
//m_u8ResetManagerTime = 0;
// 当重启是因为升级
if (m_bUpdateReset)
{
// Manager已经重启，清除标志位
m_bUpdateReset = false;
// 等待Manager自身重启事件失败，准备手动触发Manager重启事件
if (!m_asigAutoNwResetEvt.WaitOne(WAIT_MGR_RSTEVT_TIMEOUT))
{
GetNetworkInfo(true);
}
}
}
// 构建失败则重启manager
else
{
//// 如果重启Manager多次仍不能建立新的会话，则通知上层与Manager会话断开
//if (++m_u8ResetManagerTime > RESET_MANAGER_MAX_TIME)
//{
// m_u8ResetManagerTime = 0;
// managerLost();
// CommStackLog.RecordErr(enLogLayer.eAdapter, "Manager Lost!");
// return;
//}
//// 否则，需要硬件重启
//else
if (m_ThreadMoniterNewSessin == null)
{
m_Manager.ResetManager();
CommStackLog.RecordInf(enLogLayer.eAdapter, "ResetManager HW!");
// 准备新的会话建立
m_ThreadMoniterNewSessin = new Thread(moniterNewSessinWorker);
m_ThreadMoniterNewSessin.Start();
}
}
m_bProcessingNewSessin = false;
}
/// <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>
/// 自描述报告的响应
/// </summary>
private bool ReplyWSDescribe(tMeshSelfReportResult resault, bool urgent = false)
{
lock (objectLock)
{
byte[] appStream = new byte[resault.Len];
resault.Serialize(appStream);
if (SendData(resault.mac, appStream, urgent, enPktPriority.High) == enURErrCode.ERR_NONE)
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "ReplyDescribe mac(" + resault.mac.ToHexString() + ")");
return(true);
}
else
{
CommStackLog.RecordInf(enLogLayer.eAdapter, "ReplyDescribe mac(" + resault.mac.ToHexString() + ")" + " unadmissible");
return(false);
}
}
}
/// <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);
}
}
