• EPSON机器人与PC上位机软件C#网络TCP通讯

    项目背景：

            在非标设备PIN焊接机中用到了爱普生机器人。上位机软件使用c#wpf开发。主要逻辑在上位机中。用爱普生机器人给焊接平台实现自动上下料。

    通讯方式：网络TCP通讯，Socket

    角色：上位机为服务端，机器人为客户端。

    责任分工:

            上位软件负责向机器人发送流程指令。

            机器人负责执行点位移动并返回执行结果。机器人有两个回复，一个是成功接收指令的回复，一个执行完成的回复。

    指令格式：

            上位机发送指令格式：SendData,No:{0},DeviceId:{1},FlowId:{2},Msg:{3},MsgTime:{4}

            机器人回复格式："ResponseNo:" + NoVal$ + ",DeviceId:" + DeviceIdVal$ + ",FlowId:" + FlowIdVal$ + ",IsSucceed:1" '回复上位机指令接收成功

            机器人执行后回复：SendData$ = "ResponseNo:" + NoVal$ + ",DeviceId:" + DeviceIdVal$ + ",FlowId:" + FlowIdVal$ + ",Status:0," + "Msg:" + message$

    上位机代码：

    RobertSoketMsgModel

    1. /// 
    2. /// 机器人通讯 消息实体
    3. /// 
    4. public class RobertSoketMsgModel
    5. {
    6.     /// 
    7.     /// 规则
    8.     /// 第一段是设备ID(1)
    9.     /// 第二段是类型ID(1)
    10.     /// 第三段是时间戳到3位MS
    11.     /// 1120231215162010110
    12.     /// 
    13.     public string No { get; set; }
    14.  
    15.     /// 
    16.     /// 响应编号
    17.     /// 
    18.     public string ResponseNo { get; set; }
    19.  
    20.     /// 
    21.     /// 设备ID【1:一号机器人】
    22.     /// 
    23.     public int DeviceId { get; set; }
    24.  
    25.     /// 
    26.     /// 流程ID FlowIdEnum
    27.     /// 
    28.     public int FlowId { get; set; }
    29.  
    30.     /// 
    31.     /// 消息
    32.     /// 
    33.     public string Msg { get; set; }
    34.  
    35.     /// 
    36.     /// 消息时间
    37.     /// 
    38.     public DateTime MsgTime { get; set; }
    39.  
    40.     /// 
    41.     /// 是否接收成功
    42.     /// 
    43.     public int IsSucceed { get; set; }
    44.  
    45.     /// 
    46.     /// 状态 成功为1，失败为0
    47.     /// 
    48.     public int Status { get; set; }
    49.  
    50.     public override string ToString()
    51.     {
    52.         return string.Format("No:{0},ResponseNo:{1},DeviceId:{2},FlowId:{3},Msg:{4},MsgTime:{5},IsSucceed:{6},Status:{7}",
    53.             No,ResponseNo,DeviceId, FlowId, Msg,MsgTime.ToString("yyyy-MM-dd HH:mm:ss"),IsSucceed, Status);
    54.     }
    55.  
    56.     /// 
    57.     /// 发送数据
    58.     /// 
    59.     /// 
    60.     public string ToSendString()
    61.     {
    62.         return string.Format("SendData,No:{0},DeviceId:{1},FlowId:{2},Msg:{3},MsgTime:{4}",
    63.             No, DeviceId, FlowId, Msg, MsgTime.ToString("yyyy-MM-dd HH:mm:ss"));
    64.     }
    65. }
    66.  
    67. /// 
    68. /// 流程ID
    69. /// 
    70. public enum FlowIdEnum
    71. {
    72.     //回原点=0,取料1=1(p1),取料2=2(p2),扫码=3(p3),焊接准备=4(p40),平台放料=5(p5),平台取料=6(p6),平台旋转位=7(p7),旋转=8(p8),
    73.     //出料1=9(p9),出料2=10(p10),NG出料1=11(p11),NG出料2=12(p12)
    74.  
    75.     /// 
    76.     /// 回原点
    77.     /// 
    78.     [Description("回原点")]
    79.     GoHome = 0,
    80.  
    81.     /// 
    82.     /// 取料1
    83.     /// 
    84.     [Description("取料1")]
    85.     GetMaterial1 = 1,
    86.  
    87.     /// 
    88.     /// 取料2
    89.     /// 
    90.     [Description("取料2")]
    91.     GetMaterial2 = 2,
    92.  
    93.     /// 
    94.     /// 进料扫码(读码)
    95.     /// 
    96.     [Description("进料扫码")]
    97.     ReadMaterialCodeIn = 3,
    98.  
    99.     /// 
    100.     /// 焊接准备
    101.     /// 
    102.     [Description("焊接准备")]
    103.     WeldPrepare = 4,
    104.  
    105.     /// 
    106.     /// 焊接平台放料
    107.     /// 
    108.     [Description("焊接平台放料")]
    109.     WeldPlatformPut = 5,
    110.  
    111.     /// 
    112.     /// 焊接平台取料
    113.     /// 
    114.     [Description("焊接平台取料")]
    115.     WeldPlatformGet = 6,
    116.  
    117.     /// 
    118.     /// 平台旋转位
    119.     /// 
    120.     [Description("平台旋转位")]
    121.     WeldRotatePos = 7,
    122.  
    123.     //旋转=8(p8),
    124.     /// 
    125.     /// 旋转(电爪)
    126.     /// 
    127.     [Description("旋转(电爪)")]
    128.     Rotate = 8,
    129.  
    130.     /// 
    131.     /// 焊接
    132.     /// 
    133.     [Description("焊接")]
    134.     Weld = 9,
    135.  
    136.     /// 
    137.     /// 出料扫码(读码)
    138.     /// 
    139.     [Description("出料扫码")]
    140.     ReadMaterialCodeOut = 10,
    141.  
    142.     /// 
    143.     /// 出料1
    144.     /// 
    145.     [Description("出料1")]
    146.     OutMaterial1 = 11,
    147.  
    148.     /// 
    149.     /// 出料2
    150.     /// 
    151.     [Description("出料2")]
    152.     OutMateria2 = 12,
    153.  
    154.     /// 
    155.     /// NG出料1
    156.     /// 
    157.     [Description("NG出料1")]
    158.     OutNgMaterial= 13,
    159.  
    160.     /// 
    161.     /// NG出料2
    162.     /// 
    163.     [Description("NG出料2")]
    164.     OutNgMateria2 = 14,
    165. }

    Socket

    1. /// 
    2. /// 机器人 通讯
    3. /// 
    4. public class RobertSocketServer
    5. {
    6.     private string _className = "RobertSocketServer";
    7.  
    8.     /// 
    9.     /// 设备总数
    10.     /// 
    11.     private int _DeviceCount = 1;
    12.  
    13.     /// 
    14.     /// 是否有在线客户端
    15.     /// 
    16.     public bool IsHaveClient = false;
    17.  
    18.     //将远程连接客户端的IP地址和Socket存入集合中
    19.     Dictionary<string, Socket> dicSocket = new Dictionary<string, Socket>();
    20.  
    21.     private ICommunicationLogService _serverCommunicationLog = ServiceIocFactory.GetRegisterServiceImp();
    22.  
    23.     /// 
    24.     /// 运行日志服务
    25.     ///         
    26.     private IRunningLogService _srerviceRunninglogs = ServiceIocFactory.GetRegisterServiceImp();
    27.  
    28.     /// 
    29.     /// 心跳回复时间
    30.     /// 
    31.     private Dictionary<int, DateTime> _heartbeatReplyTime = new Dictionary<int, DateTime>();
    32.  
    33.     /// 
    34.     /// IP
    35.     /// 
    36.     private string _ip;
    37.     /// 
    38.     /// 端口
    39.     /// 
    40.     private int _port = 6000;
    41.  
    42.     public RobertSocketServer(string ip, int port = 6000)
    43.     {
    44.         _ip = ip;
    45.         if (port > 0)
    46.         {
    47.             _port = port;
    48.         }
    49.         if (!string.IsNullOrEmpty(_ip))
    50.         {
    51.             startListen();
    52.         }
    53.         else
    54.         {
    55.             throw new Exception("IP地址不能为空");
    56.         }
    57.     }
    58.  
    59.     /// 
    60.     /// 添加客户端
    61.     /// 
    62.     /// 
    63.     /// 
    64.     /// 
    65.     private bool addClient(string ip, Socket socket)
    66.     {
    67.         var isSucceed = false;
    68.         if (!string.IsNullOrEmpty(ip) && socket != null)
    69.         {
    70.             if (!dicSocket.ContainsKey(ip))
    71.             {
    72.                 dicSocket.Add(ip, socket);
    73.                 _DeviceCount = dicSocket.Count;
    74.                 IsHaveClient = true;
    75.             }
    76.             isSucceed = true;
    77.         }
    78.         return isSucceed;
    79.     }
    80.  
    81.     /// 
    82.     /// 移除客户端
    83.     /// 
    84.     /// 
    85.     /// 
    86.     private bool removeClient(string ip)
    87.     {
    88.         var isSucceed = false;
    89.         if (!string.IsNullOrEmpty(ip))
    90.         {
    91.             if (dicSocket.ContainsKey(ip))
    92.             {
    93.                 dicSocket.Remove(ip);
    94.             }
    95.             if (dicSocket.Count == 0)
    96.             {
    97.                 IsHaveClient = false;
    98.             }
    99.             isSucceed = true;
    100.         }
    101.         return isSucceed;
    102.     }
    103.  
    104.     /// 
    105.     /// 开始监听
    106.     /// 
    107.     private void startListen()
    108.     {
    109.         try
    110.         {
    111.             //1、创建Socket(寻址方案.IP 版本 4 的地址,
    112.             Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    113.  
    114.             //2.绑定IP 端口
    115.             IPAddress ipAddress = IPAddress.Parse(_ip);
    116.             IPEndPoint point = new IPEndPoint(ipAddress, _port);
    117.             socket.Bind(point);
    118.             WorkFlow.ShowMsg("机器人通讯服务端已经启动监听", "startListen", _className);
    119.  
    120.             //3.开启监听
    121.             socket.Listen(10);//10监听对列的最大长度
    122.  
    123.             //4.开始接受客户端的连接 会卡界面 所以要开线程异步处理
    124.             Task.Run(() => { Listen(socket); });
    125.         }
    126.         catch (Exception ex)
    127.         {
    128.             WorkFlow.ShowAlarmMsg("机器人通讯 服务器监听 异常:" + ex.Message, "startListen");
    129.         }
    130.     }
    131.  
    132.     /// 
    133.     /// 4 开始接受客户端的连接
    134.     /// 
    135.     /// 
    136.     private void Listen(Socket socket)
    137.     {
    138.         if (socket != null)
    139.         {
    140.             while (true)
    141.             {
    142.                 try
    143.                 {
    144.                     //等待客户端的连接，并且创建一个负责通信的Socket
    145.                     var accept = socket.Accept();
    146.                     //将远程连接客户端的IP地址和Socket存入集合中
    147.                     var ip = accept.RemoteEndPoint.ToString();
    148.                     if (addClient(ip, accept))
    149.                     {
    150.                         //客户端IP地址和端口号存入下拉框
    151.                         //cmbClientList.Items.Add(ip);
    152.                         WorkFlow.ShowMsg("机器人客户端：" + ip + ":连接成功", "Listen", _className);
    153.  
    154.                         Task.Run(() => { ReciveClientMsg(accept); });
    155.                     }
    156.                 }
    157.                 catch (Exception ex)
    158.                 {
    159.                     WorkFlow.ShowAlarmMsg("开始接受机器人客户端的连接 异常:" + ex.Message, "Listen", _className);
    160.                 }
    161.             }
    162.         }
    163.     }
    164.  
    165.     /// 
    166.     /// 接收客户端消息
    167.     /// 
    168.     private void ReciveClientMsg(Socket socket)
    169.     {
    170.         WorkFlow.ShowMsg("机器人服务器已启动成功，可以接收客户端连接!时间：" + DateTime.Now.ToString(),
    171.             "ReciveClientMsg", _className);
    172.         //客户端连接成功后，服务器应该接收客户端发来的消息
    173.         byte[] buffer = new byte[1024 * 1024 * 5];
    174.         string reciveMsg = string.Empty;
    175.         //不停的接收消息
    176.         while (true)
    177.         {
    178.             try
    179.             {
    180.                 //实际接收到的有效字节数
    181.                 int byteLength = 0;
    182.                 try
    183.                 {
    184.                     byteLength = socket.Receive(buffer);
    185.                 }
    186.                 catch (Exception)
    187.                 {
    188.                     //客户端异常退出
    189.                     clientExit(socket, "异常");
    190.                     return;//让方法结束，结束当前接收客户端消息异步线程
    191.                 }
    192.                 if (byteLength > 0)
    193.                 {
    194.                     reciveMsg = Encoding.UTF8.GetString(buffer, 0, byteLength);
    195.                     //ResponseNo:9876543,IsSucceed:1
    196.                     //ResponseNo:9876543,Status:1
    197.                     if (!string.IsNullOrEmpty(reciveMsg) && reciveMsg.Contains("ResponseNo"))
    198.                     {
    199.                         var rspModel = getMsgModelByStr(reciveMsg);
    200.                         if (rspModel != null)
    201.                         {
    202.                             var isSucceed = 0;
    203.                             if (rspModel.IsSucceed == TrueOrFalseEnum.True.GetHashCode())
    204.                             {
    205.                                 isSucceed = rspModel.IsSucceed;
    206.                             }
    207.                             else if (rspModel.Status == TrueOrFalseEnum.True.GetHashCode())
    208.                             {
    209.                                 isSucceed = rspModel.Status;
    210.                             }
    211.                             rspModel.IsSucceed = isSucceed;
    212.                             var logModel = new CommunicationLogModel()
    213.                             {
    214.                                 DeviceId = rspModel.DeviceId,
    215.                                 Msg = rspModel.Msg,
    216.                                 MsgTime = rspModel.MsgTime,
    217.                                 No = rspModel.ResponseNo,
    218.                                 Type = rspModel.FlowId,
    219.                                 IsSucceed = rspModel.IsSucceed,
    220.                                 ResponseNo = rspModel.ResponseNo
    221.                             };
    222.                             logModel.ClassName = _className;
    223.                             logModel.Method = "ReciveClientMsg";
    224.                             logModel.CreatedBy = _ip;
    225.                             logModel.CreatedOn = DateTime.Now;
    226.                             logModel.UpdatedBy = Global.EthernetType.GetEnumDesc();
    227.  
    228.                             FlowIdEnum flowIdEnum = (FlowIdEnum)rspModel.FlowId;
    229.                             if (rspModel.Status == TrueOrFalseEnum.True.GetHashCode())
    230.                             {
    231.                                 RobertSocketCommonServer.AddClientRspMsg(rspModel);
    232.                                 WorkFlow.ShowMsg("收机器人2>" + rspModel.DeviceId + "机" + flowIdEnum.GetEnumDesc() + "回复:" + (rspModel.Status == TrueOrFalseEnum.True.GetHashCode() ? "处理成功" : "处理失败"), "ReciveClientMsg");
    233.                             }
    234.                             else if (rspModel.IsSucceed == TrueOrFalseEnum.True.GetHashCode())
    235.                             {
    236.                                 RobertSocketCommonServer.IsSendSucceed = rspModel.IsSucceed == TrueOrFalseEnum.True.GetHashCode();
    237.                                 WorkFlow.ShowMsg("收机器人2>" + rspModel.DeviceId + "机" + flowIdEnum.GetEnumDesc() + "回复:" + (rspModel.IsSucceed == TrueOrFalseEnum.True.GetHashCode() ? "指令接收成功" : "指令接收失败"), "ReciveClientMsg");
    238.                             }
    239.                             _serverCommunicationLog.AddModelAutoIncrement(logModel);
    240.                         }
    241.                     }
    242.                     //var msg = "客户端" + socket.RemoteEndPoint + " 发送:  " + reciveMsg + "   时间：" + DateTime.Now.ToString();
    243.                     //WorkFlow.ShowMsg(msg, "ReciveClientMsg", _className);
    244.                 }
    245.                 else
    246.                 {
    247.                     //客户端正常退出
    248.                     clientExit(socket);
    249.                     return;//让方法结束，结束当前接收客户端消息异步线程
    250.                 }
    251.             }
    252.             catch (Exception ex)
    253.             {
    254.                 WorkFlow.ShowAlarmMsg("接收客户商消息 异常:" + ex.Message, "ReciveClientMsg", _className);
    255.             }
    256.         }
    257.     }
    258.  
    259.     /// 
    260.     /// 客户端退出
    261.     /// 
    262.     /// 
    263.     /// 
    264.     /// 
    265.     private bool clientExit(Socket socket, string type = "正常")
    266.     {
    267.         var isSucceed = false;
    268.         var ip = socket.RemoteEndPoint.ToString();
    269.         if (removeClient(ip))
    270.         {
    271.             //cmbClientList.Items.Remove(ip);
    272.             WorkFlow.ShowMsg("客户端" + socket.RemoteEndPoint + type + "退出。 时间：" + DateTime.Now.ToString(),
    273.                 "clientExit", _className);
    274.             isSucceed = true;
    275.             //Task.Factory.StartNew(() =>
    276.             //{
    277.             //    WindowHelper.OpenAlarmWindow(ip + "客户端退出报警!", "通讯报警");
    278.             //});
    279.         }
    280.         return isSucceed;
    281.     }
    282.  
    283.     /// 
    284.     /// 向客户端发送消息
    285.     /// 
    286.     /// 
    287.     /// 
    288.     public bool SendMsgToClient(string msg)
    289.     {
    290.         var isOk = false;
    291.         //var msg = txtSendMes.Text.Trim();
    292.         //var clientIp = cmbClientList.SelectedItem.ToString();
    293.         //if (dicSocket.ContainsKey(clientIp))
    294.         //{
    295.         if (!string.IsNullOrEmpty(msg))
    296.         {
    297.             if (dicSocket.Count == 0)
    298.             {
    299.                 //MessageBox.Show("没有可以发送的客户端");
    300.                 WorkFlow.ShowMsgSocket("没有可以发送的客户端");
    301.             }
    302.             else
    303.             {
    304.                 foreach (var clientIp in dicSocket.Keys)
    305.                 {
    306.                     var socket = dicSocket[clientIp];
    307.                     if (socket.Connected)//判断是否连接成功
    308.                     {
    309.                         //数据编码
    310.                         var buffer = Encoding.UTF8.GetBytes(msg);
    311.                         var dataList = new List<byte>();
    312.                         //dataList.Add(0);//类型：文本，字符串
    313.                         dataList.AddRange(buffer);
    314.  
    315.                         //socket.Send(dataList.ToArray(), 0, buffer.Length, SocketFlags.None);
    316.                         socket.Send(dataList.ToArray());
    317.                     }
    318.                 }
    319.                 Thread.Sleep(100);
    320.             }
    321.         }
    322.         else
    323.         {
    324.             //MessageBox.Show("发送的消息不能为空!");
    325.             WorkFlow.ShowMsg("发送的消息不能为空!", "SendMsgToClient", _className);
    326.         }
    327.         //}
    328.         return isOk;
    329.     }
    330.  
    331.     /// 
    332.     /// 解析机器人回传信息
    333.     /// 
    334.     /// 
    335.     /// 
    336.     private RobertSoketMsgModel getMsgModelByStr(string rspStr)
    337.     {
    338.         //ResponseNo:9876543,WorkId:1,IsSucceed:1
    339.         //ResponseNo:9876543,WorkId:1,Status:1,Msg:"执行失败"
    340.         //\r\n
    341.         RobertSoketMsgModel rspModel = null;
    342.         if (!string.IsNullOrEmpty(rspStr))
    343.         {
    344.             rspStr = rspStr.Replace("\r\n", string.Empty);
    345.             var responseNo = string.Empty;
    346.             int DeviceId = 0;
    347.             int FlowId = 0;
    348.             var isSucceed = TrueOrFalseEnum.False.GetHashCode();
    349.             var strList = rspStr.Split(',').ToList();
    350.             if (strList.Count > 0)
    351.             {
    352.                 responseNo = strList[0].Replace("ResponseNo:", string.Empty);
    353.                 DeviceId = strList[1].Replace("DeviceId:", string.Empty).ToInt();
    354.                 FlowId = strList[2].Replace("FlowId:", string.Empty).ToInt();
    355.  
    356.                 rspModel = new RobertSoketMsgModel();
    357.                 rspModel.ResponseNo = responseNo;
    358.                 rspModel.FlowId = FlowId;
    359.                 rspModel.DeviceId = DeviceId;
    360.                 rspModel.MsgTime = DateTime.Now;
    361.                 if (rspStr.Contains("IsSucceed") && strList.Count >= 4)
    362.                 {
    363.                     isSucceed = strList[3].Replace("IsSucceed:", string.Empty).ToInt();
    364.                     rspModel.IsSucceed = isSucceed;
    365.                 }
    366.                 else if (rspStr.Contains("Status") && strList.Count >= 4)
    367.                 {
    368.                     rspModel.Status = strList[3].Replace("Status:", string.Empty).ToInt();
    369.                     if (strList.Count > 5)
    370.                     {
    371.                         rspModel.Msg = strList[4].Replace("Msg:", string.Empty);
    372.                     }
    373.                     else
    374.                     {
    375.                         rspModel.Msg = rspModel.Status == TrueOrFalseEnum.True.GetHashCode() ? "执行成功" : "执行失败";
    376.                     }
    377.                 }
    378.             }
    379.         }
    380.         return rspModel;
    381.     }
    382. }

    RobertSocketCommonServer

    1. /// 
    2. /// 机器人 通讯公共方法(服务端)
    3. /// 
    4. public class RobertSocketCommonServer
    5. {
    6.     private static string _className = "RobertSocketCommonServer";
    7.     private static string commMsg = "机器人";
    8.     private static ICommunicationLogService _serverCommunicationLog = ServiceIocFactory.GetRegisterServiceImp();
    9.     /// 
    10.     /// 公共日志服务
    11.     /// 
    12.     private static ICommonLogService _serviceLogs = ServiceIocFactory.GetRegisterServiceImp();
    13.  
    14.     /// 
    15.     /// 客户端响应消息
    16.     /// 
    17.     private static Dictionary<string, RobertSoketMsgModel> _clientResponseMsgDic = new Dictionary<string, RobertSoketMsgModel>();
    18.  
    19.     /// 
    20.     /// 是否发送要料消息
    21.     /// 
    22.     //public static bool IsSendInMsg = false;
    23.  
    24.     /// 
    25.     /// 是否发送成功
    26.     /// 
    27.     public static bool IsSendSucceed = false;
    28.  
    29.     /// 
    30.     /// 创建一个请求消息模型
    31.     /// 
    32.     /// 设备ID
    33.     /// 类型
    34.     /// 
    35.     public static RobertSoketMsgModel CreateInMsgModel(int deviceId, FlowIdEnum flowId)
    36.     {
    37.         return new RobertSoketMsgModel()
    38.         {
    39.             DeviceId = deviceId,
    40.             Msg = flowId.ToString(),//deviceId + commMsg + type.GetEnumDesc(),
    41.             MsgTime = DateTime.Now,
    42.             No = AppCommonMethods.GenerateMsgNoRobert(flowId, deviceId),
    43.             FlowId = flowId.GetHashCode()
    44.         };
    45.     }
    46.  
    47.     /// 
    48.     /// 发送指令
    49.     /// 
    50.     /// 设备ID
    51.     public static RobertSoketMsgModel SendReq(FlowIdEnum flowId, int deviceId = 1)
    52.     {
    53.         IsSendSucceed = false;
    54.         var msgModel = CreateInMsgModel(deviceId, flowId);
    55.         //var reqJson = JsonConvert.SerializeObject(msgModel);
    56.         Global.RobertEthernetServer.SendMsgToClient(msgModel.ToSendString());
    57.         var logModel = new CommunicationLogModel()
    58.         {
    59.             DeviceId = msgModel.DeviceId,
    60.             Msg = msgModel.Msg,
    61.             MsgTime = msgModel.MsgTime,
    62.             No = msgModel.No,
    63.             Type = flowId.GetHashCode()
    64.         };
    65.         logModel.ClassName = _className;
    66.         logModel.Method = "SendLocalInReq";
    67.         logModel.CreatedBy = Global.EAP_IpAddress;
    68.         logModel.CreatedOn = DateTime.Now;
    69.         logModel.UpdatedBy = Global.EthernetType.GetEnumDesc();
    70.         _serverCommunicationLog.AddModelAutoIncrement(logModel);
    71.         //SoketMsgQueueService.Instance.Enqueue(msgModel);
    72.         return msgModel;
    73.     }
    74.  
    75.     /// 
    76.     /// 本机发送放(出)料请求
    77.     /// 
    78.     /// 设备ID
    79.     //public static string SendLocalOutReq(int deviceId)
    80.     //{
    81.     //    var msgModel = CreateInMsgModel(deviceId, SoketTypeEnum.OutRequest);
    82.     //    var logModel = new CommunicationLogModel()
    83.     //    {
    84.     //        DeviceId = msgModel.DeviceId,
    85.     //        Msg = msgModel.Msg,
    86.     //        MsgTime = msgModel.MsgTime,
    87.     //        No = msgModel.No,
    88.     //        Type = msgModel.Type.GetHashCode()
    89.     //    };
    90.     //    logModel.ClassName = _className;
    91.     //    logModel.Method = "SendLocalOutReq";
    92.     //    logModel.CreatedBy = Global.EAP_IpAddress;
    93.     //    logModel.CreatedOn = DateTime.Now;
    94.     //    logModel.UpdatedBy = Global.EthernetType.GetEnumDesc();
    95.     //    _serverCommunicationLog.AddModelAutoIncrement(logModel);
    96.     //    SoketMsgQueueService.Instance.Enqueue(msgModel);
    97.     //    return msgModel.No;
    98.     //}
    99.  
    100.     /// 
    101.     /// 添加客户端响应消息
    102.     /// 
    103.     /// 
    104.     /// 
    105.     public static bool AddClientRspMsg(RobertSoketMsgModel model)
    106.     {
    107.         var isOk = false;
    108.         if (model != null && !_clientResponseMsgDic.ContainsKey(model.ResponseNo))
    109.         {
    110.             _clientResponseMsgDic.Add(model.ResponseNo, model);
    111.             isOk = true;
    112.         }
    113.         return isOk;
    114.     }
    115.  
    116.     /// 
    117.     /// 获取客户端响应消息
    118.     /// 
    119.     /// 
    120.     /// 
    121.     public static RobertSoketMsgModel GetClientRspMsg(string no)
    122.     {
    123.         RobertSoketMsgModel msgModel = null;
    124.         if (_clientResponseMsgDic.ContainsKey(no))
    125.         {
    126.             msgModel = _clientResponseMsgDic[no];
    127.             _clientResponseMsgDic.Remove(no);
    128.         }
    129.         return msgModel;
    130.     }
    131.  
    132.     /// 
    133.     /// While等待获取客户端响应消息
    134.     /// 
    135.     /// 
    136.     /// 最大等待次数
    137.     /// 
    138.     public static RobertSoketMsgModel GetClientRspMsgWhile(string no, string msg, RobertSoketMsgModel reqModel = null, int maxCount = 60)
    139.     {
    140.         RobertSoketMsgModel msgModel = null;
    141.         var count = 0;
    142.         while (msgModel == null)
    143.         {
    144.             msgModel = GetClientRspMsg(no);
    145.             Thread.Sleep(200);
    146.             //Thread.Sleep(1000);
    147.             WorkFlow.ShowMsg("While等待获取" + commMsg + "..." + msg, "GetClientRspMsgWhile", RunningLogTypeEnum.Alarm);
    148.             //if (count >= maxCount)
    149.             //{
    150.             //    var showMsg = msg + ",未收到" + commMsg + "响应消息。是否继续等待？";
    151.             //    var commonModel = WindowHelper.OpenWindow(showMsg, "等待获取客户端响应消息报警", "继续等", "不等了");
    152.             //    if (commonModel != null && commonModel.IsSucceed)
    153.             //    {
    154.             //        if (reqModel != null)
    155.             //        {
    156.             //            var modelJson = JsonConvert.SerializeObject(reqModel);
    157.             //            Global.EthernetServer.SendMsgToClient(modelJson);//发送物料_通知
    158.             //            var logModelRsp = JsonConvert.DeserializeObject(modelJson);
    159.             //            logModelRsp.ClassName = _className;
    160.             //            logModelRsp.Method = "GetClientRspMsgWhile";
    161.             //            logModelRsp.Remark = showMsg;
    162.             //            logModelRsp.CreatedBy = Global.EAP_IpAddress;
    163.             //            logModelRsp.CreatedOn = DateTime.Now;
    164.             //            logModelRsp.UpdatedBy = Global.EthernetType.GetEnumDesc();
    165.             //            _serverCommunicationLog.AddModelAutoIncrement(logModelRsp);
    166.             //        }
    167.             //        count = 0;
    168.             //    }
    169.             //    else
    170.             //    {
    171.             //        break;
    172.             //    }
    173.             //}
    174.             count++;
    175.         }
    176.         return msgModel;
    177.     }
    178.  
    179.     /// 
    180.     /// 移动到点位
    181.     /// 
    182.     /// 
    183.     /// 
    184.     public static bool MoveToPos(FlowIdEnum flowId)
    185.     {
    186.         var isSucceed = false;
    187.         var reqModel = SendReq(flowId);
    188.         if (IsSendSucceed)
    189.         {
    190.             var rspModel = GetClientRspMsgWhile(reqModel.No, "机器人的指令处理回复");
    191.             if (rspModel != null)
    192.             {
    193.                 isSucceed = rspModel.IsSucceed == TrueOrFalseEnum.True.GetHashCode();
    194.                 WorkFlow.ShowMsg("收到机器人处理完成回复[" + flowId.GetEnumDesc() + "]" + rspModel.IsSucceed, "MoveToPos");
    195.             }
    196.             else
    197.             {
    198.                 WorkFlow.ShowMsg("未收到机器人处理完成回复[" + flowId.GetEnumDesc() + "]", "MoveToPos");
    199.             }
    200.         }
    201.         else
    202.         {
    203.             WorkFlow.ShowMsg("发送指令到机器人，发送失败。[" + flowId.GetEnumDesc() + "]", "MoveToPos");
    204.         }
    205.         return isSucceed;
    206.     }
    207. }

    机器人代码：

    1. Global String ReceiveData$, data$(0), SendData$
    2. Global String No$, DeviceId$, FlowId$, Msg$, MsgTime$ '假设receive有三组数据,分到三个值里
    3. Global String NoVal$, DeviceIdVal$, FlowIdVal$, MsgVal$, MsgTimeVal$
    4. Function main
    5. 	'Call initprg
    6. 	Call tcpClient
    7. Fend
    8. Function tcpClient
    9. 	ReceiveData$ = ""
    10. 	'设置IP地址,端口号,结束符等
    11.     'SetNet #201, "192.168.2.100", 3000, CRLF, NONE, 0
    12.     SetNet #201, "192.168.10.203", 2000, CRLF, NONE, 0
    13.     
    14.     retry_tcpip_201:		'断线重连
    15.     
    16.     CloseNet #201
    17.     '机器人作为客户端,打开端口
    18.     OpenNet #201 As Client '从
    19.     '等待连接
    20.     WaitNet #201
    21.     '连接成功显示
    22.     Print "TCP 连接成功"
    23.     Print #201, " 连接成功"
    24.     Print "ReceiveData:" + ReceiveData$
    25.     receive_again:		'再次收发数据
    26.     Print "wait ReceiveData";
    27.     Print "----------------------------"
    28.     Do
    29.     	If ChkNet(201) < 0 Then '检查端口状态(>0时)
    30.     		Print "tcp_off,try_again"
    31.     		GoTo retry_tcpip_201
    32.     	ElseIf ChkNet(201) > 0 Then
    33.     		Read #201, ReceiveData$, ChkNet(201)
    34.     		Print "ReceiveData$ = ", ReceiveData$
    35.     		Exit Do
    36.     	EndIf
    37.     Loop
    38.     
    39.     ParseStr ReceiveData$, data$(), ","  '如果要发送code,message
    40. 	No$ = data$(1)  'code=1				 '格式如下:任意数据;code;message
    41. 	DeviceId$ = data$(2)  'message=1
    42. 	FlowId$ = data$(3)
    43. 	Msg$ = data$(4)
    44. 	MsgTime$ = data$(5)
    45. '	c = Val(data$(3))
    46. 	
    47. 	Print "解析后的值:" + No$ + "," + DeviceId$ + "," + FlowId$ + "," + Msg$ + "," + MsgTime$
    48. 	Call getNoVal
    49. 	Call getFlowIdVal
    50. 	Call getDeviceIdVal
    51. 	Print "FlowIdVal:" + FlowIdVal$
    52. 	Print #201, "ResponseNo:" + NoVal$ + ",DeviceId:" + DeviceIdVal$ + ",FlowId:" + FlowIdVal$ + ",IsSucceed:1" '回复上位机指令接收成功
    53. 	'Print "len:" + Str$(Len(No$))
    54. 	'Print "index:" + Str$(InStr(No$, "No:"))
    55. 	'Print "noVal:" + Mid$(No$, InStr(No$, ":") + 1, Len(No$) - InStr(No$, ":"))
    56. 	Call doWork  '调用动作指令
    57. 	
    58. 	If SendData$ <> "" Then  '通过调用,获得数据,机械手反馈运动状态
    59. 		Print SendData$
    60. 		Print #201, SendData$
    61. 		SendData$ = "" 'reset
    62. 	EndIf
    63. 	GoTo receive_again
    64. Fend
    65. '做工作，根据上位机发送的指令执行相应动作
    66. Function doWork
    67. 	Print "执行doWork"
    68. 	String message$
    69. 	Boolean isOk
    70. 	isOk = False
    71. 	'回原点=0,取料1=1(p1),取料2=2(p2),进料扫码=3(p3),焊接准备=4(p40),焊接平台放料=5(p5),焊接平台取料=6(p6),平台旋转位=7(p7),旋转(电爪)=8(p8),
    72. 	'焊接=9,出料扫码=10,出料1=11(p11),出料2=12(p12),NG出料1=13(p13),NG出料2=14(p14)
    73. 	'CP运动命令  Move,Arc, Arc3
    74. 	'PTP运动命令 Jump,Go
    75. 	'----------------------------
    76. 	'PTP运动命令的速度设定
    77. 	'PTP运动速度的设定
    78. 	'格式：Speed s, [a, b]
    79. 	's : 速度设定值（1～100%）
    80. 	'a: 第3轴上升的速度设定值（1～100%） （可省略）
    81.  	'b: 第3轴下降的速度设定值（1～100%） （可省略）
    82. 	'使用示例
    83. 	'Speed 80
    84.     'Speed 100, 80, 50
    85. 	'PTP动作的加减速度的设定
    86. 	'格 式： Accel a, b, [c, d, e, f]
    87. 	'a : 加速设定值（1～100%）
    88.  	'b: 减速设定值（1～100%）
    89. 	'c,d : 第3轴上升的加减速设定值（1～100%） （可省略）
    90. 	'e,f : 第3轴下降的加减速设定值（1～100%） （可省略）
    91. 	'使用示例： Accel 80, 80
    92. 	'Accel 100, 100, 20, 80, 80, 20
    93. 	'------------------
    94. 	'CP运动命令  
    95. 	'SpeedS CP动作的速度的设定      SpeedS 500    速度设定值：1～1120 mm/s
    96. 	'AccelS CP动作的加减速度的设定  AccelS 2000   加减速度设定值 : 1～5000 mm/s2
    97. 	
    98. 	If FlowIdVal$ = "0" Then '通过上位机判断,机械手执行
    99. 			'相应的动作流程	回原点=0		
    100. 			'Jump P20 LimZ 0 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置0=最高位
    101. 			
    102. 		isOk = True
    103. 	ElseIf FlowIdVal$ = "1" Then '通过上位机判断,机械手执行
    104. 			'相应的动作流程	移动到取料1的位置		
    105. 			'Jump P1 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    106. 			
    107. 		isOk = True
    108. 	ElseIf FlowIdVal$ = "2" Then
    109. 			'相应的动作流程	移动到取料2的位置		
    110. 			'Jump P2 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    111. 		isOk = True
    112. 	ElseIf FlowIdVal$ = "3" Then
    113. 			'相应的动作流程	移动到[扫码]的位置
    114. 			'Jump P3 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    115. 		isOk = True
    116. 	ElseIf FlowIdVal$ = "4" Then
    117. 			'相应的动作流程	移动到[焊接准备]的位置
    118. 			'Pass 用于移动机械臂并使其穿过指定点数据(位置)附近。不穿过指定点数据(位置)自身。可通过使用Pass 命令来避开障碍物。
    119. 			Pass P40, P41, P42
    120. 		isOk = True
    121. 	ElseIf FlowIdVal$ = "5" Then
    122. 			'相应的动作流程	移动到[平台放料]的位置
    123. 			Go P5  '全轴同时的PTP动作
    124. 		isOk = True
    125. 	ElseIf FlowIdVal$ = "6" Then
    126. 			'相应的动作流程	移动到[平台取料]的位置
    127. 			Go P6
    128. 		isOk = True
    129. 	ElseIf FlowIdVal$ = "7" Then
    130. 			'相应的动作流程	移动到[平台旋转位]的位置
    131. 			Go P7
    132. 		isOk = True
    133. 	ElseIf FlowIdVal$ = "8" Then
    134. 			'相应的动作流程	移动到[旋转]的位置
    135. 			'Go P7 +U(180) '+U Z轴旋转
    136. 		isOk = True
    137. 	ElseIf FlowIdVal$ = "10" Then
    138. 			'相应的动作流程	移动到[出料扫码]的位置
    139. 			'Jump P10 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    140. 		isOk = True
    141. 	ElseIf FlowIdVal$ = "11" Then
    142. 			'相应的动作流程	移动到[出料1]的位置
    143. 			'Jump P11 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    144. 		isOk = True
    145. 		'message$ = "失败测试"
    146. 	ElseIf FlowIdVal$ = "12" Then
    147. 			'相应的动作流程	移动到[出料2]的位置
    148. 			'Jump P12 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    149. 		isOk = True
    150. 	ElseIf FlowIdVal$ = "13" Then
    151. 			'相应的动作流程	移动到[NG出料1]的位置
    152. 			'Jump P13 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    153. 		isOk = True
    154. 	ElseIf FlowIdVal$ = "14" Then
    155. 			'相应的动作流程	移动到[NG出料1]的位置
    156. 			'Jump P14 LimZ -100 'Jump 门形动作,LimZ以限定第三轴目标坐标Z上移的位置-100
    157. 		isOk = True
    158. 	EndIf
    159. 	If isOk Then
    160. 		SendData$ = "ResponseNo:" + NoVal$ + ",DeviceId:" + DeviceIdVal$ + ",FlowId:" + FlowIdVal$ + ",Status:1"  '操作完成后回复上位机的数据，Status=表示处理成功，0表示处理失败
    161. 	Else
    162. 		SendData$ = "ResponseNo:" + NoVal$ + ",DeviceId:" + DeviceIdVal$ + ",FlowId:" + FlowIdVal$ + ",Status:0," + "Msg:" + message$ '操作完成后回复上位机的数据，Status=表示处理成功，0表示处理失败
    163. 	EndIf
    164. Fend
    165. Function getNoVal
    166. 	NoVal$ = Mid$(No$, InStr(No$, ":") + 1, Len(No$) - InStr(No$, ":"))
    167. Fend
    168. '获取FlowId的值
    169. Function getFlowIdVal
    170. 	FlowIdVal$ = Mid$(FlowId$, InStr(FlowId$, ":") + 1, Len(FlowId$) - InStr(FlowId$, ":"))
    171. Fend
    172. '获取DeviceId的值
    173. Function getDeviceIdVal
    174. 	DeviceIdVal$ = Mid$(DeviceId$, InStr(DeviceId$, ":") + 1, Len(DeviceId$) - InStr(DeviceId$, ":"))
    175. Fend
    176. Function init_constantrainit '常变量初始化
    177.  Off 519
    178.  On 520
    179.  Off 521
    180.  Off 522
    181.  Off 523
    182.  Off 524
    183.  Off 525
    184.  Off 526
    185.  Off 527
    186.  Off 528
    187.  Off 529
    188. Fend
    189. Function init_robotinit '机械手初始化
    190. 	If Motor = Off Then
    191. 		Motor On
    192.     EndIf
    193.    
    194. 	If SFree(1) Or SFree(2) Or SFree(3) Or SFree(4) Then SLock
    195. 	'If SFree(1) 0r SFree(2) 0r SFree(3) 0r SFree(4) Then SLock
    196. 	Power High
    197. 	Speed 20 'GO ,JUMP ,最大100
    198. 	Accel 20, 20
    199.     SpeedS 100; 'ARC ,MOVE2000
    200. 	
    201.  	AccelS 100.100
    202. 	Call huanshou
    203.  
    204. 	On 521   '回原完成器人回原请求
    205. 	Off 530 '机器人回原请求
    206. 	Pause
    207.  
    208. Fend
    209.  
    210. Function huanshou
    211. 	If CZ(Here) < 0 Then
    212. 		Move Here :Z(0) 'Z轴回到最高位
    213. 	EndIf
    214. 	'--------一象限---------------'
    215. 	If CZ(Here) < 0 And CY(Here) < -90 Then
    216. 		If Hand(Here) = Lefty Then
    217. 			Error 8000
    218. 		Else
    219. 			Jump P110
    220. 			Move P111
    221. 			Move P112
    222. 		EndIf
    223. 	EndIf
    224. 	'--------二象限---------------'
    225. 	If CY(Here) < 369.102 And CX(Here) > 0 Then
    226. 		If Hand(Here) = Lefty Then
    227. 			Move P100
    228. 			Move P99
    229. 			Move P97
    230. 		Else
    231. 			Move P101
    232. 			Move P98
    233. 		EndIf
    234. 	EndIf
    235. 	'--------三象限---------------'
    236. 	If CX(Here) > 0 And CY(Here) < 369.102 Then
    237. 		If Hand(Here) = Lefty Then
    238. 			Move P120
    239. 		Else
    240. 			Move P121
    241. 		EndIf
    242. 	EndIf
    243. Fend
    244. Function initprg '初始化
    245. 	Print Time$ + "机器人初始化中"
    246. 	Call init_constantrainit
    247.  	'常变量初始化机械手初始化
    249. 	Call init_robotinit
    251.  	Print '机器人初始化完成
    252. Fend

  • 相关阅读:
    Vue 安装与创建第一Docker的项目
    TB-RK1808M0最新固件烧录和驱动更新
    Unreal引擎自带的有用的工具函数，持续更新中
    《向量数据库指南》——向量数据库是小题大作的方案？
    如何将图片识别为可编辑的Word文件
    Linux系统编程04
    计算机网络：物理层
    跨域请求方案整理实践
    C++基础——前后置++--，流插入提取运算符重载函数
    Java IO---File类
  • 原文地址：https://blog.csdn.net/cjh16606260986/article/details/136229421