Unity UDP可发送16进制数据可重新连接

最新推荐文章于 2022-05-11 11:56:50 发布
最新推荐文章于 2022-05-11 11:56:50 发布
阅读量1.1k 收藏 5
点赞数 1
文章标签： socket unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42393139/article/details/114577251
版权 
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;

namespace DAMTool
{
    public class UDPManager_Server : MonoBehaviour
    {

        public static UDPManager_Server Instance;
        [Header("是否自动获取系统IP")]
        public bool AutoSystemIP =true;
        [Header("当前系统IP")]
        public string ipAddress = "192.168.1.108";
        [Header("当前系统端口号")]
        public int ConnectPort = 7401;
        [Header("是否使用外部目标IP和端口")]
        bool UseOutTargetIPAndTargetPort = true;
        [Header("目标系统IP")]
        public string TargetIpAddress = "192.168.1.108";
        [Header("目标系统端口号")]
        public int TargetConnectPort = 7401;

        [Header("接收到的信息")]
        public string recvStr = "";
        [Header("接收到的16进制字符")]
        public string recvHexStr = "";
        Socket socket;
        EndPoint clientEnd;
        IPEndPoint ipEnd;
        string sendStr;
        byte[] recvData = new byte[1024];
        byte[] sendData = new byte[1024];
        int recvLen;
        Thread connectThread;
        Thread confirmThread;
        //发送指令确认队列
        public List<string> ConfirmStrList = new List<string>();

        //初始化
        private void Awake()
        {
            Instance = this;
        }
        private void LateUpdate()
        {

        }
        void Start()
        {
            if (AutoSystemIP)
            {
                //自动获取系统IP
                ipAddress = GetIP();
                //ipAddress = IPAddress.Any.ToString();
            }
            if(UseOutTargetIPAndTargetPort)
            {
                //加载外部IP和端口完成后初始化socket
                LoadUDPData_OutIP_OutPort(InitSocket);
            }
            


            //在这里初始化server
            //ConfirmStrList.Add("1234");
        }
        /// <summary>
        /// 开启加载线程
        /// </summary>
        /// <param name="fun"></param>
        public void LoadUDPData_OutIP_OutPort(UnityAction fun=null)
        {
            StartCoroutine(ReallyLoadUDPData(fun));
            
        }
        /// <summary>
        /// 加载UDP数据
        /// </summary>
        /// <param name="fun">加载完毕执行的方法</param>
        /// <returns></returns>
        IEnumerator ReallyLoadUDPData(UnityAction fun=null)
        {
            string UDPDataFilePath = Path.Combine(Application.streamingAssetsPath, "SystemData");
            UDPDataFilePath = Path.Combine(UDPDataFilePath, "UDPData.csv");
            WWW www = new WWW(UDPDataFilePath);
            yield return www;
            if (www.isDone && !string.IsNullOrEmpty(www.text))
            {
                string[] content = www.text.Split('\n');
                content[1] = content[1].Replace("\r", "");
                TargetIpAddress= content[1].Split(',')[0];
                TargetConnectPort=int.Parse( content[1].Split(',')[1]);
                if (fun != null)
                {
                    fun();
                }
            }
            

            
        }
        /// <summary>
        /// 初始化套接字
        /// </summary>
        public void InitSocket()
        {
            //防止出现连接错误
            uint IOC_IN = 0x80000000;
            uint IOC_VENDOR = 0x18000000;
            uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
            Debug.Log(ipAddress + ":" + ConnectPort);
            ipEnd = new IPEndPoint(IPAddress.Parse(ipAddress), ConnectPort);
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            socket.Bind(ipEnd);
#if UNITY_IPHONE
            //IOS该代码会报错
#else
            
            socket.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);
#endif
            //定义客户端
            //IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            IPEndPoint sender = new IPEndPoint(IPAddress.Parse(TargetIpAddress), TargetConnectPort);
            clientEnd = (EndPoint)sender;
            print("等待连接数据");
            //开启一个线程连接
            connectThread = new Thread(new ThreadStart(SocketReceive));
            confirmThread = new Thread(new ThreadStart(StrConfirm));
            connectThread.Start();
            confirmThread.Start();



        }
        /// <summary>
        /// 套接字发送内容
        /// </summary>
        /// <param name="sendStr">发送内容</param>
        /// <param name="needConfirm">是否加入确认数组，默认为不加入</param>
        public void SocketSend(string sendStr,string IP="",int Port=0, bool needConfirm = false)
        {
            if(IP!=""&&Port!=0)
            {
                EndPoint clientEndNew;
                IPEndPoint sender = new IPEndPoint(IPAddress.Parse(IP), Port);
                clientEndNew = (EndPoint)sender;

                Debug.Log("发送数据给指定目标，IP:"+IP+" Port:"+Port +" 内容:"+ sendStr);
                sendData = new byte[1024];
                sendData = Encoding.UTF8.GetBytes(sendStr);
                socket.SendTo(sendData, sendData.Length, SocketFlags.None, clientEndNew);
                if (needConfirm)
                {
                    if (!ConfirmStrList.Contains(sendStr))
                    {
                        ConfirmStrList.Add(sendStr);
                    }

                }
            }
            else
            {
                Debug.Log("发送数据给指定目标，IP:" + TargetIpAddress + " Port:" + TargetConnectPort + " 内容:" + sendStr);
                sendData = new byte[1024];
                sendData = Encoding.UTF8.GetBytes(sendStr);
                socket.SendTo(sendData, sendData.Length, SocketFlags.None, clientEnd);
                if (needConfirm)
                {
                    if (!ConfirmStrList.Contains(sendStr))
                    {
                        ConfirmStrList.Add(sendStr);
                    }

                }
            }

            

        }
        /// <summary>
        /// 发送16进制指令
        /// </summary>
        /// <param name="sendStr">发送内容</param>
        public void SocketSendHex(string sendStr, string IP = "", int Port = 0, bool needConfirm = false)
        {
            if (IP != "" && Port != 0)
            {
                EndPoint clientEndNew;
                IPEndPoint sender = new IPEndPoint(IPAddress.Parse(IP), Port);
                clientEndNew = (EndPoint)sender;

                Debug.Log("发送16进制数据，IP:" + IP + " Port:" + Port + " 内容:" + sendStr);
                sendData = new byte[1024];
                sendData = DAMDataManager.Instance.HexStringSToByteArray(sendStr);
                socket.SendTo(sendData, sendData.Length, SocketFlags.None, clientEndNew);
                if (needConfirm)
                {
                    if (!ConfirmStrList.Contains(sendStr))
                    {
                        ConfirmStrList.Add(sendStr);
                    }
                }

            }
            else
            {
                Debug.Log("发送16进制数据，IP:" + TargetIpAddress + " Port:" + TargetConnectPort + " 内容:" + sendStr);
                sendData = new byte[1024];
                sendData = DAMDataManager.Instance.HexStringSToByteArray(sendStr);
                socket.SendTo(sendData, sendData.Length, SocketFlags.None, clientEnd);
                if (needConfirm)
                {
                    if (!ConfirmStrList.Contains(sendStr))
                    {
                        ConfirmStrList.Add(sendStr);
                    }
                }
            }

            
        }



        //服务器接收
        void SocketReceive()
        {
            recvData = new byte[1024];
            while (true)
            {

                recvLen = socket.ReceiveFrom(recvData, ref clientEnd);
                recvStr = Encoding.UTF8.GetString(recvData, 0, recvLen);
                recvHexStr = Byte2Hex(recvData, recvLen);
                Debug.Log("收到的信息 " + recvStr);
                Debug.Log("收到的Hex字符串" + recvHexStr+" "+clientEnd);
                //SocketSend(recvStr);


            }
        }
        //字符确认
        void StrConfirm()
        {
            while (true)
            {
                if (recvStr != "")
                {
                    //Debug.Log(ConfirmStrList.Contains(recvStr));
                    if (ConfirmStrList.Contains(recvStr))
                    {

                        ConfirmStrList.Remove(recvStr);
                        Debug.Log("收到字符串" + recvStr);
                        recvStr = "";

                    }
                }
            }
        }
        //连接关闭
        void SocketQuit()
        {
            //关闭线程
            if (connectThread != null)
            {
                connectThread.Interrupt();
                connectThread.Abort();
            }
            if (confirmThread != null)
            {
                confirmThread.Interrupt();
                confirmThread.Abort();
            }
            //最后关闭socket
            if (socket != null)
                socket.Close();
            Debug.LogWarning("断开连接");
        }
        //重新连接
        // Use this for initialization
        public void ReConnectServer()
        {

            SocketQuit();
            InitSocket();
        }

        void OnApplicationQuit()
        {
            SocketQuit();
        }
        /// <summary>
        /// 获取IP，安卓端不可用
        /// </summary>
        /// <param name="Addfam"></param>
        /// <returns></returns>
        public string GetIP(ADDRESSFAM Addfam)
        {
            //Return null if ADDRESSFAM is Ipv6 but Os does not support it
            if (Addfam == ADDRESSFAM.IPv6 && !Socket.OSSupportsIPv6)
            {
                return null;
            }

            string output = "";

            foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
            {
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
                NetworkInterfaceType _type1 = NetworkInterfaceType.Wireless80211;
                NetworkInterfaceType _type2 = NetworkInterfaceType.Ethernet;

                if ((item.NetworkInterfaceType == _type1 || item.NetworkInterfaceType == _type2) && item.OperationalStatus == OperationalStatus.Up)
#endif
                {
                    foreach (UnicastIPAddressInformation ip in item.GetIPProperties().UnicastAddresses)
                    {
                        //IPv4
                        if (Addfam == ADDRESSFAM.IPv4)
                        {
                            if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
                            {
                                output = ip.Address.ToString();
                                Debug.Log("" + output);
                            }
                        }

                        //IPv6
                        else if (Addfam == ADDRESSFAM.IPv6)
                        {
                            if (ip.Address.AddressFamily == AddressFamily.InterNetworkV6)
                            {
                                output = ip.Address.ToString();
                            }
                        }
                    }
                }
            }
            return output;
        }
        //或取系统IP
        public string GetIP()
        {
            string AddressIP = string.Empty;
#if UNITY_IPHONE
        NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces(); ;
        foreach (NetworkInterface adapter in adapters)
        {
            if (adapter.Supports(NetworkInterfaceComponent.IPv4))
            {
                UnicastIPAddressInformationCollection uniCast = adapter.GetIPProperties().UnicastAddresses;
                if (uniCast.Count > 0)
                {
                    foreach (UnicastIPAddressInformation uni in uniCast)
                    {
                        //得到IPv4的地址。 AddressFamily.InterNetwork指的是IPv4
                        if (uni.Address.AddressFamily == AddressFamily.InterNetwork)
                        {
                            AddressIP = uni.Address.ToString();
                        }
                    }
                }
            }
        }
            return AddressIP;
#endif



            string IP = "";
            IPAddress[] ips = Dns.GetHostAddresses(Dns.GetHostName());   //Dns.GetHostName()获取本机名Dns.GetHostAddresses()根据本机名获取ip地址组
            foreach (IPAddress ip in ips)
            {
                if (ip.AddressFamily == AddressFamily.InterNetwork)
                {
                    IP = ip.ToString();  //ipv4

                }

                else if (ip.AddressFamily == AddressFamily.InterNetworkV6)
                {
                    IP = ip.ToString(); //ipv6
                }


            }
            return IP;
        }



        //byte转16进制数
        static string Byte2Hex(byte wbyte)
        {
            string ret = null;
            var arr = "0123456789ABCDEF";
            var len = arr.Length;
            ret += arr[wbyte / len].ToString();
            ret += arr[wbyte % len].ToString();
            return ret;
        }
        //btye数组转字符，需要数组长度
        static string Byte2Hex(byte[] _byte, int _Length)
        {
            string HexStr = null;
            for (int i = 0; i < _Length; i++)
            {
                HexStr += Byte2Hex(_byte[i]);
            }

            return HexStr;
        }



    }
}
public enum ADDRESSFAM
{
    IPv4, IPv6
}

已用于很多项目，效果不错，用的话需要稍作修改

补充

public void InitSocket()
        {
            //防止出现连接错误
            //uint IOC_IN = 0x80000000;
            //uint IOC_VENDOR = 0x18000000;
            //uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
            Debug.Log(ipAddress + ":" + ConnectPort);
            ipEnd = new IPEndPoint(IPAddress.Parse(ipAddress), ConnectPort);
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            socket.Bind(ipEnd);
#if UNITY_IPHONE
            //IOS该代码会报错
#else
            
            //socket.IOControl((int)SIO_UDP_CONNRESET, new byte[] { Convert.ToByte(false) }, null);
#endif
            //定义客户端
            //IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
            IPEndPoint sender = new IPEndPoint(IPAddress.Parse(TargetIpAddress1), TargetConnectPort1);
            clientEnd = (EndPoint)sender;
            print("等待连接数据");
            //开启一个线程连接
            connectThread = new Thread(new ThreadStart(SocketReceive));
            confirmThread = new Thread(new ThreadStart(StrConfirm));
            connectThread.Start();
            confirmThread.Start();



        }

在安卓端如果出现无法收到消息，但是可以发送消息的情况，将初始化方法中的防止出现连接错误的代码注释掉就可以了

qq_42393139
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
UDP十六进制数据传输
11-21
以16进制传输数据。里面带有Demo看了你就明白了。
Unity实现串口通信发送16进制字符
波波斯维奇
06-20 3695
Unity实现串口通信发送16进制字符 前言 Unity在与硬件设备进行串口通信的时候，硬件那边只接收字符串有时候是不行的，还需要接收16进制的数据，在这里简单介绍下使用Unity发送16进制的串口信号。 步骤 一、首先开发配置文件功能，代码如下所示，完成后将其挂载到场景的物体上，在这里不再赘述： using System.Collections; using System.Collections.Generic; using UnityEngine; using System.IO; using Syst
uniapp 开发微信小程序使用TCP/UDP通信以16进制发送数据
热门推荐
weixin_38946164的博客
05-11 1万+
在微信小程序中实现像网络调试助手中按16进制发送的功能。 如下图调试工具接收到微信小程序发送的16进制数据 let str = 'cf 03 00 00 00 00 1e 59 ce 96 7f 01 00 00 a5' let strs = str.split(" "); //将一个十六进制报文转为字符数组 for(let i = 0;i<strs.length;i++){ 　　strs[i] = "0x"+strs[i]; //每个字符加上0x }
uniapp 开发UDP广播发送16进制字符串
weixin_38946164的博客
03-18 3551
需求 使用手机控制udp通迅的设备进行相应的动作，设备接收16进制字节，例如在手机发送指令 CF 03 00 00 00 00 1E 59 CE 96 7F 01 00 00 A5 给设备并且能识别。 难点 手机端需要对字符串转换为16进制字节再进行发送，设备才能识别指令。 uniapp 代码 <template> <view class="page"> <view class="content"> <button type="prim
c#|Unity怎么按16进制发送udp命令
什么风把您给吹来了
04-24 2222
  private byte[] textWork16(string strText)     {         strText = strText.Replace(" ", "");         byte[] bText = new byte[strText.Length / 2];         for (int i = 0; i &lt; strText.Length / 2; i+...
Unity UDP通讯
weixin_43976972的博客
11-29 302
Unity UDP通讯 UDP的特点：随时断开，随时连接。 （客户端与服务器没有区别） 服务器 using System.Collections; using System.Collections.Generic; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; using...
Unity 串口发送十六进制byte消息
lvcoc的博客
05-20 1327
using UnityEngine; using System; using System.IO.Ports; using UnityEngine.UI; public class spSend : MonoBehaviour { public SerialPort sp; /* public Text text;*/ static public byte[] strSend = new byte[3]; void Start() { s...
Unity socket UDP 网络连接
Move_Cat的博客
05-11 681
记录在unity 网络连接中，对UDP socket学习过程。 服务端 UDP服务端，绑定了固定端口，知道自己的固定IP。 using UnityEngine; using System.Collections; //引入库 using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; public class UdpServer:MonoBehaviour { Socket sock
Unity串口通信，外部设置COM口，16进制
11-05
Unity串口通信的unityPackage包，可以在外部修改COM口，下载后直接拖拽导入到你的工程当中就好，关于串口通信的文档我也发布了，可以去查看。
Unity 串口通讯，完美解决接受16进制数据不完整的情况
09-02
可看资料：https://blog.csdn.net/a1062624730/article/details/132641467 根据网上提供的方法，测试出了最终解决方案，只要加一个sleep就可以，但是位置在前面，详情可看上方链接
C#TCP 通信（TCP发送16进制）
01-22
基于TCP实现的局域网通信，这个软件是我给别人写的一个小Demo，他们是和硬件通信，所以有些16进制转换之类的！呵呵！
Unity3d UDP通信实例代码，可运行
09-02
本实例聚焦于UDP（用户数据报协议）通信，这是一种无连接、不可靠但高效的数据传输方式，适合对实时性要求高的场景，比如在线游戏。 `UdpClient.cs` 和 `UDPServerManger.cs` 这两个文件分别代表了UDP通信的客户端...
Unity字符串与16进制的相互转化
末零 的博客
08-01 4965
由于 字符串存储过程中，用户输入的不确定性，导致解析时可能出现问题，所以采用字符串转化16进制的做法。 代码如下： /// <summary> /// 字符串转16进制 /// </summary> /// <param name="input">要转格式的字符串</param> /// <retu...
unity字符串转换十六进制
BBoyLXiang的博客
12-09 1077
private void btn_send_Click(string str) { try { string msg = str; byte[] buffer = new byte[1024 * 1024 * 3]; buffer = HexStringToByteArray(str); socketSend.Send(buffer); }
Unity Byte 转十六进制字符串
lvcoc的博客
05-08 1568
public static string ByteArrayToHexStringNoBlank(byte[] data) { StringBuilder sb = new StringBuilder(data.Length * 3); foreach (byte b in data) { sb.Append(Co...
String 转换成十六进制的字符串
yijiu0711的专栏
06-04 989
/** * 字符串转换成十六进制值 * @param bin String 转换成十六进制的字符串 * @return */ public static String bin2hex(String bin) { char[] digital = "0123456789ABCDEF".toCharArray(); StringBuffer sb = new StringBuffer(""; byte
字符串转十六进制字节数组
Champion_Lee的专栏
09-17 2986
网络通信中，有时需要传送十六进制字节数组，这时就需要将字符串转换为十六进制字节数组，比如控制无线继电器。   逻辑如下： public byte[] HexStringToByteArray(string s) { if (s.Length == 0) Debug.log("将16进制字符串转换成字节数组时出错，错误信息：被转换的字符串长度为0。"); s = s.Repl
基于微信小程序网上商城设计设计与实现.docx
最新发布
08-23
基于微信小程序网上商城设计设计与实现.docx
unity +tcp发送16进制
09-21
在Unity中，要发送16进制数据流，可以通过TCP连接来实现。下面是一个示例代码，解释了如何在Unity中发送16进制数据。 首先，需要使用Unity内置的NetworkStream类和TcpClient类来创建TCP连接并发送数据。然后，将要发送的数据从字符串转换为16进制字节数组。最后，使用NetworkStream的Write方法发送字节数组。 ```c# using UnityEngine; using System; using System.IO; using System.Net; using System.Net.Sockets; public class TcpSender : MonoBehaviour { public string serverIP = "127.0.0.1"; public int serverPort = 8888; public string hexData = "ff00d245370022"; private TcpClient client; private NetworkStream stream; void Start() { client = new TcpClient(); client.Connect(IPAddress.Parse(serverIP), serverPort); stream = client.GetStream(); SendHexData(hexData); client.Close(); } private void SendHexData(string hexData) { try { byte[] byteArray = StringToByteArray(hexData); stream.Write(byteArray, 0, byteArray.Length); Debug.Log("数据已发送"); } catch (Exception e) { Debug.Log("发送失败：" + e.Message); } } private byte[] StringToByteArray(string hex) { hex = hex.Replace(" ", ""); int charCount = hex.Length; byte[] byteArray = new byte[charCount / 2]; for (int i = 0; i < charCount; i += 2) byteArray[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16); return byteArray; } } ``` 在此示例中，我们创建了一个TcpSender类，该类在Start()方法中创建TCP连接，并通过SendHexData()方法发送16进制数据。StringToByteArray()方法将16进制字符串转换为字节数组，然后使用NetworkStream的Write()方法发送字节数组。需要根据实际情况修改serverIP、serverPort和hexData的值。 请注意，该代码仅提供了一个基本的示例，实际应用中可能需要更多的错误处理和异常处理机制来确保数据正确发送。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值