private void DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
if (e.Datagram[0] == 35 && e.Datagram[1] == 35) // Start with ## is plaint CMD
{
string cmd = System.Text.Encoding.Default.GetString(e.Datagram);
}
}
/// <summary>
/// 接收数据处理
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void client_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
Dispatcher.BeginInvoke((Action) delegate
{
DgService.ItemsSource = WinServHelper.GetServiceInfosFromBytes(e.Datagram);
});
}
private void TcpClient_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
Message message = new Message(e.ReceivedBytes);
this.Dispatcher.BeginInvoke(new Action(() => { MessageList.Add(message); }), System.Windows.Threading.DispatcherPriority.Normal);
emulator.HandleMessage(message);
}
/// <summary>
/// 接收到服务器的数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
static void ControllerServer_DatagramReceived(
object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
try
{
if (e.TcpClient != null)
{
if (RemoteHost == "" || RemoteHost == null)
{
RemoteHost = ((IPEndPoint)e.TcpClient.Client.RemoteEndPoint).Address.ToString();
}
if (RemotePort == "" || RemotePort == null)
{
RemotePort = ((IPEndPoint)e.TcpClient.Client.RemoteEndPoint).Port.ToString();
}
}
//处理数据
JsonInterFace.Parse(e.Datagram, RemoteHost, RemotePort);
}
catch (Exception ex)
{
if (Parameters.LogStatus == 0)
{
JsonInterFace.IODataHelper.SaveLogs(DateTime.Now.ToString(), "接收服务端数据异常", ex.Message, ex.StackTrace);
}
else
{
Parameters.PrintfLogsExtended("接收服务端数据异常", ex.Message, ex.StackTrace);
}
}
}
private void server_Received(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
Debug.Log(string.Format("Client : {0} --> {1}",
e.Client.TcpClient.Client.RemoteEndPoint.ToString(), e.Datagram.Length));
lock (Lock) {
inbox.Add(e.Client);
}
}
/// <summary>
/// 接收字节数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Client_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
//_master.UpdateDevceBData(Name, e.Datagram);
if (CRCMethod.CheckCRC(e.Datagram))
{
Bdata = e.Datagram;
UpDateTime = DateTime.Now;
}
}
public StatusStructure StatusAnalysis(TcpDatagramReceivedEventArgs <byte[]> e)
{
try
{
StatusStructure ss = new StatusStructure();
ss.BeginFlag = CommonFunction.byteToHexString(new byte[] { e.Datagram[0] });
ss.HeightValue = BitConverter.ToSingle(new byte[] { e.Datagram[4], e.Datagram[3], e.Datagram[2], e.Datagram[1] }, 0);
byte[] status = new byte[] { e.Datagram[5], 0 };
switch (CommonFunction.byteToHexString(status))
{
case "0000":
ss.isPlatformMoving = false;
ss.isLowCaliperClamp = true;
ss.isTopCaliperClamp = true;
break;
case "0100":
ss.isPlatformMoving = false;
ss.isLowCaliperClamp = true;
ss.isTopCaliperClamp = false;
break;
case "0200":
ss.isPlatformMoving = false;
ss.isLowCaliperClamp = false;
ss.isTopCaliperClamp = true;
break;
case "0400":
ss.isPlatformMoving = true;
ss.isLowCaliperClamp = true;
ss.isTopCaliperClamp = true;
break;
case "0300":
ss.isPlatformMoving = false;
ss.isLowCaliperClamp = false;
ss.isTopCaliperClamp = false;
break;
case "0700":
ss.isPlatformMoving = true;
ss.isLowCaliperClamp = false;
ss.isTopCaliperClamp = false;
break;
case "0600":
ss.isPlatformMoving = true;
ss.isLowCaliperClamp = false;
ss.isTopCaliperClamp = true;
break;
}
ss.EndFlag = CommonFunction.byteToHexString(new byte[] { e.Datagram[6] });
return(ss);
}
catch (Exception ex) { throw ex; }
}
private void TcpClient_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
if (e.Datagram != null)
{
var message = Encoding.UTF8.GetString(e.Datagram);
var response = Utils.Deserialize <ResponseInfo>(message);
DoResponse(e.TcpClient, response);
}
}
static void server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
if (e.Datagram != "Received")
{
Console.Write(string.Format("Client : {0} --> ", e.TcpClient.Client.RemoteEndPoint.ToString()));
Console.WriteLine(string.Format("{0}", e.Datagram));
server.Send(e.TcpClient, "Server has received you text : " + e.Datagram);
}
}
static void server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs<string> e)
{
if (e.Datagram != "Received")
{
Console.Write(string.Format("Client : {0} --> ", e.TcpClient.Client.RemoteEndPoint.ToString()));
Console.WriteLine(string.Format("{0}", e.Datagram));
server.Send(e.TcpClient, "Server has received you text : " + e.Datagram);
}
}
private void OnDataReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
byte[] content = e.datagram;
string str = System.Text.Encoding.Default.GetString(content);
//Encoding encoding = Encoding.UTF8;
//string contentstring = encoding.GetString(content, 0, content.Length);
this.receivetext = str;
//byte[] sendbackdata = new byte[] { 0xeb, 0x90 };
}
private void server_Received(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
Debug.Log(string.Format("Client : {0} --> {1}",
e.Client.TcpClient.Client.RemoteEndPoint.ToString(), e.Datagram.Length));
TcpClientState internalClient = e.Client;
string tcpClientKey = internalClient.TcpClient.Client.RemoteEndPoint.ToString();
inbox.AddOrUpdate(tcpClientKey, internalClient, (n, o) => {
return(internalClient);
});
}
void client_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
string receiveMsg = NetworkHelp.ConvertToStrData(e.Datagram);
this.tbMsg.Invoke(new Action(() =>
{
this.tbMsg.AppendText(
string.Format("Server : {0}" +
System.Environment.NewLine, receiveMsg
)
);;
}));
}
void client_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
if (e.Datagram != "Received")
{
textBox1.BeginInvoke((MethodInvoker) delegate
{
System.DateTime currentTime = new System.DateTime();/*取当前年月日时分秒 */
currentTime = System.DateTime.Now;
textBox1.AppendText(currentTime + string.Format("系统： {0} --> ", e.TcpClient.Client.RemoteEndPoint.ToString()));
textBox1.AppendText(string.Format("{0}", e.Datagram) + System.Environment.NewLine);
string[] SplitOrder = Split(e.Datagram);
});
}
}
private void TcpServer_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
if (e.Datagram != null && e.Datagram.Length > 0)
{
try
{
var message = Encoding.UTF8.GetString(e.Datagram);
var request = Utils.Deserialize <RequestInfo>(message);
if (request.Handler == "Connect")
{
tcpServer.Send(e.TcpClient, request, "连接成功！");
return;
}
var logger = new TcpServerLogger(rtbLog, request, tcpServer, e.TcpClient);
var ctxRequest = new RequestContext(logger);
ctxRequest.Request = request;
Utils.ExecuteAsync(ctxRequest, e1 =>
{
var ctx = e1.Argument as RequestContext;
if (ctx == null)
{
return;
}
var handler = RequestHandler.GetHandler(ctx);
if (handler == null)
{
ctx.Logger.WriteLog("不支持{0}的处理者！", ctx.Request.Handler);
return;
}
e1.Result = handler.Execute();
},
e2 =>
{
if (e2.Result != null)
{
tcpServer.Send(e.TcpClient, Utils.Serialize(e2.Result));
}
});
}
catch (Exception ex)
{
context.Logger.WriteLog("{0}接收异常，{1}", e.TcpClient.Client.RemoteEndPoint, ex.Message);
}
}
Application.DoEvents();
}
/// <summary>
/// 以byte[]传递数组// 这里可以作为普通数据的解析
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void server_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
try
{
//Thread thrd = new Thread(ExecuReceive);
ThreadPool.QueueUserWorkItem(ExecuReceive);
//thrd.Start(e);
//thrd.Join();
}
catch (Exception eww)
{
txtLog.Text += "\r\n 程序错误：" + eww.Message + "\r\n" + eww.StackTrace;
}
}
static void OnTcpPlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
Console.Write(string.Format("Server : {0} --> ", e.TcpClient.Client.RemoteEndPoint.ToString()));
Console.WriteLine(string.Format("{0}", e.Datagram));
}
private void server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
throw new NotImplementedException();
}
static void client_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs<string> e)
{
Console.Write(string.Format("Server : {0} --> ", e.TcpClient.Client.RemoteEndPoint.ToString()));
Console.WriteLine(string.Format("{0}", e.Datagram));
}
private void PlainTextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
string cmd = e.Datagram;
if (cmd.IndexOf(NetWorkCommand.QUIT) >= 0)
{
Log(string.Format(CultureInfo.InvariantCulture, "Received:{0}", cmd));
this.Close();
}
else if (cmd.IndexOf(NetWorkCommand.CLEAN) >= 0)
{
Log(string.Format(CultureInfo.InvariantCulture, "Received:{0}", cmd));
CleanSignature();
}
else if (cmd.IndexOf(NetWorkCommand.PAGEUP) >= 0)
{
ContentWindow.PrePage();
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke(
() => ShowOrHideCanvas(), System.Windows.Threading.DispatcherPriority.Normal);
}
else
{
ShowOrHideCanvas();
}
}
else if (cmd.IndexOf(NetWorkCommand.PAGEDOWN) >= 0)
{
ContentWindow.NextPage();
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke(
() => ShowOrHideCanvas(), System.Windows.Threading.DispatcherPriority.Normal);
}
else
{
ShowOrHideCanvas();
}
}
else if (cmd.IndexOf(NetWorkCommand.STYLUS_ADD) >= 0 || cmd.IndexOf(NetWorkCommand.STYLUS_REMOVE) >= 0)
{
if (cmd.IndexOf(NetWorkCommand.CLEAN) >= 0)
{
CleanSignature();
return;
}
String[] cmds = cmd.Split(NetWorkCommand.CMD.ToArray());
foreach (String c in cmds)
{
String[] arg = c.Split(':');
double lX = 0, lY = 0;
float lP = 0;
double scw = 0, sch = 0, ssw = 0, ssh = 0;
StylusPointCollection pts = new StylusPointCollection();
bool isAdd = true;
foreach (var ps in arg)
{
String[] p = ps.Split(',');
if (p.Length == 5)
{
isAdd = NetWorkCommand.STYLUS_ADD.IndexOf(p[0]) >= 0;
//接收签名设备屏幕信息
scw = double.Parse(p[1]);
sch = double.Parse(p[2]);
ssw = double.Parse(p[3]);
ssh = double.Parse(p[4]);
}
if (p.Length == 3)
{
double feedX = billImageW * 1d / scw;
double feedY = billImageH * 1d / sch;
lX = double.Parse(p[0]);
lY = double.Parse(p[1]);
lP = float.Parse(p[2]);
pts.Add(new StylusPoint(lX * feedX, lY * feedY, lP));
}
}
if (pts.Count > 0)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.Invoke(
() => DrawLine(pts, isAdd), System.Windows.Threading.DispatcherPriority.Normal);
}
else
{
DrawLine(pts, isAdd);
}
}
}
}
}
/// <summary>
/// 接收文本数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Client_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
//_master.UpdateDevceSData(Name, e.Datagram);
Sdata = e.Datagram;
UpDateTime = DateTime.Now;
}
void ExecuReceive(object data)
{
lock (CurrentClient)
{
AutoResetEvent exitEvent;
exitEvent = new AutoResetEvent(false);
//List<byte[]> mac_list = new List<byte[]>();
//bool open = true;
TcpDatagramReceivedEventArgs <byte[]> e = (TcpDatagramReceivedEventArgs <byte[]>)data;
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "服务器接收的基础数据：" + data);
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "；服务器收到来自设备的数据：" + Converts.GetTPandMac(e.Datagram) + ";");
int lengths = e.Datagram.Length;//接受客户端握手信息
string str_mac = "";
string str_boxdate = "";
//byte[] boxdate = new byte[6];
//byte[] mac = new byte[12];
byte[] boxdate = new byte[12];
byte[] mac = new byte[15];
//byte[] macnew = new byte[13];
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "服务器命令头：" + e.Datagram[0]);
switch (e.Datagram[0])
{
//第一个字节是EF
case 239: //主机返回的数据
{
#region 发送数据到客户端
//Array.Copy(e.Datagram, 10, mac, 0, 12);
//Array.Copy(e.Datagram, 22, boxdate, 0, 6);
try
{
Array.Copy(e.Datagram, 10, mac, 0, 15);
Array.Copy(e.Datagram, 25, boxdate, 0, 12);
str_mac = Converts.GetTPandMac(mac);
str_boxdate = Converts.GetTPandMac(boxdate);
DeviceClient dev = new DeviceClient();
dev.BoxState = str_boxdate;
dev.myclient = e.TcpClient; //请求端
dev.OnLine = false;
dev.StrMac = str_mac;
dev.typeid = 2;
//byte[] LastRes = HexStringToByte(GetLastStrToEnd("EF02", Converts.GetTPandMac(e.Datagram)));
byte[] LastRes = HexStringToByte(GetLastStrToEnd("EF03", Converts.GetTPandMac(e.Datagram)));
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "；服务器收到来自设备" + str_mac + "的数据：" + Converts.GetTPandMac(e.Datagram) + ";");
//showLog(DateTime.Now.ToString("HH:mm:ss") + "；服务器收到来自设备" + str_mac + "的数据：" + Converts.GetTPandMac(e.Datagram) + ";");
if (!CheckDataGram(LastRes))
{
//byte[] box_number = new byte[] { 0, 0, 0, 0, 0, 0 };
byte[] box_number = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
byte[] byteCommand = GetSendMulty(mac, box_number, 0x06);
string sss = ByteToHexString(byteCommand);
//暂时注释掉,回复指令
//int j = 0;
//while (j < 3)
//{
// try
// {
// Thread.Sleep(750);
// LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "向目标：" + dev.GetStrRemoteEndPoint + "；向MAC为" + str_mac + "发送重发要求" + sss);
// dev.SendMsg(byteCommand);
// break;
// }
// catch { j++; }
//}
}
else
{
if (e.Datagram[9] == 0x03) //开箱指令响应
{
string strLastCommanResponse = ByteToHexString(LastRes);
WeiXinClient wxclient = CurrentClient[str_mac, 1] as WeiXinClient;
if (wxclient != null)
{
wxclient.receivenum += GetStrAppearTimes("EF03", Converts.GetTPandMac(e.Datagram));
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "接收到来自MAC为" + str_mac + "的响应，响应的内容为:" + Converts.GetTPandMac(e.Datagram));
//LogHelper.showLog(txtLog, (DateTime.Now.ToString("HH:mm:ss") + "接收到来自MAC为" + str_mac + "的响应，响应的内容为:" + Converts.GetTPandMac(e.Datagram)));
try
{
if (wxclient.SendMsg(LastRes)) //收到的报文回送
{
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "向微信端回送成功:" + wxclient.GetStrRemoteEndPoint + strLastCommanResponse);
//LogHelper.showLog(txtLog, (DateTime.Now.ToString("HH:mm:ss") + "向微信端回送成功:" + wxclient.GetStrRemoteEndPoint + strLastCommanResponse));
CurrentClient.RemoveClient(wxclient.myclient);
}
else
{
LogHelper.showLog(txtLog, (DateTime.Now.ToString("HH:mm:ss") + "向微信端" + wxclient.GetStrRemoteEndPoint + "回送失败:" + strLastCommanResponse));
//LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "向微信端" + wxclient.GetStrRemoteEndPoint + "回送失败:" + strLastCommanResponse);
CurrentClient.RemoveClient(wxclient.myclient);
}
}
catch
{
CurrentClient.RemoveClient(wxclient.myclient);
//LogHelper.showLog(txtLog, (DateTime.Now.ToString("HH:mm:ss") + "向微信端" + wxclient.GetStrRemoteEndPoint + "回送失败:" + strLastCommanResponse));
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "向微信端" + wxclient.GetStrRemoteEndPoint + "回送失败:" + strLastCommanResponse);
}
}
dev.LastCommanResponse = strLastCommanResponse;
bool isAdded = CurrentClient.AddClient(dev);
CurrentClient.MultiSendOffLine();
}
else if (e.Datagram[9] == 0x01) //心跳
{
#region 将心跳信息存入数据库
byte[] byte_list = HexStringToByte(str_mac);
byte[] new_byte_list = new byte[byte_list.Length];
var new_mac = string.Empty;
for (int i = 0; i < byte_list.Length; i++)
{
byte new_byte = (byte)(byte_list[i] - 0x30);
new_mac += new_byte.ToString();
}
var commend = Converts.GetTPandMac(e.Datagram);
LogHelper.SaveHeart(new_mac, commend);
var sql = string.Format(@"
declare @cou int
select @cou =count(id) from WP_设备心跳记录表 where mac='{0}'
if @cou =0
begin
insert into WP_设备心跳记录表(mac,command) values('{0}','{1}')
end
else
begin
update WP_设备心跳记录表 set command = '{1}',createtime = getdate() where mac = '{0}'
end", new_mac, commend);
try
{
var b = DbHelperSQL.ExecuteSql(sql);
}
catch (Exception ex2)
{
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + ex2.Message);
}
#endregion
/*
* dev.LastBeat = ByteToHexString(e.Datagram); //服务器回应心跳包
* //LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "来自设备：" + dev.GetStrRemoteEndPoint + "；收到心跳" + dev.LastBeat);
* byte[] responsebeats;
* string strres;
* responsebeats = GetRightBeatsResponse(mac, true);
* strres = ByteToHexString(responsebeats);
* //LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "会送命令：" + responsebeats.ToString() + "；收到心跳" + dev.LastBeat);
* if (CheckDataGram(LastRes))
* {
* //LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "验证通过情况：" + responsebeats.ToString() + "；收到心跳" + dev.LastBeat);
* //dev.SendMsg(responsebeats);
* //LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "向" + str_mac + "发送响应心跳：" + strres);
* }
*/
bool isAdded = CurrentClient.AddClientWithOutCmd(dev);
CurrentClient.MultiSendOffLine();
}
//bool isAdded = CurrentClient.AddClient(dev);
//CurrentClient.MultiSendOffLine();
}
}
catch (Exception e2)
{
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "；" + e2.Message);
}
#endregion
}
break;
//微信过来的，发命令
case 02:
{
//mac_list.Add(e.Datagram);
//if (open)
//{
//}
try
{
#region 客户端发送的控制数据
//open = false;
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "客户端：" + e.TcpClient.Client.RemoteEndPoint.ToString() + "的原始命令：" + ByteToHexString(e.Datagram));
LogHelper.showLog(txtLog, (DateTime.Now.ToString("HH:mm:ss") + "客户端：" + e.TcpClient.Client.RemoteEndPoint.ToString() + "的原始命令：" + ByteToHexString(e.Datagram)));
Array.Copy(e.Datagram, 1, mac, 0, 15);
//mac_list.RemoveAt(0);
str_mac = Converts.GetTPandMac(mac);
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + "MAC：" + str_mac);
WeiXinClient wxclt = new WeiXinClient();
wxclt.sendnum = 0;
wxclt.receivenum = 0;
wxclt.myclient = e.TcpClient;
wxclt.StrMac = str_mac;
wxclt.command = ByteToHexString(e.Datagram);
wxclt.typeid = 1;
CurrentClient.AddClient(wxclt);
DeviceClient dev = CurrentClient[str_mac, 2] as DeviceClient;
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + " MAC：" + str_mac);
if (dev != null)
{ //拆命令发送
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + " dev不为空：" + str_mac);
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + " 命令长度：" + e.Datagram.Length);
byte[] box_number = new byte[e.Datagram.Length - 16];
Array.Copy(e.Datagram, 16, box_number, 0, e.Datagram.Length - 16);
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + " boxnumber：" + Converts.GetTPandMac(box_number));
int sendnum = 0;
#region 一次性
byte[] byteCommand = GetSendMulty(mac, box_number);
string sss = ByteToHexString(byteCommand);
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + " sss：" + sss);
try
{
Thread.Sleep(750);
LogHelper.WriteLog(DateTime.Now.ToString("HH:mm:ss") + " byteCommand：" + byteCommand);
dev.SendMsg(byteCommand);
sendnum++;
break;
}
catch (Exception err)
{
LogHelper.WriteLog("发送指令异常:" + err.Message + "错误发生位置为" + err.StackTrace);
LogHelper.showLog(txtLog, ("发送指令异常:" + err.Message + "错误发生位置为" + err.StackTrace));
}
#endregion
wxclt.sendnum = sendnum;
CurrentClient.AddClient(wxclt);
}
#endregion
}
catch (Exception ex)
{
LogHelper.WriteLog("发送指令异常:" + ex.Message + "错误发生位置为" + ex.StackTrace);
}
}
break;
default:
break;
}
Control.CheckForIllegalCrossThreadCalls = false;
label1.Text = CurrentClient.GetDevCount().ToString();
label3.Text = CurrentClient.GetWeiXinNumber().ToString();
//try
//{
//}
//catch (Exception ex)
//{
// string messages = string.Empty;
// messages = "捕获异常" + ex.Message + "错误发生位置为" + ex.StackTrace;
// //LogHelper.WriteLog(messages);
// //LogHelper.showLog(txtLog, messages);
//}
//finally
//{
//}
}
}
void server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
IPEndPoint ClientIP = (IPEndPoint)e.TcpClient.Client.RemoteEndPoint;
try
{
if (e.TcpClient == clientRobot)
{
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages:", e.Datagram, dic["测试命令模式"]);
switch (rd.receiveCommand(e.Datagram))
{
case Params.Robot2PCCommandType.Connection:
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.Active), dic["暂停模式选择"]);
dic["样件下半段下料完成反馈"] = false;
dic["Rotbot就绪"] = false;
dic["样件架样件夹持反馈"] = false;
dic["样件上半段下料至夹取位反馈"] = false;
dic["样件下半段下料至夹取位反馈"] = false;
dic["从样件架接料并夹持"] = false;
dic["样件上半段下料至夹取位"] = false;
dic["样件下半段下料至夹取位"] = false;
dic["样件下半段下料至夹取位"] = false;
dic["样件下半段下料完成反馈"] = false;
dic["试验数据保存完成"] = false;
dic["试验完毕"] = false;
dic["U型架移动到位并停止"] = false;
dic["拉断后U型架抬升完成"] = false;
dic["开始试验"] = false;
dic["拉力机准备就绪"] = false;
dic["样件上半段夹取位到达"] = false;
dic["样件下半段夹取位到达"] = false;
dic["U型架当前高度获得"] = false;
dic["U型架正在下降"] = false;
dic["U型架下降到位"] = false;
positionFlag = 0;
rd.AxisValue = "0.0";
i = 0;
break;
case Params.Robot2PCCommandType.Ready:
dic["Rotbot就绪"] = true;
//MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.ZQ1B));
break;
case Params.Robot2PCCommandType.ZQ1F:
dic["样件架样件夹持反馈"] = true;
if (dic["样件架样件夹持反馈"])
{
MsgSend(clientPLC, pd.createCommand(Params.PC2PLCCommandType.Finish), dic["暂停模式选择"]);
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.TopCaliperClamp), dic["暂停模式选择"]);
dic["U型架上升命令触发"] = false;
dic["U型架下降命令触发"] = false;
dic["U型架升降到位"] = false;
}
break;
case Params.Robot2PCCommandType.FeedBack1:
Thread.Sleep(20000);
dic["U型架升降到位"] = true;
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.LowCaliperClamp), dic["暂停模式选择"]);
break;
case Params.Robot2PCCommandType.DW1:
dic["样件上半段夹取位到达"] = true;
break;
case Params.Robot2PCCommandType.DW2:
dic["样件下半段夹取位到达"] = true;
break;
case Params.Robot2PCCommandType.ZQ2F:
dic["样件上半段下料至夹取位反馈"] = true;
break;
case Params.Robot2PCCommandType.ZQ3F:
dic["样件下半段下料至夹取位反馈"] = true;
break;
case Params.Robot2PCCommandType.FeedBack3:
dic["样件下半段下料完成反馈"] = true;
break;
case Params.Robot2PCCommandType.Finish:
dic["全部下料完成"] = true;
if (dic["全部下料完成"])
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.Break), dic["暂停模式选择"]);
}
if (fracturePositionResult != "中间")
{
if (fracturePositionResult == "断于下钳口")
{
MessageBox.Show("样件断在下钳口，请手动操作机器人将下半段下料！");
}
if (fracturePositionResult == "断于上钳口")
{
MessageBox.Show("样件断在上钳口，请手动操作机器人将上半段下料！");
}
}
break;
case Params.Robot2PCCommandType.Error:
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages: " + e.Datagram, " [Receive Unvalid Data!Please Check the Robot's Status]", dic["测试命令模式"]);
break;
}
}
}
catch (Exception ex)
{
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has some errors:", ex.Message, dic["测试命令模式"]);
}
}
void server_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
IPEndPoint ClientIP = (IPEndPoint)e.TcpClient.Client.RemoteEndPoint;
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + " has sent messages:", CommonFunction.byteToHexString(e.Datagram), dic["测试命令模式"]);
try
{
#region 样架PLC端
if (e.TcpClient == clientPLC)
{
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + " has sent messages:", CommonFunction.byteToHexString(e.Datagram), dic["测试命令模式"]);
switch (pd.receiveCommand(e.Datagram))
{
case Params.PLC2PCCommandType.Ready:
dic["上夹钳闭合"] = false;
dic["下夹钳闭合"] = false;
dic["批次试验完成"] = false;
MsgSend(clientPLC, pd.createCommand(Params.PC2PLCCommandType.Active), dic["暂停模式选择"]);
tsbAdd_Click(null, null);
break;
case Params.PLC2PCCommandType.Operation:
break;
case Params.PLC2PCCommandType.DataSend:
dic["上夹钳闭合"] = false;
dic["下夹钳闭合"] = false;
dic["批次试验完成"] = false;
SampleDiameter = seDiameter.Value;
SampleLength = seLength.Value;
MsgSend(clientPLC, pd.createCommand(Params.PC2PLCCommandType.DataFeedBack), dic["暂停模式选择"]);
break;
case Params.PLC2PCCommandType.CatchSample:
MsgSend(clientPLC, pd.createCommand(Params.PC2PLCCommandType.WaitKey), dic["暂停模式选择"]);
if (dic["Robot就绪"] && !dic["从样件架接料并夹持"] && dic["U型架升降到位"] && !dic["批次试验完毕"])
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.ZQ1B), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new Object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.CatchSample) });
dic["从样件架接料并夹持"] = true;
}
break;
case Params.PLC2PCCommandType.Complete:
dic["批次试验完毕"] = true; //该批次实验完毕
break;
case Params.PLC2PCCommandType.UrgencyStop:
break;
case Params.PLC2PCCommandType.ServoMotorError:
break;
case Params.PLC2PCCommandType.MeasuerRrror:
break;
case Params.PLC2PCCommandType.Error:
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages: " + CommonFunction.byteToHexString(e.Datagram), " [Receive Unvalid Data!Please Check the PLC's Status]", dic["测试命令模式"]);
break;
case Params.PLC2PCCommandType.CoderER:
dic["有急停信号"] = true;
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages: " + CommonFunction.byteToHexString(e.Datagram), " [样件架触发急停！请检查相关设备！]", false);
break;
case Params.PLC2PCCommandType.DevER:
dic["有急停信号"] = true;
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages: " + CommonFunction.byteToHexString(e.Datagram), " [伺服电机触发急停！请检查相关设备！]", false);
break;
case Params.PLC2PCCommandType.IntrusionDetectionER:
dic["有急停信号"] = true;
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages: " + CommonFunction.byteToHexString(e.Datagram), " [入侵检测触发急停！请检查相关设备！]", false);
break;
case Params.PLC2PCCommandType.RobotER:
dic["有急停信号"] = true;
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has sent messages: " + CommonFunction.byteToHexString(e.Datagram), " [机器人触发急停！请检查相关设备！]", false);
break;
}
}
#endregion
#region 拉力机PLC端
else if (e.TcpClient == clientCoder)
{
if (dic["系统开始运行"]) //系统开始运行
{
ss = ma.StatusAnalysis(e);
BeginInvoke(new UpdateDisplayDelegate(HeightDisplay), new object[] { ss.HeightValue.ToString() });
if (ss.HeightValue >= 1200)
{
MouseMovementControl(Params.MouseMovementType.ToStop, dic["暂停模式选择"]);
MessageBox.Show("拉力机移动到达上限位，请确认系统状态！");
}
if (dic["开始试验"] && dic["试验完毕"] && dic["拉断后U型架抬升完成"])
{
if (positionFlag == 1)
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.M1), dic["暂停模式选择"]);
Thread.Sleep(1000);
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.ZQ3B), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new Object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Zq3b) });
}
else if (positionFlag == 2)
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.M2), dic["暂停模式选择"]);
Thread.Sleep(1000);
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.ZQ3B), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new Object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Zq3b) });
}
}
if (!dic["样件上半段下料至夹取位"] && dic["开始试验"] && dic["试验完毕"] && dic["拉断后U型架抬升完成"]) //获取上升高度，命令机器人抓取
{
if ((positionFlag == 1 && dic["样件下半段下料至夹取位反馈"]) || positionFlag == 3)
{
if (!dic["U型架正在下降"])
{
if (!ss.isPlatformMoving)
{
MouseMovementControl(Params.MouseMovementType.ToDown, dic["暂停模式选择"]); BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new Object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Down) });
}
else
{
dic["U型架正在下降"] = true;
}
}
for (; ss.HeightValue < 800;)
{
MouseMovementControl(Params.MouseMovementType.ToStop, dic["暂停模式选择"]);
//tsbRead_Click(null, null);
dic["U型架下降到位"] = true;
break;
}
}
if (dic["U型架下降到位"])
{
if (positionFlag != 0)
{
if (positionFlag == 1 || positionFlag == 3)
{
rd.AxisValue = (ss.HeightValue - float.Parse(seZBHeight.Value.ToString())).ToString();
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.ZBAXIS), dic["暂停模式选择"]);
Thread.Sleep(1000);
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.ZQ2B), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Zq2b) });
}
dic["样件上半段下料至夹取位"] = true;
}
else
{
LogRefresh("未能正确获得断裂位置！", null, dic["测试命令模式"]);
MessageBox.Show("未能正确获得断裂位置！");
}
}
}
else if (!dic["放入拉力机并返回反馈"] && !dic["拉力机准备就绪"]) //初始化
{
#region 初始化逻辑修改：防止上下夹钳先后打开造成死机的情况发生，修改为先打开下夹钳，然后下降U型台，最后打开上夹钳的过程
//调整下夹钳
if (ss.isLowCaliperClamp)//下夹钳关闭
{
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.LowCaliperOpen), dic["暂停模式选择"]);
}
if (!ss.isLowCaliperClamp)
{
dic["下夹钳打开"] = true;//下夹钳打开
}
//调整上台高度
if ((ss.HeightValue > 805) || (ss.HeightValue < 795))
{
if (dic["下夹钳打开"]) //下夹钳已打开完成
{
if (ss.HeightValue > 805) //下降
{
if (!dic["U型架上升命令触发"])
{
if (!ss.isPlatformMoving)
{
MouseMovementControl(Params.MouseMovementType.ToDown, dic["暂停模式选择"]);
}
else
{
dic["U型架上升命令触发"] = true;
}
}
}
if (ss.HeightValue < 795)//上升
{
if (!dic["U型架下降命令触发"])
{
if (!ss.isPlatformMoving)
{
MouseMovementControl(Params.MouseMovementType.ToUp, dic["暂停模式选择"]);
}
else
{
dic["U型架下降命令触发"] = true;
}
}
}
}
}
else
{
MouseMovementControl(Params.MouseMovementType.ToStop, dic["暂停模式选择"]);
dic["U型架升降到位"] = true;
}
//调整上夹钳
if (ss.isTopCaliperClamp && dic["下夹钳打开"] && dic["U型架升降到位"])
{
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.TopCaliperOpen), dic["暂停模式选择"]);
}
if (!ss.isTopCaliperClamp)
{
dic["上夹钳打开"] = true;
}
//全部调整完毕以后，执行后续过程
if (dic["上夹钳打开"] && dic["下夹钳打开"] && dic["U型架升降到位"])
{
MsgSend(clientPLC, pd.createCommand(Params.PC2PLCCommandType.CatchSampleRequest), dic["暂停模式选择"]);
tsbAdd_Click(null, null);
dic["拉力机准备就绪"] = true;
}
#endregion
}
else if (dic["样件架样件夹持反馈"] && !dic["拉断后U型架抬升完成"]) //机器人抓取样件完成，送入拉力机位置
{
if (ss.isTopCaliperClamp)
{
Thread.Sleep(3000);
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.Return1), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Return1) });
} //上夹钳闭合，机器人退回
else
{
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.TopCaliperClamp), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.ClampClosing) });
}
if (dic["放入拉力机并返回反馈"])//机器人放入完成
{
if (!ss.isLowCaliperClamp)
{
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.LowCaliperClamp), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.ClampClosing) });
}
if (ss.isLowCaliperClamp && ss.isTopCaliperClamp && !dic["开始试验"]) //开始试验
{
if (Properties.Settings.Default.类别 == "1")
{
//试验版本
MouseMovementControl(Params.MouseMovementType.ToStart, dic["暂停模式选择"]);
if (ss.isPlatformMoving)
{
dic["开始试验"] = true;
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Test) });
}
}
else
{
//模拟测试版本
if (!dic["开始试验"])
{
MouseMovementControl(Params.MouseMovementType.ToUp, dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Test) });
}
if (ss.isPlatformMoving)
{
dic["开始试验"] = true;
if (ss.HeightValue > 830)
{
MouseMovementControl(Params.MouseMovementType.ToStop, dic["暂停模式选择"]);
}
}
}
}
if (dic["开始试验"])
{
if (ss.isPlatformMoving)
{
dic["U型架正在移动"] = true;
}
else
{
i++;
if (i > 5)
{
dic["U型架移动到位并停止"] = true;
}
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.TestFinished) });
}
}
}
if (dic["放入拉力机并返回反馈"] && dic["U型架正在移动"] && dic["U型架移动到位并停止"])//机器人放入样件完成，已经移动且停止（试验完毕）
{
if (!dic["U型架当前高度获得"])
{
V_Height = ss.HeightValue;
dic["U型架当前高度获得"] = true;
}
dic["试验完毕"] = true;
if (Properties.Settings.Default.类别 == "1")
{
MouseMovementControl(Params.MouseMovementType.ToSave, dic["暂停模式选择"]);
Thread.Sleep(2000);
tsbRead_Click(null, null);
if (dic["试验数据保存完成"])
{
fracturePositionResult = dt.Rows[0][53].ToString();//“需要根据数据库文件就行索引修改”
switch (fracturePositionResult)
{
case "中间":
positionFlag = 1;
break;
case "断于下钳口":
positionFlag = 2;
break;
case "断于上钳口":
positionFlag = 3;
break;
}
}
}
dic["拉断后U型架抬升完成"] = true;
}
}
if (dic["样件上半段下料至夹取位反馈"] && !ss.isTopCaliperClamp) //机器人取出上断裂样件后返回
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.Return2), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Return2) });
}
if (dic["样件下半段下料至夹取位反馈"] && !ss.isLowCaliperClamp) //机器人取出下断裂样件后返回
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.Return3), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.Return3) });
}
if (dic["样件上半段夹取位到达"])
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.JQ1), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.JQ1) });
if (ss.isTopCaliperClamp)
{
Thread.Sleep(10000);
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.TopCaliperOpen), dic["暂停模式选择"]);
}
}
if (dic["样件下半段夹取位到达"])
{
MsgSend(clientRobot, rd.createCommand(Params.PC2RobotCommandType.JQ2), dic["暂停模式选择"]);
BeginInvoke(new CheckStateControlDelegate(CheckStateControl), new object[] { PlatformStatusClassifier.StatusClassifier(Params.ProcessName.JQ2) });
if (ss.isLowCaliperClamp)
{
Thread.Sleep(10000);
MsgSend(clientCoder, ma.CommandAnalysis(Params.PC2CoderCommandType.LowCaliperOpen), dic["暂停模式选择"]);
}
}
}
}
#endregion
}
catch (Exception ex)
{
LogRefresh(ipC.iPConfig[ClientIP.Address.ToString()] + e.TcpClient.Client.RemoteEndPoint.ToString() + " has some errors:", ex.Message, dic["测试命令模式"]);
}
}
void __server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs<string> e)
{
this.CommandPacketUnpack(e.remoteEndPoint,e.Datagram);
//throw new NotImplementedException();
}
private void OnDataReceived(object sender, TcpDatagramReceivedEventArgs<byte[]> e)
{
byte[] content = e.datagram;
string str = System.Text.Encoding.Default.GetString(content);
//Encoding encoding = Encoding.UTF8;
//string contentstring = encoding.GetString(content, 0, content.Length);
this.receivetext = str;
//byte[] sendbackdata = new byte[] { 0xeb, 0x90 };
}
private void PlainTextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
string cmd = e.Datagram;
if (cmd.IndexOf(NetWorkCommand.QUIT) >= 0)
{
Log(string.Format(CultureInfo.InvariantCulture, "Received:{0}", cmd));
this.Close();
}
else if (cmd.IndexOf(NetWorkCommand.DRAW) >= 0)
{
emptySignature = false;
String[] cmds = cmd.Split(NetWorkCommand.CMD.ToArray());
foreach (String c in cmds)
{
String[] arg = c.Split(':');
if (arg.Length == 5)
{
DrawLine(int.Parse(arg[1]), int.Parse(arg[2]), int.Parse(arg[3]), int.Parse(arg[4]));
}
}
}
else if (cmd.IndexOf(NetWorkCommand.STYLUS_ADD) >= 0)
{
emptySignature = false;
String[] cmds = cmd.Split(NetWorkCommand.CMD.ToArray());
foreach (String c in cmds)
{
String[] arg = c.Split(':');
int lX = 0, lY = 0;
int scw = 0, sch = 0, ssw = 0, ssh = 0;
foreach (var ps in arg)
{
String[] p = ps.Split(',');
if (p.Length == 5)
{
//接收签名设备屏幕信息
scw = int.Parse(p[1]);
sch = int.Parse(p[2]);
ssw = int.Parse(p[3]);
ssh = int.Parse(p[4]);
}
if (p.Length == 3)
{
lX = lX == 0? (int)double.Parse(p[0]) : lX;
lY = lY == 0 ? (int)double.Parse(p[1]) : lY;
DrawLine(scw, sch, ssw, ssh, lX, lY, (int)double.Parse(p[0]), (int)double.Parse(p[1]));
lX = (int)double.Parse(p[0]);
lY = (int)double.Parse(p[1]);
}
}
}
}
else if (cmd.IndexOf(NetWorkCommand.CLEAN) >= 0)
{
Log(string.Format(CultureInfo.InvariantCulture, "Received:{0}", cmd));
emptySignature = true;
bitmap = new Bitmap(picSignature.Width, picSignature.Height, picSignature.CreateGraphics());
Graphics.FromImage(bitmap).Clear(Color.Transparent);
picSignature.Refresh();
}
}
/// <summary>
/// 服务器接受客户端消息时执行
/// </summary>
/// <param name="sender"></param>
/// <param name="e">接受数据参数-Tcpclient,byte[]</param>
static void server_DatagramReceived(object sender, TcpDatagramReceivedEventArgs <byte[]> e)
{
//TODO
int headData = DataHandleHelper.getHeadData(e.Datagram);
byte[] receviceData = e.Datagram;
string username;
bool isExist;
int battleCode;
switch (headData)
{
case CommandParam.LOGIN_REQUEST:
//登陆请求
username = DataHandleHelper.getStringParam(receviceData);
UserInfo userInfo = new UserInfo();
isExist = ConectMySqldb.queryUserInfoByUserName(username, userInfo);
if (isExist)
{
if (onLineList.ContainsKey(e.TcpClient) || onLineList.ContainsValue(username))
{
userInfo = new UserInfo(); //已存在用户或客户端，返回空值
}
else
{
onLineList.Add(e.TcpClient, username);
}
}
else
{
userInfo = new UserInfo();
}
//返回数据
server.Send(e.TcpClient, userInfo, CommandParam.LOGIN_RETURN);
break;
case CommandParam.LOADING_REQUEST:
//载入请求
username = DataHandleHelper.getStringParam(receviceData);
ReviewInfo reviewInfo = new ReviewInfo();
isExist = ConectMySqldb.queryReviewInfoByUserName(username, reviewInfo);
if (!isExist)
{
reviewInfo = new ReviewInfo(); //不存在，返回空值
}
//返回数据
server.Send(e.TcpClient, reviewInfo, CommandParam.LOAD_RETURN);
break;
case CommandParam.MATCH_REQUEST:
//匹配请求
MatchInfo matchInfo = new MatchInfo();
if (linelist.Count == 0)
{
linelist.Add(e.TcpClient);
matchInfo.isMatch = 0;
matchInfo.battleCode = -1;
}
else if (linelist.Count == 1)
{
if (linelist.Contains(e.TcpClient))
{
matchInfo.isMatch = 0;
matchInfo.battleCode = -1;
}
else
{
TcpClient emeny = linelist.ElementAt(0);
linelist.Remove(emeny); //移除第一个匹配的元素
TcpClient[] battle = new TcpClient[] { emeny, e.TcpClient };
battleList.Add(battle);
matchInfo.isMatch = 1;
matchInfo.battleCode = battleList.IndexOf(battle); //在对战列表的位置
}
}
else
{
matchInfo.isMatch = 0;
matchInfo.battleCode = -1;
}
//返回数据
server.Send(e.TcpClient, matchInfo, CommandParam.MATCH_RETURN);
break;
case CommandParam.BATTLE_REQUEST:
//战斗数据交换
battleCode = DataHandleHelper.getIntParam(receviceData);
BattleInfo battleInfo = new BattleInfo();
battleInfo.ReadByBytes(receviceData);
if (battleCode < 0)
{
return; //找不到战斗列表
}
else
{
foreach (var p in battleList.ElementAt(battleCode))
{
if (p != e.TcpClient)
{
TcpClient target = p;
battleInfo.setBattelCode(battleCode);
server.Send(target, battleInfo, CommandParam.BATTLE_RETURN);
}
}
}
break;
case CommandParam.UPDATE_REQUEST:
//更新数据
ReviewInfo updatereviewInfo = new ReviewInfo();
updatereviewInfo.ReadByBytes(receviceData);
UpdateInfo updateInfo = new UpdateInfo();
bool isUpdate = ConectMySqldb.updateReviewInfo(updatereviewInfo);
if (isUpdate)
{
updateInfo.isUpdate = 1;
}
else
{
updateInfo.isUpdate = 0;
}
//返回数据
server.Send(e.TcpClient, updateInfo, CommandParam.UPDATE_RETURN);
break;
case CommandParam.FINSH_REQUEST:
battleCode = DataHandleHelper.getIntParam(receviceData);
if (battleList.ElementAt(battleCode) != null)
{
battleList.RemoveAt(battleCode);
}
server.Send(e.TcpClient, "Gamerover");
break;
default:
server.Send(e.TcpClient, "参数错误");
break;
}
}
void server_DatagramReceived(object sender, TcpDatagramReceivedEventArgs<byte[]> e)
{
this.server.Send(e.remoteEndPoint,e.Datagram);
//异步处理，但别用e中的元素，因为可能其会失效
//MethodInvoker eh = new MethodInvoker(delegate {
// Thread.Sleep(3000);
// MessageBox.Show("MethodInvoker");
//});
//eh.BeginInvoke(null, null, null, null);
this.BeginInvoke(new MethodInvoker(delegate
{
this.listBox1.Items.Add("Server Thread=" + Thread.CurrentThread.ManagedThreadId + " : Rev " + e.remoteEndPoint + " " + Encoding.UTF8.GetString(e.Datagram));
this.listBox1.SelectedIndex = this.listBox1.Items.Count - 1;
}));
//throw new NotImplementedException();
}
private static void Server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs <string> e)
{
Console.WriteLine($"recv from { e.TcpClient.Client.RemoteEndPoint.ToString()}: {e.Datagram}");
Logger.Custom("log/", $"recv from { e.TcpClient.Client.RemoteEndPoint.ToString()}: {e.Datagram}");
#region 指令正确时
if (e.Datagram.Length == 10)
{
#region【1】定义变量
int index;
#endregion
#region【2】数据处理
try
{
int.TryParse(e.Datagram.Substring(5, 3), out index);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"Data Received from { e.TcpClient.Client.RemoteEndPoint.ToString()} exception：{ex.Message}");
byte[] msg = Encoding.Default.GetBytes("ErrorRequest!");
e.TcpClient.GetStream().Write(msg, 0, msg.Length); // return confirmation
return;
}
string cmd = e.Datagram.Remove(5, 3);
#endregion
#region【3】 处理逻辑
if (mySer != null && mySer.IsOpen)
{
DealwithCmd(cmd, index, e.TcpClient);
}
#endregion
#region 串口未打开时的异常处理
else
{
try
{
mySer.Open();
// if (mySer.ReceivedEvent
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"Serial Opening exception:{ex.Message}");
}
byte[] msg = Encoding.Default.GetBytes("SerialComunicationError!");
e.TcpClient.GetStream().Write(msg, 0, msg.Length); // return confirmation
}
#endregion
}
#endregion
#region 指令异常时
else
{
byte[] msg = Encoding.Default.GetBytes("ErrorRequest!-CMDLengthError");
e.TcpClient.GetStream().Write(msg, 0, msg.Length); // return confirmation
}
#endregion
}
