/// <summary>
/// 主机操作复位
/// </summary>
private void ResetMain()
{
if (currentGUID != "")
{
Queue.Remove(currentGUID);
currentGUID = "";
if (currentGetStatue != GetStatueList.无请求 && NeedMainReset != null)
{
NeedMainReset(this, new EventArgs());
}
currentGetStatue = GetStatueList.无请求;
}
}
private bool Loop()
{
try
{
lock (lockObject)
{
Dictionary <string, string> buff = new Dictionary <string, string>();
buff.Add("Code", string.Format("{0}", (int)currentSetStatue));
buff.Add("GUID", clientGuid);
SSMeter.SSReadMeter.ReadDataStyle rd = new SSMeter.SSReadMeter.ReadDataStyle(Class.TypeUse.TypeList.Int, buff);
byte[] readBuff;
if (WriteAndRead <byte[], byte[]>(rd.GetBytes(), 7, out readBuff))
{
SSMeter.SSReadMeter.ReadResultStyle rs = SSMeter.SSReadMeter.ReadResultStyle.Parse(readBuff);
if (rs == null || rs.Random != rd.Random || !rs.Result)
{
All.Class.Error.Add("SSLockClient.Loop无校验或校验不通过");
return(false);
}
List <int> result = (List <int>)rs.Value;
if (result[0] < 0 || result[0] >= Enum.GetNames(typeof(GetStatueList)).Length)
{
All.Class.Error.Add("SSLockClient.Loop无效的命令");
return(false);
}
switch ((SSLockMain.ReturnStatueList)result[0])
{
case SSLockMain.ReturnStatueList.无请求:
if ((int)currentGetStatue != (int)GetStatueList.无状态)
{
currentGetStatue = GetStatueList.无状态;
All.Class.Log.Add("SSLockClient.状态->无状态/无请求");
if (NeedClientReset != null)
{
NeedClientReset(this, new EventArgs());
}
}
break;
case SSLockMain.ReturnStatueList.允许:
if ((int)currentGetStatue != (int)GetStatueList.允许执行)
{
currentGetStatue = GetStatueList.允许执行;
All.Class.Log.Add("SSLockClient.状态->允许执行");
if (NeedClientSwitch != null)
{
NeedClientSwitch(this, new EventArgs());
}
}
break;
case SSLockMain.ReturnStatueList.等待:
if ((int)currentGetStatue != (int)GetStatueList.等待执行)
{
currentGetStatue = GetStatueList.等待执行;
All.Class.Log.Add("SSLockClient.状态->等待执行");
}
break;
}
}
else
{
return(false);
}
}
}
catch (Exception e)
{
All.Class.Error.Add(e);
return(false);
}
return(true);
}
private void lockUpd_GetStringArgs(Udp sender, ReciveString reciveArgs)
{
string value = reciveArgs.Value;
string[] buff = value.Split(new string[] { "~~~" }, StringSplitOptions.None);
T index = (T)(Object)(buff[0]);
LockClient <T> .SetStatueList statue = (LockClient <T> .SetStatueList)Num.ToInt(buff[1]);
switch (statue)
{
case LockClient <T> .SetStatueList.连接测试:
lockUdp.Write(string.Format("{0}", (int)GetStatueList.收到请求), reciveArgs.RemoteHost, reciveArgs.RemotePort);
break;
case LockClient <T> .SetStatueList.请求:
if (!lockList.Contains(index))
{
lockList.Add(index);
}
if (lockList.Count > 0)
{
if ((string)(object)lockList[0] == (string)(object)index)
{
lockUdp.Write(string.Format("{0}", (int)GetStatueList.允许执行互锁要求), reciveArgs.RemoteHost, reciveArgs.RemotePort);
}
else
{
lockUdp.Write(string.Format("{0}", (int)GetStatueList.等待), reciveArgs.RemoteHost, reciveArgs.RemotePort);
}
}
else
{
Error.Add("有添加的请求，但数组列为0", Environment.StackTrace);
}
break;
case LockClient <T> .SetStatueList.执行要求完毕:
if (lockList.Count > 0)
{
if ((string)(object)lockList[0] != (string)(object)index)
{
Error.Add(string.Format("动作完成的工位和允许执行的工位不是同一个，大问题。允许工位为：{0}，执行工位为：{1}", lockList[0], index), Environment.StackTrace);
return;
}
switch (nowStatueList)
{
case GetStatueList.收到请求:
if (AllTestNeedOk != null)
{
AllTestNeedOk();
}
nowStatueList = GetStatueList.正在执行互锁动作;
lockUdp.Write(string.Format("{0}", (int)GetStatueList.正在执行互锁动作), reciveArgs.RemoteHost, reciveArgs.RemotePort);
break;
case GetStatueList.正在执行互锁动作:
lockUdp.Write(string.Format("{0}~~~{1}", (int)GetStatueList.正在执行互锁动作, testingValue), reciveArgs.RemoteHost, reciveArgs.RemotePort);
break;
case GetStatueList.互锁动作执行完毕:
lockUdp.Write(string.Format("{0}~~~{1}", (int)GetStatueList.互锁动作执行完毕, testValue), reciveArgs.RemoteHost, reciveArgs.RemotePort);
break;
}
}
else
{
Error.Add("有返回执行的工位请求，但数组列为0", Environment.StackTrace);
}
break;
case LockClient <T> .SetStatueList.动作完毕取消请求:
lockUdp.Write(string.Format("{0}", (int)GetStatueList.互锁请求正常结束), reciveArgs.RemoteHost, reciveArgs.RemotePort);
if (lockList.Count > 0)
{
if ((string)(object)lockList[0] == (string)(object)index)
{
nowStatueList = GetStatueList.收到请求;
testValue = "";
testingValue = "";
lockList.Remove(index);
}
else
{
Error.Add(string.Format("动作完成的工位和完成请求的工位不是同一个，大问题。允许工位为：{0}，执行完成工位为：{1}", lockList[0], index), Environment.StackTrace);
return;
}
}
else
{
Error.Add("有返回完毕的工位请求，但数组列为0", Environment.StackTrace);
}
break;
case LockClient <T> .SetStatueList.除:
if (lockList.Count > 0)
{
if ((string)(object)lockList[0] == (string)(object)index)
{
nowStatueList = GetStatueList.收到请求;
testValue = "";
testingValue = "";
if (AllTestCancel != null)
{
AllTestCancel();
}
}
}
if (lockList.Contains(index))
{
lockList.Remove(index);
}
lockUdp.Write(string.Format("{0}", (int)GetStatueList.除请求成功), reciveArgs.RemoteHost, reciveArgs.RemotePort);
break;
}
}
/// <summary>
/// 处理各种请求
/// </summary>
private void Loop()
{
lock (lockObject)
{
//检测分站状态的合法性
allClientRequestStatue.Keys.ToList().ForEach(key =>
{
switch (allClientRequestStatue[key])
{
case SSLockClient.SetStatueList.开始测试:
if (Queue.GetCount(0) > 0 && Queue[0] != key) //如果分站不是第一个的话,状态不能为开始测试,
{
allClientRequestStatue[key] = SSLockClient.SetStatueList.除请求; //错误状态的请求,直接删除
}
break;
}
});
//确定返回分站的状态
allClientRequestStatue.Keys.ToList().ForEach(key =>
{
switch (allClientRequestStatue[key])
{
case SSLockClient.SetStatueList.无动作:
if (Queue.GetCurrent(key) != key) //排在后面的可以先删除掉
{
Queue.Remove(key);
}
allClientReturnStatue[key] = ReturnStatueList.无请求;
break;
case SSLockClient.SetStatueList.请求测试:
Queue.Request(key);
if (allClientReturnStatue[key] == ReturnStatueList.无请求)
{
allClientReturnStatue[key] = ReturnStatueList.等待;
}
break;
case SSLockClient.SetStatueList.开始测试:
break;
}
});
//确定主机应该如何动作
if (Queue.GetCount(0) > 0)
{
currentGUID = Queue[0];
if ((int)allClientRequestStatue[currentGUID] == (int)SSLockClient.SetStatueList.无动作)
{
ResetMain();
return;
}
switch (currentGetStatue)//主机当前状态
{
case GetStatueList.无请求:
switch (allClientRequestStatue[currentGUID]) //分机请求状态
{
case SSLockClient.SetStatueList.请求测试:
if ((int)currentGetStatue != (int)GetStatueList.等待主机执行互锁前切换动作)
{
All.Class.Log.Add("SSLockMain.状态->等待主机执行互锁前切换动作");
}
currentGetStatue = GetStatueList.等待主机执行互锁前切换动作;
if (NeedMainSwitch != null)
{
NeedMainSwitch(this, new EventArgs());
}
break;
default:
All.Class.Error.Add(string.Format("动作不能跳跃式完成,当前主机状态只能接收[请求测试]状态,实际接收[{0}]状态,请检查客户端发送状态逻辑", allClientRequestStatue[currentGUID]));
break;
}
break;
case GetStatueList.等待主机执行互锁前切换动作:
switch (allClientRequestStatue[currentGUID])
{
case SSLockClient.SetStatueList.开始测试:
if ((int)currentGetStatue != (int)GetStatueList.等待执行互锁动作)
{
All.Class.Log.Add("SSLockMain.状态->等待执行互锁动作");
}
currentGetStatue = GetStatueList.等待执行互锁动作;
if (NeedMainStart != null)
{
NeedMainStart(this, new EventArgs());
}
break;
case SSLockClient.SetStatueList.请求测试:
break;
default:
All.Class.Error.Add(string.Format("动作不能跳跃式完成,当前主机状态只能接收[开始测试]状态,实际接收[{0}]状态,请检查客户端发送状态逻辑", allClientRequestStatue[currentGUID]));
break;
}
break;
case GetStatueList.等待执行互锁动作:
break;
}
}
else
{
ResetMain();
}
}
}
public void AllTestOver(string value)
{
testValue = value;
nowStatueList = GetStatueList.互锁动作执行完毕;
}
