diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs
index 2cd46ff..6be2851 100644
--- a/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs
+++ b/Modbus.Net/Modbus.Net.Modbus/ModbusProtocolLinkerBytesExtend.cs
@@ -5,6 +5,14 @@ using System.Text;
 
 namespace Modbus.Net.Modbus
 {
+    /// <summary>
+    ///     Udp字节伸缩
+    /// </summary>
+    public class ModbusUdpProtocolLinkerBytesExtend : ModbusTcpProtocolLinkerBytesExtend
+    {
+        
+    }
+
     /// <summary>
     ///     Rtu透传字节伸缩
     /// </summary>
diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs
new file mode 100644
index 0000000..720ed02
--- /dev/null
+++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocol.cs
@@ -0,0 +1,45 @@
+using System.Configuration;
+
+namespace Modbus.Net.Modbus
+{
+    /// <summary>
+    ///     Modbus/Udp协议
+    /// </summary>
+    public class ModbusUdpProtocol : ModbusProtocol
+    {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        public ModbusUdpProtocol(byte slaveAddress, byte masterAddress)
+            : this(ConfigurationManager.AppSettings["IP"], slaveAddress, masterAddress)
+        {
+        }
+
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">ip地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        public ModbusUdpProtocol(string ip, byte slaveAddress, byte masterAddress)
+            : base(slaveAddress, masterAddress)
+        {
+            ProtocolLinker = new ModbusUdpProtocolLinker(ip);
+        }
+
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">ip地址</param>
+        /// <param name="port">端口</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        public ModbusUdpProtocol(string ip, int port, byte slaveAddress, byte masterAddress)
+            : base(slaveAddress, masterAddress)
+        {
+            ProtocolLinker = new ModbusUdpProtocolLinker(ip, port);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs
new file mode 100644
index 0000000..cb7e394
--- /dev/null
+++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUdpProtocolLinker.cs
@@ -0,0 +1,47 @@
+using System.Configuration;
+
+namespace Modbus.Net.Modbus
+{
+    /// <summary>
+    ///     Modbus/Udp协议连接器
+    /// </summary>
+    public class ModbusUdpProtocolLinker : UdpProtocolLinker
+    {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">IP地址</param>
+        public ModbusUdpProtocolLinker(string ip)
+            : this(ip, int.Parse(ConfigurationManager.AppSettings["ModbusPort"] ?? "502"))
+        {
+        }
+
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">IP地址</param>
+        /// <param name="port">端口</param>
+        public ModbusUdpProtocolLinker(string ip, int port) : base(ip, port)
+        {
+            ((BaseConnector)BaseConnector).AddController(new FifoController(0));
+        }
+
+        /// <summary>
+        ///     校验返回数据
+        /// </summary>
+        /// <param name="content">设备返回的数据</param>
+        /// <returns>数据是否正确</returns>
+        public override bool? CheckRight(byte[] content)
+        {
+            //ProtocolLinker的CheckRight不会返回null
+            if (base.CheckRight(content) != true) return false;
+            //长度校验失败
+            if (content[5] != content.Length - 6)
+                throw new ModbusProtocolErrorException(500);
+            //Modbus协议错误
+            if (content[7] > 127)
+                throw new ModbusProtocolErrorException(content[2] > 0 ? content[2] : content[8]);
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs b/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
index c47b678..d4405db 100644
--- a/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
+++ b/Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs
@@ -33,6 +33,10 @@ namespace Modbus.Net.Modbus
         ///     Ascii连接Tcp透传
         /// </summary>
         AsciiInTcp = 4,
+        /// <summary>
+        ///     Udp连接
+        /// </summary>
+        Udp = 5
     }
 
     /// <summary>
@@ -193,6 +197,17 @@ namespace Modbus.Net.Modbus
                                     MasterAddress));
                         break;
                     }
+                    //Udp协议
+                    case ModbusType.Udp:
+                    {
+                        Wrapper = ConnectionString == null
+                            ? new ModbusUdpProtocol(SlaveAddress, MasterAddress)
+                            : (ConnectionStringPort == null
+                                ? new ModbusUdpProtocol(ConnectionString, SlaveAddress, MasterAddress)
+                                : new ModbusUdpProtocol(ConnectionStringIp, ConnectionStringPort.Value, SlaveAddress,
+                                    MasterAddress));
+                        break;
+                    }
                 }
             }
         }
diff --git a/Modbus.Net/Modbus.Net/SocketMessageEventArgs.cs b/Modbus.Net/Modbus.Net/SocketMessageEventArgs.cs
new file mode 100644
index 0000000..78431e1
--- /dev/null
+++ b/Modbus.Net/Modbus.Net/SocketMessageEventArgs.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Modbus.Net
+{
+    /*
+    /// <summary>
+    ///     Socket收到的数据
+    /// </summary>
+    public class SocketMessageEventArgs : EventArgs
+    {
+        /// <summary>
+        ///     构造器
+        /// </summary>
+        /// <param name="message">需要返回的信息</param>
+        public SocketMessageEventArgs(byte[] message)
+        {
+            Message = message;
+        }
+
+        /// <summary>
+        ///     返回的信息
+        /// </summary>
+        public byte[] Message { get; }
+    }*/
+}
diff --git a/Modbus.Net/Modbus.Net/TcpConnector.cs b/Modbus.Net/Modbus.Net/TcpConnector.cs
index 174968a..cadff86 100644
--- a/Modbus.Net/Modbus.Net/TcpConnector.cs
+++ b/Modbus.Net/Modbus.Net/TcpConnector.cs
@@ -8,26 +8,6 @@ using Serilog;
 
 namespace Modbus.Net
 {
-    /// <summary>
-    ///     Socket收到的数据
-    /// </summary>
-    public class SocketMessageEventArgs : EventArgs
-    {
-        /// <summary>
-        ///     构造器
-        /// </summary>
-        /// <param name="message">需要返回的信息</param>
-        public SocketMessageEventArgs(byte[] message)
-        {
-            Message = message;
-        }
-
-        /// <summary>
-        ///     返回的信息
-        /// </summary>
-        public byte[] Message { get; }
-    }
-
     /// <summary>
     ///     Socket收发类
     ///     作者：本类来源于CSDN，并由罗圣（Chris L.）根据实际需要修改
diff --git a/Modbus.Net/Modbus.Net/UdpConnector.cs b/Modbus.Net/Modbus.Net/UdpConnector.cs
new file mode 100644
index 0000000..96a8623
--- /dev/null
+++ b/Modbus.Net/Modbus.Net/UdpConnector.cs
@@ -0,0 +1,287 @@
+using System;
+using System.Linq;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+using Nito.AsyncEx;
+using Serilog;
+
+namespace Modbus.Net
+{
+    /// <summary>
+    ///     Udp收发类
+    /// </summary>
+    public class UdpConnector : BaseConnector, IDisposable
+    {
+        private readonly string _host;
+        private readonly int _port;
+
+        /// <summary>
+        ///     1MB 的接收缓冲区
+        /// </summary>
+        private readonly byte[] _receiveBuffer = new byte[1024];
+
+        private int _errorCount;
+        private int _receiveCount;
+
+        private int _sendCount;
+
+        private UdpClient _socketClient;
+
+        private bool m_disposed;
+
+        private Task _receiveThread;
+        private bool _taskCancel = false;
+
+        /// <summary>
+        ///     构造器
+        /// </summary>
+        /// <param name="ipaddress">Ip地址</param>
+        /// <param name="port">端口</param>
+        /// <param name="timeoutTime">超时时间</param>
+        public UdpConnector(string ipaddress, int port, int timeoutTime = 10000) : base(timeoutTime)
+        {
+            _host = ipaddress;
+            _port = port;
+        }
+
+        /// <inheritdoc />
+        public override string ConnectionToken => _host;
+
+        /// <inheritdoc />
+        protected override int TimeoutTime { get; set; }
+
+        /// <inheritdoc />
+        public override bool IsConnected => _socketClient?.Client != null && _socketClient.Client.Connected;
+
+        /// <inheritdoc />
+        protected override AsyncLock Lock { get; } = new AsyncLock();
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            //.NET Framework 类库
+            // GC..::.SuppressFinalize 方法
+            //请求系统不要调用指定对象的终结器。
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        ///     虚方法，可供子类重写
+        /// </summary>
+        /// <param name="disposing"></param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!m_disposed)
+            {
+                if (disposing)
+                {
+                    // Release managed resources
+                }
+                // Release unmanaged resources
+                if (_socketClient != null)
+                {
+                    CloseClientSocket();
+#if NET40 || NET45 || NET451 || NET452
+                    _socketClient.Close();
+#else
+                    _socketClient.Dispose();
+#endif
+                    Log.Debug("Tcp client {ConnectionToken} Disposed", ConnectionToken);
+                }
+                m_disposed = true;
+            }
+        }
+
+        /// <summary>
+        ///     析构函数
+        ///     当客户端没有显示调用Dispose()时由GC完成资源回收功能
+        /// </summary>
+        ~UdpConnector()
+        {
+            Dispose(false);
+        }
+
+        /// <inheritdoc />
+        public override async Task<bool> ConnectAsync()
+        {
+            using (await Lock.LockAsync())
+            {
+                if (_socketClient != null)
+                {
+                    return true;
+                }
+                try
+                {
+                    _socketClient = new UdpClient();
+
+                    try
+                    {
+                        var cts = new CancellationTokenSource();
+                        cts.CancelAfter(TimeoutTime);
+                        await Task.Run(() => _socketClient.Connect(_host, _port), cts.Token);
+                    }
+                    catch (Exception e)
+                    {
+                        Log.Error(e, "Tcp client {ConnectionToken} connect error", ConnectionToken);
+                    }
+                    if (_socketClient.Client.Connected)
+                    {
+                        _taskCancel = false;
+                        Controller.SendStart();
+                        ReceiveMsgThreadStart();
+                        Log.Information("Tcp client {ConnectionToken} connected", ConnectionToken);
+                        return true;
+                    }
+                    Log.Error("Tcp client {ConnectionToken} connect failed.", ConnectionToken);
+                    return false;
+                }
+                catch (Exception err)
+                {
+                    Log.Error(err, "Tcp client {ConnectionToken} connect exception", ConnectionToken);
+                    return false;
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public override bool Disconnect()
+        {
+            if (_socketClient == null)
+                return true;
+
+            try
+            {
+                Dispose();
+                Log.Information("Tcp client {ConnectionToken} disconnected successfully", ConnectionToken);
+                return true;
+            }
+            catch (Exception err)
+            {
+                Log.Error(err, "Tcp client {ConnectionToken} disconnected exception", ConnectionToken);
+                return false;
+            }
+            finally
+            {
+                _socketClient = null;
+            }
+        }
+
+        /// <inheritdoc />
+        protected override async Task SendMsgWithoutConfirm(byte[] message)
+        {
+            var datagram = message;
+
+            try
+            {
+                if (!IsConnected)
+                    await ConnectAsync();
+
+                RefreshSendCount();
+
+                Log.Verbose("Tcp client {ConnectionToken} send text len = {Length}", ConnectionToken, datagram.Length);
+                Log.Verbose($"Tcp client {ConnectionToken} send: {String.Concat(datagram.Select(p => " " + p.ToString("X2")))}");
+                await _socketClient.SendAsync(datagram, datagram.Length);
+            }
+            catch (Exception err)
+            {
+                Log.Error(err, "Tcp client {ConnectionToken} send exception", ConnectionToken);
+                CloseClientSocket();
+            }
+        }
+
+        /// <inheritdoc />
+        protected override void ReceiveMsgThreadStart()
+        {
+            _receiveThread = Task.Run(ReceiveMessage);
+        }
+
+        /// <inheritdoc />
+        protected override void ReceiveMsgThreadStop()
+        {
+            _taskCancel = true;
+        }
+
+        /// <summary>
+        ///     接收返回消息
+        /// </summary>
+        /// <returns>返回的消息</returns>
+        protected async Task ReceiveMessage()
+        {
+            try
+            {
+                while (!_taskCancel)
+                {
+                    var receive = await _socketClient.ReceiveAsync();
+
+                    var len = receive.Buffer.Length;
+                    // 异步接收回答
+                    if (len > 0)
+                    {
+                        if (receive.Buffer.Clone() is byte[] receiveBytes)
+                        {
+                            Log.Verbose("Tcp client {ConnectionToken} receive text len = {Length}", ConnectionToken,
+                                receiveBytes.Length);
+                            Log.Verbose(
+                                $"Tcp client {ConnectionToken} receive: {String.Concat(receiveBytes.Select(p => " " + p.ToString("X2")))}");
+                            var isMessageConfirmed = Controller.ConfirmMessage(receiveBytes);
+                            if (isMessageConfirmed == false)
+                            {
+                                //主动传输事件
+                            }
+                        }
+                    }
+
+                    RefreshReceiveCount();
+                }
+            }
+            catch (ObjectDisposedException)
+            {
+                //ignore
+            }
+            catch (Exception err)
+            {
+                Log.Error(err, "Tcp client {ConnectionToken} receive exception", ConnectionToken);
+                //CloseClientSocket();
+            }
+        }
+
+        private void RefreshSendCount()
+        {
+            _sendCount++;
+            Log.Verbose("Tcp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount);
+        }
+
+        private void RefreshReceiveCount()
+        {
+            _receiveCount++;
+            Log.Verbose("Tcp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount);
+        }
+
+        private void RefreshErrorCount()
+        {
+            _errorCount++;
+            Log.Verbose("Tcp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount);
+        }
+
+        private void CloseClientSocket()
+        {
+            try
+            {
+                Controller.SendStop();
+                Controller.Clear();
+                ReceiveMsgThreadStop();
+                if (_socketClient.Client.Connected)
+                {
+                    _socketClient?.Client.Disconnect(false);
+                }
+                _socketClient?.Close();
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Tcp client {ConnectionToken} client close exception", ConnectionToken);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Modbus.Net/Modbus.Net/UdpProtocolLinker.cs b/Modbus.Net/Modbus.Net/UdpProtocolLinker.cs
new file mode 100644
index 0000000..7c74f4d
--- /dev/null
+++ b/Modbus.Net/Modbus.Net/UdpProtocolLinker.cs
@@ -0,0 +1,48 @@
+using System.Configuration;
+
+namespace Modbus.Net
+{
+    /// <summary>
+    ///     Udp连接对象
+    /// </summary>
+    public abstract class UdpProtocolLinker : ProtocolLinker
+    {
+        /// <summary>
+        ///     构造器
+        /// </summary>
+        protected UdpProtocolLinker(int port)
+            : this(ConfigurationManager.AppSettings["IP"], port)
+        {
+        }
+
+        /// <summary>
+        ///     构造器
+        /// </summary>
+        /// <param name="ip">Ip地址</param>
+        /// <param name="port">端口</param>
+        protected UdpProtocolLinker(string ip, int port)
+            : this(ip, port, int.Parse(ConfigurationManager.AppSettings["IPConnectionTimeout"] ?? "-1"))
+        {
+        }
+
+        /// <summary>
+        ///     构造器
+        /// </summary>
+        /// <param name="ip">Ip地址</param>
+        /// <param name="port">端口</param>
+        /// <param name="connectionTimeout">超时时间</param>
+        protected UdpProtocolLinker(string ip, int port, int connectionTimeout)
+        {
+            if (connectionTimeout == -1)
+            {
+                //初始化连接对象
+                BaseConnector = new UdpConnector(ip, port);
+            }
+            else
+            {
+                //初始化连接对象
+                BaseConnector = new UdpConnector(ip, port, connectionTimeout);
+            }
+        }
+    }
+}
\ No newline at end of file