.NET6实现对西门子1500PLC的开放式TCP/IP数据读取与写入

已于 2022-04-13 12:20:01 修改
阅读量5k 收藏 14
点赞数 4
文章标签： c#
于 2022-04-07 21:41:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helldoger/article/details/124027311
版权 
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net6.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWindowsForms>true</UseWindowsForms>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

	<ItemGroup>
		<PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.3" />
		<PackageReference Include="Microsoft.EntityFrameworkCore.Abstractions" Version="6.0.3" />
		<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.3">
		  <PrivateAssets>all</PrivateAssets>
		  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
		</PackageReference>
		<PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="6.0.3" />
		<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="6.0.3" />
		<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="6.0.3">
			<PrivateAssets>all</PrivateAssets>
			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
		</PackageReference>
		<PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
		<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="6.0.0" />
		<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
		<PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
		<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
		<PackageReference Include="NModbus4.NetCore" Version="2.0.1" />
		<PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version="6.0.1" />
	</ItemGroup>

	<ItemGroup>
	  <Folder Include="DataConvertLib\" />
	  <Folder Include="Service\" />
	</ItemGroup>

	<ItemGroup>
	  <None Include="..\.editorconfig" Link=".editorconfig" />
	</ItemGroup>

	<ItemGroup>
	  <None Update="VariableNode.json">
	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
	  </None>
	</ItemGroup>
</Project>

先建立json文件点表:

{
  "ConnectionStrings": {
    "SqliteConnectionString": "Data Source=D:\\Csharp\\code\\STM32Demon\\STM32Demon\\bin\\Debug\\net6.0-windows\\Database\\DbSqlite.db",
    "MySQLConnectionString": "server=127.0.0.1; database=OneToMany; uid=root; pwd=123456;"
  },
  "ServerURL": "192.168.1.100",
  "Port": "2000",
  "VarNum": "6",
  "ByteLenth": "100",
  "Variable": [
    {
      "Id": 1,
      "Number": "1",
      "Name": "Float1",
      "Description": "40001-40002",
      "Type": "TCP",
      "VarAddress": 0,
      "Scale": "1",
      "Offset": "0",
      "Start": "0",
      "AccessProperty": "读写",
      "VarType": "Float",
      "InsertTime": "0",
      "Value": "0"
    },
    {
      "Id": 2,
      "Number": "2",
      "Name": "Float2",
      "Description": "40001-40002",
      "Type": "TCP",
      "VarAddress": 2,
      "Scale": "1",
      "Offset": "0",
      "Start": "0",
      "AccessProperty": "读写",
      "VarType": "Float",
      "InsertTime": "0",
      "Value": "0"
    },
    {
      "Id": 3,
      "Number": "3",
      "Name": "Float3",
      "Description": "40005-40006",
      "Type": "TCP",
      "VarAddress": 4,
      "Scale": "1",
      "Offset": "0",
      "Start": "0",
      "AccessProperty": "读写",
      "VarType": "Float",
      "InsertTime": "0",
      "Value": "0"
    },
    {
      "Id": 4,
      "Number": "4",
      "Name": "Float4",
      "Description": "40007-40008",
      "Type": "TCP",
      "VarAddress": 6,
      "Scale": "1",
      "Offset": "0",
      "Start": "0",
      "AccessProperty": "读写",
      "VarType": "Float",
      "InsertTime": "0",
      "Value": "0"
    },
    {
      "Id": 5,
      "Number": "5",
      "Name": "UShort1",
      "Description": "40008",
      "Type": "TCP",
      "VarAddress": 8,
      "Scale": "1",
      "Offset": "0",
      "Start": "0",
      "AccessProperty": "读写",
      "VarType": "UShort",
      "InsertTime": "0",
      "Value": "0"
    },
    {
      "Id": 6,
      "Number": "6",
      "Name": "UShort2",
      "Description": "40009",
      "Type": "TCP",
      "VarAddress": 9,
      "Scale": "1",
      "Offset": "0",
      "Start": "0",
      "AccessProperty": "读写",
      "VarType": "UShort",
      "InsertTime": "0",
      "Value": "0"
    }
  ]
}

客户端主程序:

using EF6Demon.DAL;
using Microsoft.Extensions.Configuration;
using STM32Demon.Models;
using System.Net;
using System.Net.Sockets;
using thinger.DataConvertLib;
using DataType = thinger.DataConvertLib.DataType;

namespace STM32Demon
{
    public partial class FrmMain1 : Form
    {
        public FrmMain1()
        {
            InitializeComponent();
            this.Load += FrmMain1_Load;
        }

        //private ModelsResponsitory dbContext = new ModelsResponsitory();
        private ConfigurationBuilder cfgBuilder = new ConfigurationBuilder();
        private IConfigurationRoot configRoot;
        private CancellationTokenSource cts = new CancellationTokenSource();
        private byte[] setArray;
        private Socket tcpClient;
        private FrmServer frmServer;

        private void FrmMain1_Load(object? sender, EventArgs e)
        {
            cfgBuilder.AddJsonFile("VariableNode.json", optional: true, reloadOnChange: true);
            this.configRoot = cfgBuilder.Build();
            CommonMethods.Ip = configRoot.GetSection("ServerURL").Value;
            CommonMethods.Port = configRoot.GetSection("Port").Value;
            CommonMethods.VarNum = configRoot.GetSection("VarNum").Value;
            CommonMethods.ByteLenth = int.Parse(configRoot.GetSection("ByteLenth").Value);
            CommonMethods.AllVarList = new List<Variable>();
            for (int i = 0; i < int.Parse(CommonMethods.VarNum); i++)
            {
                Variable variable = configRoot.GetSection($"Variable:{i}").Get<Variable>();
                CommonMethods.AllVarList.Add(variable);
            }
            foreach (var item in CommonMethods.AllVarList)
            {
                this.comboBox1.Invoke(() =>
                {
                    this.comboBox1.Items.Add(item.Name);
                });
                CommonMethods.CurrentPLCValue.Add(item.Name, item.Value);
                CommonMethods.CurrentPLCNote.Add(item.Name, item.VarType);

            }
        }

        private void btnConn_Click(object sender, EventArgs e)
        {
            tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tcpClient.Connect(IPAddress.Parse(CommonMethods.Ip), int.Parse(CommonMethods.Port));
            CommonMethods.IsConnected = tcpClient.Connected;
            CommonMethods.FirstConnect = false;
            Addinfo(CommonMethods.IsConnected ? "连接成功" : "连接失败");
        }


        private void Addinfo(string info)
        {
            this.isInfo.Items.Insert(
                0, DateTime.Now.ToString("HH:mm:ss") + " " + info + Environment.NewLine);
        }

        private void btnRead_Click(object sender, EventArgs e)
        {
            Task.Run(async () =>
            {
                while (!cts.IsCancellationRequested)
                {
                    await Task.Delay(200);
                    byte[] buffer = new byte[1024];
                    int length = -1;
                    length = tcpClient.Receive(buffer, SocketFlags.None);
                    byte[] result = new byte[CommonMethods.ByteLenth / 2];
                    byte[] setArray1 = new byte[CommonMethods.ByteLenth / 2];
                    this.setArray = setArray1;
                    if (length == CommonMethods.ByteLenth) //100 =100
                    {
                        //数据源, 数据源开始索引, 目标数据,目标数据开始索引, 长度
                        Array.Copy(buffer, 0, result, 0, CommonMethods.ByteLenth / 2);
                        setArray = ByteArrayLib.GetByteArrayFromByteArray(buffer, CommonMethods.ByteLenth / 2, CommonMethods.ByteLenth / 2);

                        foreach (var item in CommonMethods.AllVarList)
                        {
                            int start = item.VarAddress * 2;
                            switch (item.VarType)
                            {
                                case DataType.Bool:
                                    item.Value = BitLib.GetBitFromByteArray(result, start, int.Parse(item.Offset)).ToString();
                                    break;
                                case DataType.Short:
                                    item.Value = ShortLib.GetShortFromByteArray(result, start).ToString();
                                    
                                    break;
                                case DataType.UShort:
                                    item.Value = UShortLib.GetUShortFromByteArray(result, start).ToString();
                                    break;
                                case DataType.Int:
                                    item.Value = IntLib.GetIntFromByteArray(result, start).ToString();
                                    break;
                                case DataType.UInt:
                                    item.Value = UIntLib.GetUIntFromByteArray(result, start).ToString();
                                    break;
                                case DataType.Float:
                                    item.Value = FloatLib.GetFloatFromByteArray(result, start).ToString();
                                    break;
                                case DataType.Double:
                                    item.Value = DoubleLib.GetDoubleFromByteArray(result, start).ToString();
                                    break;
                                default:
                                    break;
                            }
                            //包含就替换，否则就添加
                            if (CommonMethods.CurrentPLCValue.ContainsKey(item.Name))
                            {
                                CommonMethods.CurrentPLCValue[item.Name] = item.Value;

                            }
                            else
                            {
                                CommonMethods.CurrentPLCValue.Add(item.Name, item.Value);
                            }
                        }
                    }

                    foreach (var item in CommonMethods.CurrentPLCValue)
                    {
                        this.isInfo.Invoke(() =>
                        {
                            this.isInfo.Items.Add(item.Key+":");
                            this.isInfo.Items.Add(item.Value.ToString());
                        });
                    };

                    Invoke(new Action(() =>
                    {
                        foreach (Control item in this.Controls)
                        {
                            //if (item is TextBox txt)
                            //{
                            //    item.Text = CommonMethods.CurrentPLCValue[this.comboBox1.Text].ToString();
                            //}
                            if (item is LabelShow ls)
                            {
                                if (ls.VarTitle == "Float1")
                                {
                                    ls.VarValue = CommonMethods.CurrentPLCValue["Float1"].ToString();
                                }
                                if (ls.VarTitle == "Float2")
                                {
                                    ls.VarValue = CommonMethods.CurrentPLCValue["Float2"].ToString();
                                }
                                if (ls.VarTitle == "Float3")
                                {
                                    ls.VarValue = CommonMethods.CurrentPLCValue["Float3"].ToString();
                                }
                                if (ls.VarTitle == "Float4")
                                {
                                    ls.VarValue = CommonMethods.CurrentPLCValue["Float4"].ToString();
                                }
                                if (ls.VarTitle == "UShort1")
                                {
                                    ls.VarValue = CommonMethods.CurrentPLCValue["UShort1"].ToString();
                                }
                                if (ls.VarTitle == "UShort2")
                                {
                                    ls.VarValue = CommonMethods.CurrentPLCValue["UShort2"].ToString();
                                }
                            }
                        }
                    }
                    ));

                }

            }, cts.Token);
        }

        private void btnServer_Click(object sender, EventArgs e)
        {
            frmServer = new FrmServer();
            frmServer.ShowDialog();
        }

        private void btnDisc_Click(object sender, EventArgs e)
        {
            try
            {
                tcpClient.Close();
                CommonMethods.IsConnected = tcpClient.Connected;
                //CommonMethods.IsConnected = false;
                Addinfo(CommonMethods.IsConnected ? "没有断开" : "断开成功");
            }
            catch (Exception)
            {

                throw;
            }
        }

        private void btnWrite1_Click(object sender, EventArgs e)
        {
            List<byte> res = new List<byte>();
            //byte[] res;
            string varName = this.comboBox1.Text;
            float valueF1 = Convert.ToSingle(this.txt1.Text.Trim());
            ushort valueS = Convert.ToUInt16(Math.Floor(double.Parse(this.txt1.Text.Trim())));
            int varAddress = 0;
            switch (CommonMethods.CurrentPLCNote[varName])
            {
                case DataType.UShort:
                    res = ByteArrayLib.GetByteArrayFromUShort(valueS).ToList();
                    break;
                case DataType.Float:
                    res = ByteArrayLib.GetByteArrayFromFloat(valueF1).ToList();
                    break;
                default:
                    break;
            }

            foreach (var item in CommonMethods.AllVarList)
            {
                if (item.Name==this.comboBox1.Text)
                {
                    varAddress = item.VarAddress;
                }
            }

            byte[] set = ByteArrayLib.ReplaceByteArray(setArray, varAddress*2, res.ToArray());
            tcpClient.Send(set, SocketFlags.None);
        }

        public byte[] ReplaceByteArray(byte[] source, int start, byte[] value)
        {
            for (int i = 0; i < value.Length; i++)
            {
                source[start + i] = value[i];
            }
            return source;
        }
    }
}

读取ASCII与其他格式

using STM32Demon.DataConvertLib;
using System.Text.RegularExpressions;
using DataType = thinger.DataConvertLib.DataType;

namespace STM32Demon
{
    public partial class FrmMain1 : Form
    {
        public FrmMain1()
        {
            InitializeComponent();
            this.Load += FrmMain1_Load;
        }

        //private ModelsResponsitory dbContext = new ModelsResponsitory();
        private ConfigurationBuilder cfgBuilder = new ConfigurationBuilder();
        private IConfigurationRoot configRoot;
        private CancellationTokenSource cts = new CancellationTokenSource();
        private byte[] setArray;
        private Socket tcpClient;
        private FrmServer frmServer;
        InsertDataSQLite objInsert = new InsertDataSQLite(10000);//10秒1次

        private void FrmMain1_Load(object? sender, EventArgs e)
        {
            cfgBuilder.AddJsonFile("VariableNode.json", optional: true, reloadOnChange: true);
            this.configRoot = cfgBuilder.Build();

            //服务器Ip和端口
            CommonMethods.Ip = configRoot.GetSection("ServerURL").Value;
            CommonMethods.Port = configRoot.GetSection("Port").Value;

            //自建服务器Ip和端口
            CommonMethods.CreateIp = configRoot.GetSection("CrateServer").Value;
            CommonMethods.CreatePort = configRoot.GetSection("CreatePort").Value;

            CommonMethods.VarNum = configRoot.GetSection("VarNum").Value;
            CommonMethods.ByteLenth = int.Parse(configRoot.GetSection("ByteLenth").Value);
            CommonMethods.AllVarList = new List<Variable>();
            //读入点表
            for (int i = 0; i < int.Parse(CommonMethods.VarNum); i++)
            {
                Variable variable = configRoot.GetSection($"Variable:{i}").Get<Variable>();
                CommonMethods.AllVarList.Add(variable);
            }
            //给combox加入变量
            foreach (var item in CommonMethods.AllVarList)
            {
                this.comboBox1.Invoke(() =>
                {
                    this.comboBox1.Items.Add(item.Name);
                });
                CommonMethods.CurrentPLCValue.Add(item.Name, item.Value);
                CommonMethods.CurrentPLCNote.Add(item.Name, item.VarType);
            }
        }

        private void btnConn_Click(object sender, EventArgs e)
        {
            tcpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            tcpClient.Connect(IPAddress.Parse(CommonMethods.Ip), int.Parse(CommonMethods.Port));
            CommonMethods.IsConnected = tcpClient.Connected;
            CommonMethods.FirstConnect = false;
            Addinfo(CommonMethods.IsConnected ? "连接成功" : "连接失败");
        }


        private void Addinfo(string info)
        {
            this.isInfo.Items.Insert(
                0, DateTime.Now.ToString("HH:mm:ss") + " " + info + Environment.NewLine);
        }

        private void btnRead_Click(object sender, EventArgs e)
        {
            Task.Run( () =>
            {
                while (!cts.IsCancellationRequested)
                {
                    Task.Delay(200);
                    byte[] buffer = new byte[1024 * 1024 * 10];
                    int length = -1;
                    try
                    {
                        length = tcpClient.Receive(buffer, SocketFlags.None);
                    }
                    catch (Exception)
                    {
                        break;
                    }
                    
                    if (length > 0)
                    {
                        string msg = string.Empty;
                        string msg2 = string.Empty;
                        MessageType type = (MessageType)buffer[0];

                        msg = Encoding.ASCII.GetString(buffer, 1, length - 1);

                        msg2 = Encoding.ASCII.GetString(buffer, 0, length);
                        //UTF8:
                        //msg = Encoding.UTF8.GetString(buffer, 1, length - 1);

                        //hex:
                        //msg = HexGetString(buffer, 1, length - 1);



                        AddLog(0, "服务器：" + msg);
                        AddLog2(0, "服务器：" + msg2);
                        //switch (type)
                        //{
                        //    case MessageType.ASCII:

                        //        msg = Encoding.ASCII.GetString(buffer, 1, length - 1);

                        //        AddLog(0, "服务器：" + msg);

                        //        break;
                        //    case MessageType.UTF8:

                        //        msg = Encoding.UTF8.GetString(buffer, 1, length - 1);

                        //        AddLog(0, "服务器：" + msg);

                        //        break;
                        //    case MessageType.Hex:

                        //        msg = HexGetString(buffer, 1, length - 1);

                        //        AddLog(0, "服务器：" + msg);

                        //        break;
                        //    case MessageType.File:

                        //        Invoke(new Action(() =>
                        //        {
                        //            SaveFileDialog sfd = new SaveFileDialog();

                        //            sfd.Filter = "txt files(*.txt)|*.txt|xls files(*.xls)|*.xls|xlsx files(*.xlsx)|*.xlsx|All files(*.*)|*.*";

                        //            if (sfd.ShowDialog() == DialogResult.OK)
                        //            {
                        //                string fileSavePath = sfd.FileName;

                        //                using (FileStream fs = new FileStream(fileSavePath, FileMode.Create))
                        //                {
                        //                    fs.Write(buffer, 1, length - 1);
                        //                }

                        //                AddLog(0, "文件成功保存至" + fileSavePath);
                        //            }
                        //        }));

                        //        break;
                        //    case MessageType.JSON:


                        //        break;
                        //    default:
                        //        break;
                        //}
                    }




                    //byte[] result = new byte[CommonMethods.ByteLenth / 2];
                    //byte[] setArray1 = new byte[CommonMethods.ByteLenth / 2];
                    //string msg = string.Empty;
                    //this.setArray = setArray1;
                    //if (length > 0) //100 =100
                    //{
                    //    //数据源, 数据源开始索引, 目标数据,目标数据开始索引, 长度
                    //    Array.Copy(buffer, 0, result, 0, CommonMethods.ByteLenth / 2);
                    //    //setArray = ByteArrayLib.GetByteArrayFromByteArray(buffer, CommonMethods.ByteLenth / 2, CommonMethods.ByteLenth / 2);
                    //    setArray = ByteArrayLib.GetByteArrayFromByteArray(buffer, 0, CommonMethods.ByteLenth / 2);
                    //    foreach (var item in CommonMethods.AllVarList)
                    //    {
                    //        int start = item.VarAddress * 2;
                    //        switch (item.VarType)
                    //        {
                    //            case DataType.Bool:
                    //                item.Value = BitLib.GetBitFromByteArray(result, start, int.Parse(item.Offset)).ToString();
                    //                break;
                    //            case DataType.Short:
                    //                item.Value = ShortLib.GetShortFromByteArray(result, start).ToString();
                                    
                    //                break;
                    //            case DataType.UShort:
                    //                item.Value = UShortLib.GetUShortFromByteArray(result, start).ToString();
                    //                break;
                    //            case DataType.Int:
                    //                item.Value = IntLib.GetIntFromByteArray(result, start).ToString();
                    //                break;
                    //            case DataType.UInt:
                    //                item.Value = UIntLib.GetUIntFromByteArray(result, start).ToString();
                    //                break;
                    //            case DataType.Float:
                    //                item.Value = FloatLib.GetFloatFromByteArray(result, start).ToString();
                    //                break;
                    //            case DataType.Double:
                    //                item.Value = DoubleLib.GetDoubleFromByteArray(result, start).ToString();
                    //                break;
                    //            case DataType.ASCII:
                    //                break;
                    //            default:
                    //                break;
                    //        }
                    //        //包含就替换，否则就添加
                    //        if (CommonMethods.CurrentPLCValue.ContainsKey(item.Name))
                    //        {
                    //            CommonMethods.CurrentPLCValue[item.Name] = item.Value;

                    //        }
                    //        else
                    //        {
                    //            CommonMethods.CurrentPLCValue.Add(item.Name, item.Value);
                    //        }
                    //    }
                    //}

                    //foreach (var item in CommonMethods.CurrentPLCValue)
                    //{
                    //    this.isInfo.Invoke(() =>
                    //    {
                    //        this.isInfo.Items.Add(item.Key+":");
                    //        this.isInfo.Items.Add(item.Value.ToString());
                    //    });
                    //};
                    //Task.Delay(200);
                    //Invoke(new Action(() =>
                    //{
                    //    foreach (Control item in this.Controls)
                    //    {
                    //        //if (item is TextBox txt)
                    //        //{
                    //        //    item.Text = CommonMethods.CurrentPLCValue[this.comboBox1.Text].ToString();
                    //        //}
                    //        if (item is LabelShow ls)
                    //        {
                    //            for (int i = 0; i < 12; i++)
                    //            {
                    //                if (ls.VarTitle == $"UShort{i}")
                    //                {
                    //                    ls.VarValue = CommonMethods.CurrentPLCValue[$"UShort{i}"].ToString();
                    //                }
                    //            }
                    //        }
                    //    }
                    //}
                    //));

                }

            }, cts.Token);
        }

        #region 16进制字符串处理

        private string HexGetString(byte[] buffer, int start, int length)
        {
            string Result = string.Empty;

            if (buffer != null && buffer.Length >= start + length)
            {
                //截取字节数组

                byte[] res = new byte[length];

                Array.Copy(buffer, start, res, 0, length);

                string Hex = Encoding.Default.GetString(res, 0, res.Length);

                // 01   03 0 40 0A
                if (Hex.Contains(" "))
                {
                    string[] str = Regex.Split(Hex, "\\s+", RegexOptions.IgnoreCase);

                    foreach (var item in str)
                    {
                        Result += "0x" + item + " ";
                    }
                }
                else
                {
                    Result += "0x" + Hex;
                }

            }
            else
            {
                Result = "Error";
            }
            return Result;
        }


        #endregion

        //当前时间属性
        private string CurrentTime
        {
            get { return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); }
        }

        private void AddLog(int index, string info)
        {
            if (!this.lst_Rcv.InvokeRequired)
            {
                ListViewItem lst = new ListViewItem("   " + CurrentTime, index);

                lst.SubItems.Add(info);

                lst_Rcv.Items.Insert(lst_Rcv.Items.Count, lst);

            }
            else
            {
                Invoke(new Action(() =>
                {
                    ListViewItem lst = new ListViewItem("   " + CurrentTime, index);

                    lst.SubItems.Add(info);

                    lst_Rcv.Items.Insert(lst_Rcv.Items.Count, lst);
                }));
            }
        }

        private void AddLog2(int index, string info)
        {
            if (!this.lst_Rcv1.InvokeRequired)
            {
                ListViewItem lst = new ListViewItem("   " + CurrentTime, index);

                lst.SubItems.Add(info);

                lst_Rcv1.Items.Insert(lst_Rcv1.Items.Count, lst);

            }
            else
            {
                Invoke(new Action(() =>
                {
                    ListViewItem lst = new ListViewItem("   " + CurrentTime, index);

                    lst.SubItems.Add(info);

                    lst_Rcv1.Items.Insert(lst_Rcv1.Items.Count, lst);
                }));
            }
        }

        private void btnServer_Click(object sender, EventArgs e)
        {
            frmServer = new FrmServer();
            frmServer.ShowDialog();
        }

        private void btnDisc_Click(object sender, EventArgs e)
        {
            try
            {
                tcpClient.Close();
                CommonMethods.IsConnected = tcpClient.Connected;
                //CommonMethods.IsConnected = false;
                Addinfo(CommonMethods.IsConnected ? "没有断开" : "断开成功");
            }
            catch (Exception)
            {

                throw;
            }
        }

        private void btnWrite1_Click(object sender, EventArgs e)
        {
            List<byte> res = new List<byte>();
            //byte[] res;
            string varName = this.comboBox1.Text;
            float valueF1 = Convert.ToSingle(this.txt1.Text.Trim());
            ushort valueS = Convert.ToUInt16(Math.Floor(double.Parse(this.txt1.Text.Trim())));
            int varAddress = 0;
            switch (CommonMethods.CurrentPLCNote[varName])
            {
                case DataType.UShort:
                    res = ByteArrayLib.GetByteArrayFromUShort(valueS).ToList();
                    break;
                case DataType.Float:
                    res = ByteArrayLib.GetByteArrayFromFloat(valueF1).ToList();
                    break;
                default:
                    break;
            }

            foreach (var item in CommonMethods.AllVarList)
            {
                if (item.Name==this.comboBox1.Text)
                {
                    varAddress = item.VarAddress;
                }
            }

            byte[] set = ByteArrayLib.ReplaceByteArray(setArray, varAddress*2, res.ToArray());
            tcpClient.Send(set, SocketFlags.None);
        }

        public byte[] ReplaceByteArray(byte[] source, int start, byte[] value)
        {
            for (int i = 0; i < value.Length; i++)
            {
                source[start + i] = value[i];
            }
            return source;
        }

        private void btnSendASC_Click(object sender, EventArgs e)
        {
            AddLog(0, "发送内容：" + this.txt_Send.Text.Trim());
            byte[] send = Encoding.ASCII.GetBytes(this.txt_Send.Text.Trim());

            //创建最终发送的数组
            byte[] sendMsg = new byte[send.Length + 1];

            //整体拷贝数组
            Array.Copy(send, 0, sendMsg, 1, send.Length);

            //给首字节赋值

            sendMsg[0] = (byte)MessageType.ASCII;

            tcpClient?.Send(sendMsg);

            this.txt_Send.Clear();
        }

        private void btnSendASC2_Click(object sender, EventArgs e)
        {
            AddLog(0, "发送内容：" + this.txt_Send.Text.Trim());
            byte[] send = Encoding.ASCII.GetBytes(this.txt_Send.Text.Trim());

            //UTF8:
            //byte[] send = Encoding.UTF8.GetBytes(this.txt_Send.Text.Trim());

            //hex
            //byte[] send = Encoding.Default.GetBytes(this.txt_Send.Text.Trim());

            tcpClient?.Send(send);

            this.txt_Send.Clear();
        }
    }
}

服务器端主程序

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using thinger.DataConvertLib;

namespace STM32Demon
{
    public partial class FrmServer : Form
    {
        public FrmServer()
        {
            InitializeComponent();
            this.Load += FrmServer_Load;
        }

        private void FrmServer_Load(object? sender, EventArgs e)
        {
            //给combox加入变量
            foreach (var item in CommonMethods.AllVarList)
            {
                this.comboBox1.Invoke(() =>
                {
                    this.comboBox1.Items.Add(item.Name);
                });
            }
        }

        private Socket tcpServer;

        private CancellationTokenSource cts;

        private byte[] setArray;

        private List<Socket> SocketList = new List<Socket>();

        private void Addinfo(string info)
        {
            this.isInfo.Items.Insert(
                0, DateTime.Now.ToString("HH:mm:ss") + " " + info + Environment.NewLine);
        }


        private void btnCeate_Click(object sender, EventArgs e)
        {
            tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(CommonMethods.CreateIp), int.Parse(CommonMethods.CreatePort));
            try
            {
                tcpServer.Bind(ipe);
            }
            catch (Exception)
            {
                MessageBox.Show("服务器开启失败");
                return;
            }
            MessageBox.Show("服务器开启成功");

            tcpServer.Listen(6);
            //开启多线程侦听

            Task.Run(new Action(() =>
            {
                ListenConnection();

            }));
        }

        private void ListenConnection()
        {
            while (true)
            {
                Task.Delay(500);

                try
                {
                    //创建一个新的socket连接
                    Socket tcpClient = tcpServer.Accept();

                    SocketList.Add(tcpClient);

                    Task.Run(new Action(() =>
                    {
                        ReceiveFromPLC(tcpClient);
                    }));
                }
                catch (Exception)
                {
                    break;
                }
            }
        }

        private void ReceiveFromPLC(Socket tcpClient)
        {
            while (true)
            {
                Task.Delay(200);
                byte[] buffer = new byte[1024];
                int length = -1;
                try
                {
                    length = tcpClient.Receive(buffer, SocketFlags.None);
                }
                catch (Exception)
                {
                    break;
                }

                byte[] result = new byte[CommonMethods.ByteLenth / 2];
                byte[] setArray1 = new byte[CommonMethods.ByteLenth / 2];
                this.setArray = setArray1;
                if (length == CommonMethods.ByteLenth) //100 =100
                {
                    //数据源, 数据源开始索引, 目标数据,目标数据开始索引, 长度
                    Array.Copy(buffer, 0, result, 0, CommonMethods.ByteLenth / 2);
                    setArray = ByteArrayLib.GetByteArrayFromByteArray(buffer, CommonMethods.ByteLenth / 2, CommonMethods.ByteLenth / 2);

                    foreach (var item in CommonMethods.AllVarList)
                    {
                        int start = item.VarAddress * 2;
                        switch (item.VarType)
                        {
                            case DataType.Bool:
                                item.Value = BitLib.GetBitFromByteArray(result, start, int.Parse(item.Offset)).ToString();
                                break;
                            case DataType.Short:
                                item.Value = ShortLib.GetShortFromByteArray(result, start).ToString();

                                break;
                            case DataType.UShort:
                                item.Value = UShortLib.GetUShortFromByteArray(result, start).ToString();
                                break;
                            case DataType.Int:
                                item.Value = IntLib.GetIntFromByteArray(result, start).ToString();
                                break;
                            case DataType.UInt:
                                item.Value = UIntLib.GetUIntFromByteArray(result, start).ToString();
                                break;
                            case DataType.Float:
                                item.Value = FloatLib.GetFloatFromByteArray(result, start).ToString();
                                break;
                            case DataType.Double:
                                item.Value = DoubleLib.GetDoubleFromByteArray(result, start).ToString();
                                break;
                            default:
                                break;
                        }
                        //包含就替换，否则就添加
                        if (CommonMethods.CurrentPLCValue.ContainsKey(item.Name))
                        {
                            CommonMethods.CurrentPLCValue[item.Name] = item.Value;

                        }
                        else
                        {
                            CommonMethods.CurrentPLCValue.Add(item.Name, item.Value);
                        }
                    }
                }

                foreach (var item in CommonMethods.CurrentPLCValue)
                {
                    this.isInfo.Invoke(() =>
                    {
                        this.isInfo.Items.Add(item.Key + ":");
                        this.isInfo.Items.Add(item.Value.ToString());
                    });
                };
                Task.Delay(200);
                Invoke(new Action(() =>
                {
                    foreach (Control item in this.Controls)
                    {
                        //if (item is TextBox txt)
                        //{
                        //    item.Text = CommonMethods.CurrentPLCValue[this.comboBox1.Text].ToString();
                        //}
                        if (item is LabelShow ls)
                        {
                            if (ls.VarTitle == "Float1")
                            {
                                ls.VarValue = CommonMethods.CurrentPLCValue["Float1"].ToString();
                            }
                            if (ls.VarTitle == "Float2")
                            {
                                ls.VarValue = CommonMethods.CurrentPLCValue["Float2"].ToString();
                            }
                            if (ls.VarTitle == "Float3")
                            {
                                ls.VarValue = CommonMethods.CurrentPLCValue["Float3"].ToString();
                            }
                            if (ls.VarTitle == "Float4")
                            {
                                ls.VarValue = CommonMethods.CurrentPLCValue["Float4"].ToString();
                            }
                            if (ls.VarTitle == "UShort1")
                            {
                                ls.VarValue = CommonMethods.CurrentPLCValue["UShort1"].ToString();
                            }
                            if (ls.VarTitle == "UShort2")
                            {
                                ls.VarValue = CommonMethods.CurrentPLCValue["UShort2"].ToString();
                            }
                        }
                    }
                }
                ));
            }
        }

        private void btnWrite1_Click(object sender, EventArgs e)
        {
            List<byte> res = new List<byte>();
            //byte[] res;
            string varName = this.comboBox1.Text;
            float valueF1 = Convert.ToSingle(this.txt1.Text.Trim());
            ushort valueS = Convert.ToUInt16(Math.Floor(double.Parse(this.txt1.Text.Trim())));
            int varAddress = 0;
            switch (CommonMethods.CurrentPLCNote[varName])
            {
                case DataType.UShort:
                    res = ByteArrayLib.GetByteArrayFromUShort(valueS).ToList();
                    break;
                case DataType.Float:
                    res = ByteArrayLib.GetByteArrayFromFloat(valueF1).ToList();
                    break;
                default:
                    break;
            }

            foreach (var item in CommonMethods.AllVarList)
            {
                if (item.Name == this.comboBox1.Text)
                {
                    varAddress = item.VarAddress;
                }
            }

            byte[] set = ByteArrayLib.ReplaceByteArray(setArray, varAddress * 2, res.ToArray());
            //tcpClient.Send(set, SocketFlags.None);
            this.SocketList[0].Send(set, SocketFlags.None);
        }

        public byte[] ReplaceByteArray(byte[] source, int start, byte[] value)
        {
            for (int i = 0; i < value.Length; i++)
            {
                source[start + i] = value[i];
            }
            return source;
        }
    }
}

实体类 Model

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using thinger.DataConvertLib;

namespace STM32Demon.Models
{
    public class Variable
    {
        public int Id { get; set; }
        public string Number { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public string Type { get; set; }
        public int VarAddress { get; set; }
        public string Scale { get; set; }
        public string Offset { get; set; }
        public string Start { get; set; }
        public string AccessProperty { get; set; }
        public DataType VarType { get; set; }
        public string InsertTime { get; set; }
        public string Value { get; set; }
    }
}

通用类

using Microsoft.EntityFrameworkCore.Query;
using STM32Demon.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using thinger.DataConvertLib;

namespace STM32Demon
{
    public class CommonMethods
    {
        public static Dictionary<string, object> CurrentPLCValue = new Dictionary<string, object>();

        //归档变量集合
        public static List<Variable> ArchiveVarList = new List<Variable>();

        //所有
        public static List<Variable> AllVarList = new List<Variable>();
        /// <summary>
        /// 键值对，键是变量名称，值是其对应的变量实体对象 用来写数据
        /// </summary>
        public static Dictionary<string, Variable> CurrentPLCVariable = new Dictionary<string, Variable>();

        /// <summary>
        /// 变量名称和变量地址的键值对
        /// </summary>
        public static Dictionary<string, DataType> CurrentPLCNote = new Dictionary<string, DataType>();

        public static bool IsConnected = false;

        public static int CacheCount = 600;//10分钟, 每秒一条

        //public static IIncludableQueryable<NodeClass, IEnumerable<Variable>> ModbusTCPList;
        public static int ErrorTimes = 0;
        public static bool FirstConnect = true;
        public static string Ip;
        public static string Port;
        public static string VarNum;
        public static int ByteLenth;
    }
}

博途程序 :

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

"TCPServerSendData".Float1 := "TCPServerSendData".Float5;
"TCPServerSendData".Float2 := "TCPServerSendData".Float6;
"TCPServerSendData".Float3 := "TCPServerSendData".Float7;
"TCPServerSendData".Float4 := "TCPServerSendData".Float8;
"TCPServerSendData".Ushort1 := "TCPServerSendData".Ushort3;
"TCPServerSendData".Ushort2 := "TCPServerSendData".Ushort4;

在这里插入图片描述
在这里插入图片描述

潘诺西亚的火山
关注
S7.Net与西门子PLC通讯
xdpcxq的专栏
12-31 1163
/ eg: 比如最后一个DBW是16，那么数据类型长度为2，count就需要传18才能获取到。（真心的，谁想到还能仿真模拟设备）西门子官方管理设备数据块的客户端，每一个项目等同于一个设备型号，可以理解为是我们经常使用的数据块客户端。第四步：开始仿真，点击之后会自动打开S7-PLCSIM，根据提示点击“装载”，点“完成”第三步：添加数据类型之后，点击编辑，生成偏移量（Offset），后面获取单个数值时需要。创建一个仿真的模拟环境，使用TIA Portal进行调用，控制仿真设备的运行停止。
使用LabVIEW和C#VS开源协议库，实现西门子PLC全系列与SMART网口TCP通讯
cpOhoNVCPA的博客
04-27 535
通过这种方式，我们可以轻松地实现LabVIEW与西门子PLC之间的数据交换和控制指令的发送。同时，通过使用C#VS开源协议库提供的函数和方法，我们可以方便地设置通讯参数和读取写入PLC的数据。通过在LabVIEW中调用C#VS开源协议库的函数，我们可以方便地设置这些参数，并确保与PLC的通讯正常进行。通过本文的介绍，相信读者对LabVIEW 网口通讯、西门子网络通讯以及C#VS开源协议库的应用有了更深入的了解。需要注意的是，LabVIEW与西门子PLC的通讯过程中，需要遵循一定的通讯协议和规范。
西门子PLC通过TCP协议的数据采集方案
09-05
西门子s7-300/400通过加装以太网模块（自带网口的可直接通讯），利用TCP协议，与服务器进行数据交互。
基于.NET（C#）的西门子PLC读写组件
08-20
基于.NET（C#）的西门子PLC读写组件，直接引用S7.Net.dll文件即可使用，有演示代码。亲测可以用。
手摸手教你撕碎西门子S7通讯协议06--S7Read读取short数据
最新发布
hqwest的专栏
07-29 472
根据上节读取bool数据，可以想想如何读取short数据，报文拼装方面要改哪些地方，希望通过这节动手，加深对报文的理解。什么是short类型，PLC中的word类型就是C#中的short类型，它是指int16格式的数据，包括有符号和无符号整数，但不包括小数，比如459，-832。通过观察可以得知以下几点：1》发送报文在序号22的Transport size这个地方不同，再来看下这个具体值，S7Parameter->Item->Transport size常见值，所以应该是0x04。
西门子1500更改IP地址
热门推荐
weixin_43572650的博客
12-11 1万+
1500更改IP地址的方法 1.通过博图软件的在线访问如下图所示设置（需先将PLC置为STOP），临时的设置，PLC的IP地址确实改变了，PLC的MAINT黄色指示灯常亮，当PLC断电重启后IP地址恢复之前的。 2.通过PLC的面板进行IP设置，（需先将PLC置为STOP），临时的设置，PLC的IP地址确实改变了，PLC的MAINT黄色指示灯常亮，当PLC断电重启后IP地址恢复之前的。 3.组态下更改IP地址（永久更改，推荐使用）。 ...
西门子S7-1200/1500对接MySQL数据库，实现数据上报与查询
PLC通讯智能网关
07-07 5102
IGT-SER系列智能网关模块，支持各种PLC、智能仪表、远程IO与数据库之间双向通讯，既可以读取设备的数据上报到SQL数据库，也可以从数据库查询数据后写入到设备；数据库软件支持MySQL、SQLServer、PostgreSQL。相关软件和手册下载 网关安装在设备侧，与设备同时起停，不担心数据丢失；在断网、服务器维护上报数据有异常时，网关主动将数据缓存，待故障解除后自动重新上报到数据库；网关也支持多服务器冗余、异常未提交数据本地保存等功能，确保数据安全；已批量用于多种行业的智能工厂，...
基于C#开放式TCP通信建立与西门子PLC的socket通信示例.rar
04-06
在本文中，我们将深入探讨如何使用C#编程语言构建一个基于TCP/IP协议的开放式通信系统，以便与西门子PLC（可编程逻辑控制器）进行Socket通信。这是一项至关重要的技能，特别是在工业自动化和物联网(IoT)领域，因为...
一台三菱PLC与2台西门子通信.rar
08-31
在三菱PLC中，需要编写相应的程序来读取和写入西门子PLC的数据寄存器。 通信步骤大致如下： 1. **配置通信接口**：确保所有PLC的物理连接正确，例如使用RS485转以太网模块，将三菱PLC与西门子PLC连接在同一网络上...
西门子smartclient怎么用_西门子s7-200smart modbus-tcp通信实例编程详细指导
weixin_29391349的博客
12-23 6231
西门子s7-200smart modbus-tcp通信实例编程详细指导2020-11-24西门子S7-200Modbus-TCP通信例子【】绝密【】NDA【X】公开一、 组网概述本文以 ZKA-4488-ETH 为例介绍西门子PLC与深圳市综科智控科技开发有限公司的IO设备进行Modbus通讯的步骤设置。ZKA-4488-ETH 是 8 路数字量输入(DI)，8 路数字量输出(DO)，4路模拟量输...
基于TIA Portal下的TCP通讯的方法
08-22
- 在“数据区域”中，指定发送的数据来源，例如从PLC的某个变量表读取数据。 - **第三步：引脚配置** - 配置发送功能块的输入输出引脚，确保数据能够正确地被发送出去。某些参数可能是系统自动生成的。 ##### 2...
C#直接读写西门子PLC类库——S7.net
02-28
C#基于.net直接访问西门子PLC的类库——S7.net，可以实现西门子200含Smart、300、1200、1500寄存器地址的直接读写操作
西门子PLC s-1200、s-1500通讯,西门子1500与1200通讯,C#
06-12
VB、C#等PC高级语言与西门子PLC（S7-200Smart、S7-1200、S7-1500、S7-300、S7-400等）以太网、串口通讯
.NET6 Socket编程实现内网穿透.zip
05-16
.NET6 Socket编程实现内网穿透，UDP,TCP打洞实现点对点直连，通过tcp转发，http1.1代理，socks5代理，实现访问内网web ，内网桌面，及其它TCP上层协议服务 .NET6 Socket编程实现内网穿透，UDP,TCP打洞实现点对点直连，通过tcp转发，http1.1代理，socks5代理，实现访问内网web ，内网桌面，及其它TCP上层协议服务 .NET6 Socket编程实现内网穿透，UDP,TCP打洞实现点对点直连，通过tcp转发，http1.1代理，socks5代理，实现访问内网web ，内网桌面，及其它TCP上层协议服务 .NET6 Socket编程实现内网穿透，UDP,TCP打洞实现点对点直连，通过tcp转发，http1.1代理，socks5代理，实现访问内网web ，内网桌面，及其它TCP上层协议服务 .NET6 Socket编程实现内网穿透，UDP,TCP打洞实现点对点直连，通过tcp转发，http1.1代理，
C#简单实现实现TCP服务器多线程数据接收
lzl640的博客
07-05 8228
1、引入依赖库，无需第三方。 using System; using System.Collections.Generic; using System.Data; using System.IO; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; using System.Windows.Forms; 2、变量声明 /// <summary>
.NET6 supersocket 全双工发送和接收消息
festone000的专栏
08-27 2254
C# , .NET6, supersocket 2 全双工通信示例.
vb.net 教程 7-1 本地网络信息的获取 6 Tcp/Udp统计数据
chinaherolts2008的博客
09-12 225
版权声明：本文为博主原创文章，转载请在显著位置标明本文出处以及作者网名，未经作者允许不得用于商业目的。 通过 IPGlobalProperties的GetTcpIPv4Statistics、GetTcpIPv6Statistics、GetUdpIPv4Statistics、GetUdpIPv6Statistics方法可以获得对应的TCP和UDP统计信息： 具体代码如下； Private Sub Button5_Click(sender As Object, e As EventArgs) H..
c#使用s7netplus读取plc数据
qq_53217825的博客
09-12 1万+
这里的环境使用的是.net core 控制台程序首先在使用的地方引用数据类涉及到最后的转换。需要留意以上一篇文章博途数据块为例：点击转至在线》点击第二个点。监视数据块中的值的变化图中偏移量为所在数据块的位置，与下一个数据相隔的偏移量为占用的字节可以看到a值读取到设置的初始值false在第2步中修改了bool值之后，博途软件中监视值换成了true以上代码读取一次会重新建立一个tcp连接，非常消耗资源。在实际开发中不建议使用在途中第一个参数，标识数据块类型。第二个标识数据块。
C#直接与S7-200Smart、S7-300/400、S7-1200/1500以太网、PPI、MPI通讯
u012172195的博客
04-17 6952
C#直接与S7-200Smart、S7-300/400、S7-1200/1500以太网、PPI、MPI通讯 1.0 通讯组件概述 该类通讯组件适用于基于PC高级语言的工业自动化控制系统，用于PC与可编程控制器(PLC)、智能仪表等进行数据通讯。组件采用动态链接库文件(*.DLL)的形式，在PC系统的项目工程里引用该组件，调用相应的属性与方法函数，即可快速实现PC与PLC的数据高效交换。 DL...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值