C#实现调试软件通过网线连接修改控制器的IP设定

已于 2024-05-31 13:44:31 修改
阅读量432 收藏 5
点赞数 15
分类专栏： C# 文章标签： tcp/ip 网络协议 网络
于 2024-03-25 15:01:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41184334/article/details/137012128
版权

项目要求：实现看门狗软件与外部调试软件在不知道对方信息的状态下建立可靠的通信。

思路：双方定义一个共同的通信端口号，调试软件定义为发送端，通过广播的方式发送指令。

看门狗定义为接收端，获取需要监控的网口，对每个网口定义UDP通信服务器，接收发送端发来的命令，

调试软件定义为发送端，定义UDP通信客户端，绑定已知的网口。

为保证数据的完整性我们需要定义一下报文格式，我使用的是CRC16_IBM效验。外部调试软件主动发送请求另一端电脑的网络信息，监控回复，解析回复信息得到另一端电脑的IP信息，然后修改本地IP信息与另一端电脑在同一网段，这样就可以建立TCP通信了。

看门狗作为接收端，实时监控来自调试软件的（需要注意的是我对本地的电脑以太网进行了遍历，创建UDP客户端数组，便于确认是哪个网口连接网线收到了广播信息，可以定位到想要修改的网口），单例模式实现如下：

    public class UdpClient_Cmd
    {
        static UdpClient_Cmd() { }
        private UdpClient_Cmd() { }

        static readonly UdpClient_Cmd instance = new UdpClient_Cmd();
        public static UdpClient_Cmd Instance
        {
            get
            {
                return instance;
            }
        }
        public string broadcastMsg = "This is UDP broadcast";



        Thread sendThread = null;
        bool sendThreadFlag = false;
        int BroadcastPort = 40001;
        private void BroadcastLocalIp()
        {
            //定义广播内容
            byte[] sendBytes = Encoding.Default.GetBytes(broadcastMsg);
            while (sendThreadFlag)
            {
                using (UdpClient sendClient = new UdpClient())
                {
                    sendClient.Send(sendBytes, sendBytes.Length, new IPEndPoint(IPAddress.Broadcast, BroadcastPort));
                }

                Thread.Sleep(1000);
            }

        }

        /// <summary>
        /// 开始向外部广播信息
        /// </summary>
        public void StartSendBroadcast(int broadcastport)
        {
            BroadcastPort = broadcastport;
            sendThreadFlag = true;
            sendThread = new Thread(BroadcastLocalIp);
            sendThread.IsBackground = true;
            sendThread.Start();
            LogHelper.Info("UDP通信广播服务线程启动完成！");
        }

        /// <summary>
        /// 停止向外部广播信息
        /// </summary>
        public void StopSendBroadcast()
        {
            sendThreadFlag = false;
            if (sendThread != null)
                sendThread.Abort();

            if (sendThread != null)
            {
                while ((sendThread.ThreadState != System.Threading.ThreadState.Stopped) && (sendThread.ThreadState != System.Threading.ThreadState.Aborted))
                {
                    Thread.Sleep(10);
                }
            }
            sendThread = null;
            LogHelper.Info("UDP通信广播服务线程停止！");
        }


        Thread receThread = null;
        bool recvThreadflag = false;
        int BindPort = 40000;
        private async void RecvThread()
        {

            // 接收广播消息
            try
            {
                while (recvThreadflag)
                {
                    // 定义监听的网口IP地址和端口号
                    List<string> listenInterfaces = IPProvider.getLocalNetworks();

                    if (listenInterfaces.Count > 0)
                    {
                        // 创建 UDP 客户端套接字数组
                        UdpClient[] udpClients = new UdpClient[listenInterfaces.Count];

                        // 创建并绑定 UDP 客户端套接字到每个网口
                        for (int i = 0; i < listenInterfaces.Count; i++)
                        {
                            IPAddress listenIP = IPAddress.Parse(listenInterfaces[i]);
                            udpClients[i] = new UdpClient();
                            udpClients[i].Client.Bind(new IPEndPoint(listenIP, BindPort));
                        }

                        // 异步接收数据报文
                        Task<UdpReceiveResult>[] receiveTasks = new Task<UdpReceiveResult>[udpClients.Length];
                        for (int i = 0; i < udpClients.Length; i++)
                        {
                            receiveTasks[i] = udpClients[i].ReceiveAsync();
                        }

                        // 等待任意一个UDP套接字接收到数据报文
                        Task<UdpReceiveResult> completedTask = await Task.WhenAny(receiveTasks);
                        // 获取完成的任务所对应的接收结果
                        UdpReceiveResult receiveResult = completedTask.Result;
                        //IPAddress localIPAddress = ((IPEndPoint)receiveResult.RemoteEndPoint).Address;

                        if (CommunicateHelper.Check_ReceData(receiveResult.Buffer))
                        {
                            byte addressYype = receiveResult.Buffer[2];
                            byte funType = receiveResult.Buffer[3];

                            if (addressYype == (byte)AddressCode.WatchDog)
                            {
                                // 获取主设备的IP地址和端口号
                                IPAddress mainDeviceIPAddress = ((IPEndPoint)receiveResult.RemoteEndPoint).Address;
                                int mainDevicePort = ((IPEndPoint)receiveResult.RemoteEndPoint).Port;
                                IPAddress localIPAddress = ((IPEndPoint)udpClients[Array.IndexOf(receiveTasks, completedTask)].Client.LocalEndPoint).Address;
                                byte[] receivedData = receiveResult.Buffer.Skip(8).Take(receiveResult.Buffer.Length - 12).ToArray();
                                byte[] sendData = null;

                                switch (funType)
                                {
                                    case (byte)FunctionCode.Broadcast:
                                        sendData = CommunicateHelper.Gen_SendData_Cmd(AddressCode.Debuger, FunctionCode.Broadcast, Encoding.Default.GetBytes(localIPAddress.ToString()));
                                        // 使用UDP单播向主设备发送回复消息
                                        using (UdpClient replyClient = new UdpClient())
                                        {
                                            replyClient.Send(sendData, sendData.Length, mainDeviceIPAddress.ToString(), mainDevicePort);
                                        }
                                        break;
                                    case (byte)FunctionCode.getIPAddress:
                                        var networkInterface = IPProvider.GetNetworkInterface(localIPAddress);
                                        string ret1 = IPProvider.GetIpv4Adress(networkInterface);
                                        string ret2 = IPProvider.GetSubnetMask(networkInterface);
                                        string ret3 = IPProvider.GetDefaultGateway(networkInterface);
                                        string replayString = String.Format("{0},{1},{2}", ret1, ret2, ret3);
                                        sendData = CommunicateHelper.Gen_SendData_Cmd(AddressCode.Debuger, FunctionCode.getIPAddress, Encoding.Default.GetBytes(replayString));
                                        using (UdpClient replyClient = new UdpClient())// 使用UDP单播向主设备发送回复消息
                                        {
                                            replyClient.Send(sendData, sendData.Length, mainDeviceIPAddress.ToString(), mainDevicePort);
                                        }

                                        break;

                                    case (byte)FunctionCode.setIPAddress:
                                        sendData = CommunicateHelper.Gen_SendData_Cmd(AddressCode.Debuger, FunctionCode.setIPAddress, receivedData);
                                        using (UdpClient replyClient = new UdpClient())// 使用UDP单播向主设备发送回复消息
                                        {
                                            replyClient.Send(sendData, sendData.Length, mainDeviceIPAddress.ToString(), mainDevicePort);
                                        }
                                        var ipsArr = Encoding.Default.GetString(receivedData).Split(',');
                                        IPProvider.ModifyIPAddress(localIPAddress.ToString(), ipsArr[0], ipsArr[1], ipsArr[2]);
                                        Thread.Sleep(6000);
                                        break;

                                    default:
                                        sendData = CommunicateHelper.Gen_SendData_Cmd(AddressCode.Debuger, FunctionCode.setIPAddress, Encoding.Default.GetBytes("FunctionCode指令不存在！"));
                                        using (UdpClient replyClient = new UdpClient())// 使用UDP单播向主设备发送回复消息
                                        {
                                            replyClient.Send(sendData, sendData.Length, mainDeviceIPAddress.ToString(), mainDevicePort);
                                        }
                                        LogHelper.Info("未定义的UDP通信格式，功能码不存在或不支持！");
                                        break;
                                }

                            }
                        }

                        // 关闭 UDP 客户端套接字
                        foreach (var udpClient in udpClients)
                        {
                            udpClient.Close();
                        }

                    }
                    else
                    {
                        Thread.Sleep(1000);
                    }

                }
            }
            catch (Exception ex)
            {
                LogHelper.Info($"UDPClient Exception: {ex.Message}");
            }


        }

        /// <summary>
        /// 开始监听外部广播信息
        /// </summary>
        public void StartReceiveBroadcast(int bindport)
        {
            BindPort = bindport;
            recvThreadflag = true;
            receThread = new Thread(new ThreadStart(RecvThread));
            receThread.IsBackground = true;
            receThread.Start();
            LogHelper.Info("UDP通信服务器线程启动完成！");
        }

        /// <summary>
        /// 停止监听外部广播信息
        /// </summary>
        public void StopReceiveBroadcast()
        {

            recvThreadflag = false;
            if (receThread != null)
                receThread.Abort();

            Thread.Sleep(50);

            if (receThread != null)
            {
                while ((receThread.ThreadState != System.Threading.ThreadState.Stopped) && (receThread.ThreadState != System.Threading.ThreadState.Aborted))
                {
                    Thread.Sleep(10);
                }
            }

            receThread = null;
            LogHelper.Info("UDP通信服务器线程停止！");
        }


    }

调试软作为发送端，这样可以控制广播的使用，模式实现看门狗软件与外部调试软件在不知道对方信息的状态下建立可靠的通信，单例模式实现代码如下：

    public class UdpClientHelper
    {

        static UdpClientHelper() { }
        private UdpClientHelper() { }

        static readonly UdpClientHelper instance = new UdpClientHelper();
        public static UdpClientHelper Instance
        {
            get
            {
                return instance;
            }
        }

        public void SendBroadcast(string LocalIp,int LocalPort, byte[] send)
        {
            try
            {
                using (UdpClient udpClient = new UdpClient())
                {
                    udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true);
                    udpClient.Client.Bind(new IPEndPoint(IPAddress.Parse(LocalIp), LocalPort));
                    udpClient.Send(send, send.Length, new IPEndPoint(IPAddress.Broadcast, LocalPort));
                }
            }
            catch (SocketException ex)
            {
                // 捕获超时异常
                if (ex.SocketErrorCode == SocketError.TimedOut)
                {
                    Console.WriteLine("Receive timeout.");
                }
                else
                {
                    // 其他 SocketException 异常处理
                    Console.WriteLine($"SocketException: {ex.Message}");
                }

            }

        }

        public string ReceiveBroadcast(string LocalIp, int LocalPort)
        {
            string receiveMsg = null;
            try
            {
                using (UdpClient udpClient = new UdpClient())
                {
                    //udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true);
                    udpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 600);// 设置接收超时为 0.6 秒
                    udpClient.Client.Bind(new IPEndPoint(IPAddress.Parse(LocalIp), LocalPort));
                    IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
                    byte[] receiveBytes = udpClient.Receive(ref remoteEP);
                    if ( CommunicateHelper.Check_ReceData(receiveBytes))
                    {
                        byte addressYype = receiveBytes[2];
                        byte funType = receiveBytes[3];

                        if (addressYype == (byte)AddressCode.Debuger)
                        {
                            byte[] receivedData = receiveBytes.Skip(8).Take(receiveBytes.Length - 12).ToArray();
                            byte[] sendData = null;

                            switch (funType)
                            {
                                case (byte)FunctionCode.getIPAddress:
                                    receiveMsg = Encoding.Default.GetString(receivedData);
                                    break;
                                case (byte)FunctionCode.setIPAddress:
                                    receiveMsg = Encoding.Default.GetString(receivedData);
                                    break;
                                default:
                                    receiveMsg = null;
                                    break;
                            }

                        }

                    }
                }
            }
            catch (SocketException ex)
            {
                // 捕获超时异常
                if (ex.SocketErrorCode == SocketError.TimedOut)
                {
                    Console.WriteLine("Receive timeout.");
                }
                else
                {
                    // 其他 SocketException 异常处理
                    Console.WriteLine($"SocketException: {ex.Message}");
                }
            }
            return receiveMsg;
        }

    }

调用方法：

        private void btn_getIpAddressInfo_Click(object sender, EventArgs e)
        {
            if(CurrentIp==null)
            {
                MessageBox.Show("请先选择网卡！！");return;
            }

            txt_ContolBox_IPAddress.Text = "";
            txt_ContolBox_IPSubnet.Text = "";
            txt_ContolBox_DefaultIPGateway.Text = "";
            byte[] SendBytes = CommunicateClass.Gen_SendDataWithCRC(AddressCode.WatchDog, FunctionCode.getIPAddress, Encoding.Default.GetBytes("getIPAddress"));
            UdpClientHelper.Instance.SendBroadcast(CurrentIp, 12000, SendBytes);
            string ips= UdpClientHelper.Instance.ReceiveBroadcast(CurrentIp, 12000);
            if (ips!=null)
            {
                txt_ContolBox_IPAddress.Text = ips.Split(',')?[0];
                txt_ContolBox_IPSubnet.Text = ips.Split(',')?[1];
                txt_ContolBox_DefaultIPGateway.Text = ips.Split(',')?[2];
            }

        }

报文格式如下：

 //
    //报文格式：地址码+功能码+内容+校验码
    //
    //功能码 定义  发送内容备注

    //0x09    Broadcast   无要求
    //0x10    getIPAddress   无要求
    //0x11    setIPAddress   IP地址, 子网掩码, 默认网关
    //
    //地址码 定义
    //0x01    调试软件
    //0x02    看门狗
    //

    public enum FunctionCode : byte
    {

        Broadcast = 0x09,
        getIPAddress = 0x10,
        setIPAddress = 0x11,

    }

    public enum AddressCode : byte
    {
        Debuger = 0x01,
        WatchDog = 0x02,
    }

CRC效验静态库方法（nuget安装包，搜索“ApeFree.CodePlus.Algorithm”并安装。）：

    public static class CommunicateClass
    {

        /// <summary>
        /// 将发送数据整理成设定的报文格式
        /// </summary>
        /// <param name="func">功能码</param>
        /// <param name="byteSource">发送内容</param>
        /// <returns>返回的完整报文数据</returns>
        public static byte[] Gen_SendDataWithCRC(AddressCode addr, FunctionCode func, byte[] byteSource)
        {
            List<byte> tmp = new List<byte>();
            byte[] addrByte = new byte[] { (byte)addr };
            byte[] functionByte = new byte[] { (byte)func };
            tmp.AddRange(addrByte);
            tmp.AddRange(functionByte);
            tmp.AddRange(byteSource);
            byte[] sendData = tmp.ToArray();
            var crc = new Crc(CrcModel.CRC16_IBM);
            var calculatedCRC = crc.Calculate(sendData);
            byte[] dataToSend = sendData.Concat(calculatedCRC).ToArray(); // 将CRC校验码拼接到发送数据后面
            return dataToSend;

        }


        /// <summary>
        /// 接受报文并解析
        /// </summary>
        /// <param name="sourceData">收到的信息</param>
        /// <returns></returns>
        public static bool Check_ReceDataWithCRC(byte[] sourceData)
        {

            // 接收数据并效验
            byte[] receivedCRC = sourceData.Skip(sourceData.Length - 2).Take(2).ToArray(); // 从接收数据中取出CRC校验码
            byte[] receivedDataWithoutCRC = sourceData.Take(sourceData.Length - 2).ToArray();
            // // 从接收数据中删除CRC校验码      
            var crc = new Crc(CrcModel.CRC16_IBM);
            var calculatedCRC = crc.Calculate(receivedDataWithoutCRC);
            if (receivedCRC.SequenceEqual(calculatedCRC)) // 判断接收到的CRC校验码是否与计算得到的CRC校验码相等
            {
                return true;
            }
            else
            {
                return false;
            }



        }



    }
xiaowu080
关注
  • 15
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# System.Net.NetworkInformation 命名空间学习之NetworkInterface 类获取IP，DNS，Gateway,Mask, MAC等网络相关信息
游牧小小诗人
02-10 9093
慢慢更新
c#通过modbusTcp连接codesys控制器.rar
09-12
在本文中，我们将深入探讨如何使用C#编程语言通过MODBUS TCP协议与CODESYS控制器进行通信。CODESYS是一款基于IEC 61131-3标准的编程系统，广泛应用于工业自动化领域。MODBUS TCP则是一种网络通信协议，允许设备之间...
C#修改电脑IP信息帮助类
qq_41184334的博客
04-25 681
【代码】修改电脑IP信息帮助类。
C#使用cmd更改IP地址
裤头是叫裤头的裤头
03-18 1204
C#调用cmd更改IP地址
c#获取和设置网卡ip/dns等信息
热门推荐
真爱无限的CSDN博客
07-29 1万+
using System; using System.Windows.Forms; using System.Management; using System.Net.NetworkInformation; using System.Text.RegularExpressions; namespace 修改本地连接工具 { public partial class For
C# 修改本地以太网ip地址
pengzhanli的博客
10-14 7646
因为某项需求，要修改以太网的ip地址,研究了一段时间，因不太懂网络的知识，只实现了最基本的修改以太网ip的功能。如果有错误，欢迎指出 等价于在这里修改: 实现代码： //设置ip地址 private void SetNetworkAdapter(string ipAddress, string subnetMask, string gateway) ...
C# PLC与工控机连接控制界面
11-23
5. 将通信逻辑与界面事件绑定，实现控制功能。 最后，测试和调试是必不可少的环节。确保在真实环境中，你的程序能正确地连接到PLC，读取和写入数据，并在出现错误时有适当的处理机制。 总的来说，C# PLC与工控机...
IP摄像头RTSP流实时监控软件下载(C#源码)
04-23
软件特色包括：通过双击流窗口实现全窗口扩展、自动切换高/低分辨率流、支持命令行参数、可在指定编号的屏幕上全屏启动、自定义源名称以及视频丢失警报。 支持的格式有UDP/RTP单播、UDP/RTP多播、HTTP / FTP、TCP/...
C#安川控制器对外通讯C#代码示例Demo
02-04
本示例Demo主要关注的是如何使用C#与安川控制器进行通信，这是一个关键的技能，因为安川控制器是工业自动化领域的常用设备，常用于机器人控制、生产线管理等场景。下面将详细探讨这一主题。 首先，我们需要理解C#中...
network interface配置网络
俗人
01-01 2416
修改文件/etc/network/interfaces为 allow-hotplug eth0 iface eth0 inet dhcp allow-hotplug wlan0 iface wlan0 inet dhcp 修改后执行，链接wifi sudo ifup wlan0
C#设置IP地址，启用禁用适配器
weixin_30763455的博客
06-15 316
界面效果图如下： 报表界面 说下关键代码 需要开启Windows Management Instrumentation服务（默认已经开启），在程序中需要增加Management引用。 主要有NetworkAdapter（保存适配器的IP地址，网关，子网掩码，设置IP方面等 ）,NetworkAdapterUtil(主要是NetworkAdapter类的集合 )两个类。 ...
使用C#修改本机IP等相关信息
hhszsp的博客
11-27 4585
原文链接using System; using System.Collections.Generic; using System.Text; using System.Text.RegularExpressions; using System.Management; namespace IPProvider { class WMIForIPSet { public W
DNS、网关、IP、DHCP
weixin_47695827的博客
07-24 1545
DNS、网关、IP和DHCP是计算机网络中不可或缺的四个概念。它们共同构建了互联网的基础架构，确保了数据的准确传输和设备的有效连接。通过深入理解这些概念的工作原理和相互关系，我们可以更好地管理网络、保障安全，并充分利用网络资源。在未来的网络发展中，这些概念将继续发挥重要作用，推动互联网的持续进步和发展。
socket 编程
qq_68915288的博客
07-24 1069
它可以使任何客户端机器连接到任何服务器，安装在客户端和服务器两侧的程序就可以实现双向的通信。Socket的作用就是把连接两个计算机的通信软件“中间接”起来，能够实现远程连接。接收数据一般使用recvfrom，也可以使用read / recv，但是这两个函数只能读取到用户数据，不能获取发送方的网络地址。发送必须使用sendto，因为数据发送前没有连接，告诉socket，要把数据发给谁。accept 在“监听套接字”上，创建一个与客户端的“连接套接字”UDP是传输层的一个协议，面向无连接，数据报的传输层协议。
TCP/IP面试三道题
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
07-25 1994
针对TCP/IP的面试题，我将从简单到困难给出三道题目，并附上参考答案的概要。
vivado IP_REPO_PATHS
最新发布
cckkppll的博客
07-25 480
vivado IP_REPO_PATHS
路由表与IP数据报的转发
小李学不完的博客
07-25 1291
直接交付和间接交付。目的 IP 地址属于直接连接的网络时，IP 数据报直接交付给目的主机，否则转发给下一跳路由器进行间接交付静态路由表由网络管理员在路由器中手动配置，能对路由的行为进行精确的控制， 但不能对网络的变化做出反应路由聚合和默认路由能减少路由表项，以及减少查找路由时间。
解读 IP 地址定位
m0_73609283的博客
07-24 667
那么如果我想要精确到县级或区级，就要采用一些精密的算法和国家的合作商，但出于互联网隐私条律，得到的信息并不能具体定位到个人，比如知道具体的地址门牌号之类。但由于IP地址都是独一无二的，有权限的比如立案需求，手续齐全，还是能够快速精确到个人的。所以如果您遭遇了网络诈骗，警方通过这样准确的定位流程就可以快速定位到不法分子，当然不法分子可能会采用一些手段来掩盖自己的IP地址，但是凡走过必有痕迹，如何识别IP地址是否为代理就是另一个话题了。一些不良的应用可能会利用这一功能，大量获取用户本地设备中的信息。
C# 通过IP地址远程控制电脑时连接容易中断，如何增强稳定
06-14
要增强远程控制的稳定性，你可以尝试以下几种方法： 1. 确保网络连接稳定：连接中断可能是由于网络问题导致的，因此你需要确保网络连接稳定。可以尝试使用有线网络连接，或者增加信号强度等。 2. 优化网络设置：尝试优化网络设置以提高连接稳定性。你可以在路由器或防火墙上开放端口，或者调整网络协议和传输速率等。 3. 使用可靠的远程控制软件：选择一个可靠的远程控制软件，例如TeamViewer、VNC等。这些软件有着较高的稳定性和安全性，可以帮助你实现更稳定的远程控制。 4. 使用专业设备：如果你需要进行高质量、高稳定性的远程控制，你可以考虑使用专业的设备，例如远程控制器、KVM等。 5. 升级硬件：如果你的硬件配置较低，可能会导致远程控制的稳定性较差。你可以考虑升级硬件，例如增加内存或者更换更快的处理器等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值