C# WPF上位机实现和下位机TCP通讯-低调大师

C# WPF上位机实现和下位机TCP通讯

2019-03-19 427

C# WPF上位机实现和下位机TCP通讯
下位机使用北京大华程控电源DH1766-1，上位机使用WPF。实现了电压电流实时采集，曲线显示。上午在公司调试成功，手头没有程控电源，使用TCP服务端模拟。昨天写的TCP服务端正好排上用场。

界面如下：

服务端

服务端实在上篇基础上实现的。需要做如下更改：

复制代码
while (true)

                      {
                          try
                          {
                              byte[] bufferDate = new byte[1024];
                              int realLen = pSocket.Receive(bufferDate);
                              if (realLen <= 0)
                              {
                                  this.Invoke(addTextDelegate, pSocket.RemoteEndPoint.ToString() + "退出\r\n");
                                  socketList.Remove(pSocket);
                                  //客户端退出的时候会发送一个空字节
                                  pSocket.Shutdown(SocketShutdown.Both);
                                  pSocket.Close();
                                  return;
                              }
                              string receiveStr = Encoding.Default.GetString(bufferDate, 0, realLen);
                              switch (receiveStr)
                              {
                                  case "MEAS:VOLTage:ALL?\n":
                                      proxSocket.Send(Encoding.Default.GetBytes(r.Next(16,25).ToString()+ ","+r.Next(16, 25).ToString()+","+ r.Next(16, 25).ToString()));
                                      break;
                                  case "MEAS:CURR:ALL?\n":
                                      proxSocket.Send(Encoding.Default.GetBytes(r.Next(2, 5).ToString() + "," + r.Next(2, 5).ToString() + "," + r.Next(2, 5).ToString()));
                                      break;
                                  default:
                                      break;
                              }
                              this.Invoke(addTextDelegate, receiveStr + "from" + pSocket.RemoteEndPoint.ToString() + "\r\n");
                          }
                          catch (Exception ex)
                          {
                              this.Invoke(addTextDelegate, pSocket.RemoteEndPoint.ToString() + "异常退出\r\n");
                              socketList.Remove(pSocket);
                              pSocket.Shutdown(SocketShutdown.Both);
                              pSocket.Close();
                              return;
                          }
                      }

复制代码
在While循环中加入：

switch (receiveStr)
{
　　case "MEAS:VOLTage:ALL?n":
　　proxSocket.Send(Encoding.Default.GetBytes(r.Next(16,25).ToString()+ ","+r.Next(16, 25).ToString()+","+ r.Next(16, 25).ToString()));
　　break;
　　case "MEAS:CURR:ALL?n":
　　proxSocket.Send(Encoding.Default.GetBytes(r.Next(2, 5).ToString() + "," + r.Next(2, 5).ToString() + "," + r.Next(2, 5).ToString()));
　　break;
　　default:
　　break;

}

模拟电源，当收到电压查询时，发送16~25中随机数，由于电源是三个通道的，因此发送三个随机数，用逗号隔开。同样收到电流查询，发送2~5之间的随机数。

完整的客户端源码：

复制代码
public partial class Form1 : Form

{
    public Form1()
    {
        InitializeComponent();
        addTextDelegate = new AddTextDelegate(AddText);
    }
    private AddTextDelegate addTextDelegate;
    private List<Socket> socketList = new List<Socket>();

    public delegate void AddTextDelegate(string text);
    private void AddText(string text)
    {
        txtLog.Text += text;
    }

    Random r = new Random();

    private void btnStart_Click(object sender, EventArgs e)
    {
        //参数：寻址方式    传输数据方式  通信协议
        Socket socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

        IPAddress iPAddress = IPAddress.Parse(txtIP.Text);

        //创建EndPoint
        IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, int.Parse(txtPort.Text));

        //绑定端口
        socket.Bind(iPEndPoint);

        //开启侦听
        socket.Listen(10);

        txtLog.Text += "服务启动开启侦听……\r\n";

        Thread thread = new Thread((s) =>
          {
              Socket serSocket = (Socket)s;
              while (true)//不断接收客户端连接
              {
                  this.Invoke(addTextDelegate, "服务正在等待客户端连接……\r\n");

                  //开始接收客户端的连接
                  //阻塞当前线程，等待客户端连接
                  //客户端连接上之后，服务端自动生成一个socket和连接的客端通信
                  Socket proxSocket = serSocket.Accept();

                  this.Invoke(addTextDelegate, "客户端连接成功！\r\n" + proxSocket.RemoteEndPoint.ToString());

                  //proxSocket.Send(Encoding.Default.GetBytes("连接成功！"));

                  socketList.Add(proxSocket);//当前通信的socket放到集合中

                  new Thread(p =>
                  {
                      Socket pSocket = (Socket)p;
                      while (true)
                      {
                          try
                          {
                              byte[] bufferDate = new byte[1024];
                              int realLen = pSocket.Receive(bufferDate);

                              if (realLen <= 0)
                              {
                                  this.Invoke(addTextDelegate, pSocket.RemoteEndPoint.ToString() + "退出\r\n");

                                  socketList.Remove(pSocket);
                                  //客户端退出的时候会发送一个空字节
                                  pSocket.Shutdown(SocketShutdown.Both);
                                  pSocket.Close();

                                  return;
                              }
                              string receiveStr = Encoding.Default.GetString(bufferDate, 0, realLen);
                              switch (receiveStr)
                              {
                                  case "MEAS:VOLTage:ALL?\n":
                                      proxSocket.Send(Encoding.Default.GetBytes(r.Next(16,25).ToString()+ ","+r.Next(16, 25).ToString()+","+ r.Next(16, 25).ToString()));
                                      break;
                                  case "MEAS:CURR:ALL?\n":
                                      proxSocket.Send(Encoding.Default.GetBytes(r.Next(2, 5).ToString() + "," + r.Next(2, 5).ToString() + "," + r.Next(2, 5).ToString()));
                                      break;
                                  default:
                                      break;
                              }
                              this.Invoke(addTextDelegate, receiveStr + "from" + pSocket.RemoteEndPoint.ToString() + "\r\n");
                          }
                          catch (Exception ex)
                          {
                              this.Invoke(addTextDelegate, pSocket.RemoteEndPoint.ToString() + "异常退出\r\n");

                              socketList.Remove(pSocket);
                              pSocket.Shutdown(SocketShutdown.Both);
                              pSocket.Close();
                              return;
                          }
                      }
                  })
                  { IsBackground = true }.Start(proxSocket);
              }
          });
        thread.IsBackground = true;
        thread.Start(socket);
       
    }

    private void btnSend_Click(object sender, EventArgs e)
    {
        string str = txtSend.Text;
        byte[] data = Encoding.Default.GetBytes(str);
        foreach (var socket in socketList)
        {
            if (socket != null && socket.Connected)
            {
                socket.Send(data);
            }
        }
    }
}

复制代码
上位机实现客户端功能。具体如下：

1、字段和属性

public readonly IPEndPoint TagetIPEP;
public bool IsConnected { get; set; } = false;
private Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { /ReceiveTimeout=1000,SendTimeout=1000/};
private Thread recListenThread;
public string ReceiveStr { get; set; }
public byte[] ReceiveByte { get; set; }
TagetIPEP是服务器地址和端口。
IsConnected是连接的状态，这个比较重要，在发送和接收时，都要更加IsConnected进行，并更新IsConnected。
Socket用于和客户端通讯。
recListenThread是监听客户端消息的线程。
ReceiveStr和ReceiveByte用来存储客户端发来的消息。
2、方法函数
连接方法：
复制代码
public bool Connect()

    {
        try
        {
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
            {
                //ReceiveTimeout = 1000,
                //SendTimeout=1000
            };

            //IAsyncResult connResult = socket.BeginConnect(TagetIPEP.Address, TagetIPEP.Port, null, null);
            //connResult.AsyncWaitHandle.WaitOne(5000, true);
            //if (connResult.IsCompleted)
            //{
            socket.Connect(TagetIPEP.Address, TagetIPEP.Port);
            IsConnected = true;
                //开启接收监听

                recListenThread = new Thread(() =>
                {
                    while (true)
                    {
                        try
                        {
                            ReceiveByte = new byte[1024];
                            int realLen = socket.Receive(ReceiveByte);
                            ReceiveStr = Encoding.Default.GetString(ReceiveByte, 0, realLen);
                            ReceiveEvent();
                            if (realLen <= 0)
                            {
                                if (socket != null && socket.Connected)
                                {
                                    //服务器退出
                                    IsConnected = false;
                                    Log.WriteLog("服务器退出！");
                                    socket.Shutdown(SocketShutdown.Both);
                                    socket.Close();
                                    MessageBox.Show("连接断开！");
                                }
                                return;
                            }
                        }
                        catch (Exception ex)
                        {
                            if (socket != null && socket.Connected)
                            {
                                IsConnected = false;
                                Log.WriteLog("服务器异常退出！", ex);
                                socket.Shutdown(SocketShutdown.Both);
                                socket.Close();
                            }
                            return;
                        }
                    }
                })
                { IsBackground = true };
                recListenThread.Start();
                return true;
            //}

        }
        catch (Exception ex)
        {
            Log.WriteLog(TagetIPEP.Address + "连接失败", ex);
        }
        return false;
    }

复制代码
连接函数返回值为bool类型，根据返回值判断连接是否成功连接。这里每次连接都实例化了一个socket，因为在执行socket.close()后，重新打开会失败，而断线重连会经常用到，没有找到更好的方法，干脆重新实例化socket。连接成功后，开启监听服务端消息的线程。这里使用了一个ReceiveEvent()事件，在接收到消息时会触发这个事件，刷新UI界面。

发送方法：

复制代码
public bool Send(string msg)

    {
        byte[] sendMsg = Encoding.Default.GetBytes(msg);
        if (sendMsg.Length > 0&&IsConnected)
        {
            if (socket != null && socket.Connected)
            {
                try
                {
                    socket.Send(sendMsg);
                    return true;
                }
                catch (Exception ex)
                {
                    IsConnected = false;
                    Log.WriteLog("发送数据失败,目标地址" + TagetIPEP.Address, ex);
                }
            }
        }

        return false;

    }

复制代码
关闭方法：

复制代码

public void Close()
    {
        if (socket != null && socket.Connected)
        {
            IsConnected = false;
            recListenThread.Abort();
            Log.WriteLog("关闭连接！");
            socket.Shutdown(SocketShutdown.Both);
            socket.Close();
        }
    }

复制代码
在出现异常时调用

消息接收事件：

public event Action ReceiveEvent;

每次接收消息时触发，获取属性ReceiveStr和ReceiveByte的值，刷新UI界面。

完整代码：

复制代码
public class TCPClient

{
    public TCPClient(/*IPEndPoint localIPEP,*/IPEndPoint targetIPEP)
    {
        //socket.Bind(localIPEP);
        TagetIPEP = targetIPEP;
       
    }

    public readonly IPEndPoint TagetIPEP;

    public bool IsConnected { get; set; } = false;

    private Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { /*ReceiveTimeout=1000,SendTimeout=1000*/};

    public bool Connect()
    {
        try
        {
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
            {
                //ReceiveTimeout = 1000,
                //SendTimeout=1000
            };

            //IAsyncResult connResult = socket.BeginConnect(TagetIPEP.Address, TagetIPEP.Port, null, null);
            //connResult.AsyncWaitHandle.WaitOne(5000, true);
            //if (connResult.IsCompleted)
            //{
            socket.Connect(TagetIPEP.Address, TagetIPEP.Port);
            IsConnected = true;
                //开启接收监听

                recListenThread = new Thread(() =>
                {
                    while (true)
                    {
                        try
                        {
                            ReceiveByte = new byte[1024];
                            int realLen = socket.Receive(ReceiveByte);
                            ReceiveStr = Encoding.Default.GetString(ReceiveByte, 0, realLen);
                            ReceiveEvent();
                            if (realLen <= 0)
                            {
                                if (socket != null && socket.Connected)
                                {
                                    //服务器退出
                                    IsConnected = false;
                                    Log.WriteLog("服务器退出！");
                                    socket.Shutdown(SocketShutdown.Both);
                                    socket.Close();
                                    MessageBox.Show("连接断开！");
                                }
                                return;
                            }
                        }
                        catch (Exception ex)
                        {
                            if (socket != null && socket.Connected)
                            {
                                IsConnected = false;
                                Log.WriteLog("服务器异常退出！", ex);
                                socket.Shutdown(SocketShutdown.Both);
                                socket.Close();
                            }
                            return;
                        }
                    }
                })
                { IsBackground = true };
                recListenThread.Start();
                return true;
            //}

        }
        catch (Exception ex)
        {
            Log.WriteLog(TagetIPEP.Address + "连接失败", ex);
        }
        return false;
    }

    public bool Send(string msg)
    {
        byte[] sendMsg = Encoding.Default.GetBytes(msg);
        if (sendMsg.Length > 0&&IsConnected)
        {
            if (socket != null && socket.Connected)
            {
                try
                {
                    socket.Send(sendMsg);
                    return true;
                }
                catch (Exception ex)
                {
                    IsConnected = false;
                    Log.WriteLog("发送数据失败,目标地址" + TagetIPEP.Address, ex);
                }
            }
        }

        return false;

    }

    public event Action ReceiveEvent;

    public string ReceiveStr { get; set; }

    public byte[] ReceiveByte { get; set; }

    public void Close()
    {
        if (socket != null && socket.Connected)
        {
            IsConnected = false;
            recListenThread.Abort();
            Log.WriteLog("关闭连接！");
            socket.Shutdown(SocketShutdown.Both);
            socket.Close();
        }
    }

    private Thread recListenThread;

}

复制代码
前台调用，声明Timer定时器，每个一秒触发一次。触发事件如下：

复制代码

    private string flag = "";
    private void QueryTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        Now = DateTime.Now;

        if (!tcp.Send("MEAS:VOLTage:ALL?\n"))
        {
            queryTimer.Enabled = false;
            StartContent = "开始";
            ConnContent = "连接";
            tcp.IsConnected = false;
            MessageBox.Show("查询失败！");
            return;
        }
        flag = "V";
        Thread.Sleep(50);

        if (!tcp.Send("MEAS:CURR:ALL?\n"))
        {
            queryTimer.Enabled = false;
            StartContent = "开始";
            ConnContent = "连接";
            tcp.IsConnected = false;
            MessageBox.Show("查询失败！");
            return;
        }
        flag = "C";

        #region 测试
        //angle += 18;
        //if (angle > 360)
        //{
        //    angle = 18;
        //}

        #endregion

    }

复制代码
刷新UI界面的事件如下：

复制代码
private void Tcp_ReceiveEvent()

    {
        Task.Run(() =>
        {
            Application.Current.Dispatcher.Invoke(() =>
            {
                RemoteIP = tcp.TagetIPEP.ToString();
                switch (flag)
                {
                    case "V":
                        VoltValue = Math.Round(Convert.ToDouble(tcp.ReceiveStr.Split(',')[0]), 3);
                        break;
                    case "C":
                        CurrentValue = Math.Round(Convert.ToDouble(tcp.ReceiveStr.Split(',')[0]), 3);
                        break;
                    default:
                        break;
                }

                #region 测试
                //VoltValue = Math.Round(Math.Sin((angle) * pi / 180) * 16 + 16, 3);
                //CurrentValue = Math.Round(Math.Sin((angle) * pi / 180) * 2.5 + 2.5, 3);
                #endregion

                VoltValues.Add(VoltValue);
                CurrentValues.Add(CurrentValue);

                if (VoltValues.Count > 30)
                {
                    VoltValues.RemoveAt(0);
                    CurrentValues.RemoveAt(0);
                }
            });
        });
    }

复制代码
原文地址https://www.cnblogs.com/Samberger/p/10561243.html

微信关注我们

原文链接：https://yq.aliyun.com/articles/694384

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

关于python中函数的思考

基本语言特性函数是几乎任何程序语言都支持的基本语言特性。然而，不同的语言对函数的看法却是不同的，这不仅导致了函数在语言中的地位，也产生出了不同的编程风格。在scheme语言中，函数与普通数据别无二致，所以自然而然的将函数作为第一类对象，同时scheme更强函数式编程和函数递归，以追求计算的本质。在java中，函数与普通数据是区分开的，即函数不能直接被传递，只能被包裹到类中再通过实例对象被传递，高度的强调面向对象编程。在python中，函数也被当做第一类对象，支持少量的函数式编程风格，但依然以面向对象为主。关于第一类对象的思考所谓第一类对象，就是指这样的一种对象：可以赋值给变量可以传参给函数可以从函数中传出第一句话其实已经包含了后两句，所以它们可以概括为一句话：类似23，'hello'，True，instance这种可以赋值给变量的对象。首先，我觉得编程语言应该将函数对象作为第一类对象，这应该成为编程语言的标准特性，函数对象和数字23没有什么区别，它们本质上都是数据，所以函数对象可以和普通数据一样被各种操作。但在java中，函数对象被看成与普通数据是不同的，这一点我觉得并...

2019-03-19

702

C，java，Python，这些名字背后的江湖！还记得高中的时候，有一次我们计算机老师问我们班要不要去参加市里面的C语言比赛，当时还小的我对编程世界压根就一片空白。那时候我就想啊，为什么是C语言，那么A语言，B语言或者是D语言又是什么呢？后来就到了大学，学习了计算机知识后才知道C语言是什么东西。但是，你有没有过一瞬间感到奇怪，为什么它就叫做C语言，Java就叫java而不是叫J语言？今天我就带大家了解一下编程语言名字背后的故事吧~ Javajava logo 今天Java技术栈运用已经如此广泛，Web，Android，大数据等等。但你可能不知道，Java最初是为交互式电视而设计的，而且最开始它的名字也不是叫Java，而是叫Oak。但是后面发现，不能使用Oak这个名字，因为它已经被注册了。为了这个事，Sun公司特地组织了一次头脑风暴。我们都知道，起名字这种事情，一个人来起最容易，但每增加一个人，起名难度呈指数上升。而当时参与起名的人得有十来个。大家广泛讨论，胡思乱想，最终产生了几十个名字，而经过一番评选讨论，名字个数缩小到十几个，名单上的名字除了Java外，还有Silk，Lyric，...

2019-03-20

601

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。