C# 三菱FX PLC XYS读写，串口读写

已于 2023-08-13 12:31:27 修改
阅读量1.8k 收藏 18
点赞数 5
文章标签： c# PLC
于 2022-03-15 08:51:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34677276/article/details/123493397
版权

花了两三天写了一个这个，本来想着自己用的，看到有很多替代品，果断开源了吧:
下载地址:https://github.com/t39q/MitsubishiFX-PLC-XYS
以下是原理，后面有帮助类和调用方法
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
调用方法

 private void button27_Click(object sender, EventArgs e)
        {
            //开，置位 
            string address = textBox3.Text.Substring(0, 1);
            if (address == "Y")
            {
                MitsubishiPLC_XYControl.SendControlCmd(PLC_SerialPort, MitsubishiPLC_XYControl.OpenY(textBox3.Text));
            }
            else if (address=="X")
            {
                MitsubishiPLC_XYControl.SendControlCmd(PLC_SerialPort, MitsubishiPLC_XYControl.OpenX(textBox3.Text));
            }
            else if (address == "S")
            {
                MitsubishiPLC_XYControl.SendControlCmd(PLC_SerialPort, MitsubishiPLC_XYControl.OpenS(textBox3.Text));
            }
        }

        private void button28_Click(object sender, EventArgs e)
        {
            //关，复位
            string address = textBox3.Text.Substring(0, 1);
            if (address == "Y")
            {
                MitsubishiPLC_XYControl.SendControlCmd(PLC_SerialPort, MitsubishiPLC_XYControl.CloseY(textBox3.Text));
            }
            else if (address == "S")
            {
                MitsubishiPLC_XYControl.SendControlCmd(PLC_SerialPort, MitsubishiPLC_XYControl.CloseS(textBox3.Text));
            }
        }

        private void button26_Click(object sender, EventArgs e)
        {
            //读
            string address = textBox3.Text.Substring(0, 1);
            if (address == "X")
            {
                textBox4.Text= MitsubishiPLC_XYControl.ReadXStatus(PLC_SerialPort, textBox3.Text);
            }
            else if (address == "S")
            {
                textBox4.Text = MitsubishiPLC_XYControl.ReadSStatus(PLC_SerialPort, textBox3.Text);
            }
        }

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace 三菱PLC_XY控制
{
    class MitsubishiPLC_XYControl
    {
        public static byte[] OpenY(string Y)
        {
            //bool Flag = false;
            byte[] OpenByte = new byte[9];
            byte[] YAddressByte = GetYAddress(Y);
            OpenByte[0] = 0x02;
            OpenByte[1] = 0x37;
            OpenByte[2] = YAddressByte[0];
            OpenByte[3] = YAddressByte[1]; 
            OpenByte[4] = YAddressByte[2]; 
            OpenByte[5] = YAddressByte[3];
            OpenByte[6] = 0x03;
            byte[] CheckSumByte = new byte[6];
            for (int i = 1; i < CheckSumByte.Length+1; i++)
            {
                CheckSumByte[i-1] = OpenByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            OpenByte[7] = Check2Byte[0];
            OpenByte[8] = Check2Byte[1];
            return OpenByte;
        }
        public static byte[] OpenX(string X)
        {
            //bool Flag = false;
            byte[] OpenByte = new byte[9];
            byte[] XAddressByte = GetXAddress(X);
            OpenByte[0] = 0x02;
            OpenByte[1] = 0x37;
            OpenByte[2] = XAddressByte[0];
            OpenByte[3] = XAddressByte[1];
            OpenByte[4] = XAddressByte[2];
            OpenByte[5] = XAddressByte[3];
            OpenByte[6] = 0x03;
            byte[] CheckSumByte = new byte[6];
            for (int i = 1; i < CheckSumByte.Length + 1; i++)
            {
                CheckSumByte[i - 1] = OpenByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            OpenByte[7] = Check2Byte[0];
            OpenByte[8] = Check2Byte[1];
            return OpenByte;
        }
        public static byte[] OpenS(string S)
        {
            //bool Flag = false;
            byte[] OpenByte = new byte[9];
            byte[] SAddressByte = GetSAddress(S);
            OpenByte[0] = 0x02;
            OpenByte[1] = 0x37;
            OpenByte[2] = SAddressByte[0];
            OpenByte[3] = SAddressByte[1];
            OpenByte[4] = SAddressByte[2];
            OpenByte[5] = SAddressByte[3];
            OpenByte[6] = 0x03;
            byte[] CheckSumByte = new byte[6];
            for (int i = 1; i < CheckSumByte.Length + 1; i++)
            {
                CheckSumByte[i - 1] = OpenByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            OpenByte[7] = Check2Byte[0];
            OpenByte[8] = Check2Byte[1];
            return OpenByte;
        }
        public static bool SendControlCmd(SerialPort serialPort,byte[] bytes)
        {
            bool Flag = false;
            for (int i = 0; i < 3; i++)
            {
                try
                {
                    serialPort.Write(bytes, 0, bytes.Length);
                    Thread.Sleep(50);
                    byte[] RcvBytes = new byte[1];
                    serialPort.Read(RcvBytes, 0, 1);
                    if (RcvBytes[0] != 6)
                    {
                        continue;
                    }
                    else
                    {
                        Flag = true;
                        break;
                    }
                }
                catch (Exception)
                {
                    continue;
                    //throw;
                }
                
            }
            return Flag;
        }
        public static string ReadXStatus(SerialPort serialPort, string X)
        {
            string OutResult = "";
            string Result = "";
            if (MitsubishiPLC_XYControl.SendReadCmd(serialPort, MitsubishiPLC_XYControl.ReadX(X),
                X, out OutResult))
            {
                Result = OutResult;
            }
            else
            {
                Result = "-1";
            }
            return Result;
        }
        public static string ReadSStatus(SerialPort serialPort, string S)
        {
            string OutResult = "";
            string Result = "";
            if (MitsubishiPLC_XYControl.SendReadCmdS(serialPort, MitsubishiPLC_XYControl.ReadS(S),
                S, out OutResult))
            {
                Result = OutResult;
            }
            else
            {
                Result = "-1";
            }
            return Result;
        }
        public static bool SendReadCmd(SerialPort serialPort, byte[] bytes,string X,out string Result)
        {
            string BinResult="";
            Result = "";
            bool Flag = false;
            for (int j = 0; j < 3; j++)
            {
                try
                {
                    serialPort.Write(bytes, 0, bytes.Length);
                    Thread.Sleep(50);
                    byte[] RcvBytes = new byte[8];
                    serialPort.Read(RcvBytes, 0, RcvBytes.Length);
                    byte[] CheckSumByte = new byte[5];
                    for (int i = 1; i < CheckSumByte.Length + 1; i++)
                    {
                        CheckSumByte[i - 1] = RcvBytes[i];
                    }
                    byte[] Check2Byte = new byte[2];
                    Check2Byte = CheckSum(CheckSumByte);
                    if (RcvBytes[6] == Check2Byte[0] &&
                    RcvBytes[7] == Check2Byte[1])
                    {
                        //02 30 41 38 30 03 44 43   
                        // 从第二个字节算起，顺序为1032，38 30 30 41
                        //当进行按字节转换为ASCII时，高位在右边
                        byte[] ResultByte = new byte[4];
                        ResultByte[0] = RcvBytes[3]; //3
                        ResultByte[1] = RcvBytes[4]; //2
                        ResultByte[2] = RcvBytes[1]; //1
                        ResultByte[3] = RcvBytes[2]; //0
                        string HexResult = Encoding.ASCII.GetString(ResultByte);
                        BinResult = Convert.ToString(Convert.ToInt32(HexResult, 16), 2).PadLeft(16, '0');
                        BinResult = BinResult.Substring(BinResult.Length - 8, 8);
                        Result = JudgingByBit(BinResult, X);
                        Flag = true;
                        break;
                    }
                    else
                    {
                        continue;
                    }
                }
                catch (Exception)
                {
                    continue;
                    //throw;
                }
                
            }
            return Flag;
        }
        public static bool SendReadCmdS(SerialPort serialPort, byte[] bytes, string S, out string Result)
        {
            string BinResult = "";
            Result = "";
            bool Flag = false;
            for (int j = 0; j < 3; j++)
            {
                try
                {
                    serialPort.Write(bytes, 0, bytes.Length);
                    Thread.Sleep(50);
                    byte[] RcvBytes = new byte[8];
                    serialPort.Read(RcvBytes, 0, RcvBytes.Length);
                    byte[] CheckSumByte = new byte[5];
                    for (int i = 1; i < CheckSumByte.Length + 1; i++)
                    {
                        CheckSumByte[i - 1] = RcvBytes[i];
                    }
                    byte[] Check2Byte = new byte[2];
                    Check2Byte = CheckSum(CheckSumByte);
                    if (RcvBytes[6] == Check2Byte[0] &&
                    RcvBytes[7] == Check2Byte[1])
                    {
                        byte[] ResultByte = new byte[4];
                        //02 30 41 38 30 03 44 43   
                        // 从第二个字节算起，顺序为1032，38 30 30 41
                        //当进行按字节转换为ASCII时，高位在右边
                        ResultByte[0] = RcvBytes[3]; //3
                        ResultByte[1] = RcvBytes[4]; //2
                        ResultByte[2] = RcvBytes[1]; //1
                        ResultByte[3] = RcvBytes[2]; //0
                        string HexResult = Encoding.ASCII.GetString(ResultByte);
                        BinResult= Convert.ToString(Convert.ToInt32(HexResult, 16), 2).PadLeft(16, '0');
                        BinResult = BinResult.Substring(BinResult.Length - 8, 8);
                        Result = JudgingByBitS(BinResult, S);
                        Flag = true;
                        break;
                    }
                    else
                    {
                        continue;
                    }
                }
                catch (Exception)
                {
                    continue;
                    //throw;
                }

            }
            return Flag;
        }
        public static string JudgingByBit(string BinResult,string X)
        {
            char[] BinResultArray = BinResult.ToCharArray();
            string Result = "";
            switch (X)
            {
                case "X0":
                    Result = BinResultArray[7].ToString();
                    break;
                case "X1":
                    Result = BinResultArray[6].ToString();
                    break;
                case "X2":
                    Result = BinResultArray[5].ToString();
                    break;
                case "X3":
                    Result = BinResultArray[4].ToString();
                    break;
                case "X4":
                    Result = BinResultArray[3].ToString();
                    break;
                case "X5":
                    Result = BinResultArray[2].ToString();
                    break;
                case "X6":
                    Result = BinResultArray[1].ToString();
                    break;
                case "X7":
                    Result = BinResultArray[0].ToString();
                    break;
                case "X10":
                    Result = BinResultArray[7].ToString();
                    break;
                case "X11":
                    Result = BinResultArray[6].ToString();
                    break;
                case "X12":
                    Result = BinResultArray[5].ToString();
                    break;
                case "X13":
                    Result = BinResultArray[4].ToString();
                    break;
                case "X14":
                    Result = BinResultArray[3].ToString();
                    break;
                case "X15":
                    Result = BinResultArray[2].ToString();
                    break;
                case "X16":
                    Result = BinResultArray[1].ToString();
                    break;
                case "X17":
                    Result = BinResultArray[0].ToString();
                    break;
            }
            return Result;
        }
        public static string JudgingByBitS(string BinResult, string S)
        {
            char[] BinResultArray = BinResult.ToCharArray();
            string Result = "";
            switch (S)
            {
                case "S0":
                    Result = BinResultArray[7].ToString();
                    break;
                case "S1":
                    Result = BinResultArray[6].ToString();
                    break;
                case "S2":
                    Result = BinResultArray[5].ToString();
                    break;
                case "S3":
                    Result = BinResultArray[4].ToString();
                    break;
                case "S4":
                    Result = BinResultArray[3].ToString();
                    break;
                case "S5":
                    Result = BinResultArray[2].ToString();
                    break;
                case "S6":
                    Result = BinResultArray[1].ToString();
                    break;
                case "S7":
                    Result = BinResultArray[0].ToString();
                    break;
                case "S8":
                    Result = BinResultArray[7].ToString();
                    break;
                case "S9":
                    Result = BinResultArray[6].ToString();
                    break;
                case "S10":
                    Result = BinResultArray[5].ToString();
                    break;
                case "S11":
                    Result = BinResultArray[4].ToString();
                    break;
                case "S12":
                    Result = BinResultArray[3].ToString();
                    break;
                case "S13":
                    Result = BinResultArray[2].ToString();
                    break;
                case "S14":
                    Result = BinResultArray[1].ToString();
                    break;
                case "S15":
                    Result = BinResultArray[0].ToString();
                    break;
            }
            return Result;
        }
        public static byte[] CloseY(string Y)
        {
            //bool Flag = false;
            byte[] OpenByte = new byte[9];
            byte[] YAddressByte = GetYAddress(Y);
            OpenByte[0] = 0x02;
            OpenByte[1] = 0x38;
            OpenByte[2] = YAddressByte[0];
            OpenByte[3] = YAddressByte[1];
            OpenByte[4] = YAddressByte[2];
            OpenByte[5] = YAddressByte[3];
            OpenByte[6] = 0x03;
            byte[] CheckSumByte = new byte[6];
            for (int i = 1; i < CheckSumByte.Length + 1; i++)
            {
                CheckSumByte[i - 1] = OpenByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            OpenByte[7] = Check2Byte[0];
            OpenByte[8] = Check2Byte[1];
            return OpenByte;
        }
        public static byte[] CloseS(string S)
        {
            //bool Flag = false;
            byte[] OpenByte = new byte[9];
            byte[] SAddressByte = GetSAddress(S);
            OpenByte[0] = 0x02;
            OpenByte[1] = 0x38;
            OpenByte[2] = SAddressByte[0];
            OpenByte[3] = SAddressByte[1];
            OpenByte[4] = SAddressByte[2];
            OpenByte[5] = SAddressByte[3];
            OpenByte[6] = 0x03;
            byte[] CheckSumByte = new byte[6];
            for (int i = 1; i < CheckSumByte.Length + 1; i++)
            {
                CheckSumByte[i - 1] = OpenByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            OpenByte[7] = Check2Byte[0];
            OpenByte[8] = Check2Byte[1];
            return OpenByte;
        }
        public static string byteToHexStr(byte[] bytes)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < bytes.Length; i++)
                {
                    returnStr +=bytes[i].ToString("X2")+" ";
                }
            }
            return returnStr;
        }
        public static byte[] CheckSum(byte[] Byte)
        {
            //做加法后转为16进制，取右边两位的ASCII
            int Sum = 0;
            for (int i = 0; i < Byte.Length; i++)
            {
                Sum = Sum + Byte[i];
            }
            string CheckSumString = Sum.ToString("X8");//大写X代表大写字母，小写代表小写，此处不同，需要注意。
            string Right2String = CheckSumString.Substring(CheckSumString.Length-2,2);
            byte[] CheckSumByte = new byte[2];
            ASCIIEncoding charToASCII = new ASCIIEncoding();
            CheckSumByte = charToASCII.GetBytes(Right2String.ToArray());
            return CheckSumByte;
        }
        public static byte[] ReadX(string X)
        {
            //bool Flag = false;
            byte[] ReadByte = new byte[11];
            byte[] XAddressByte = GetX_ReadAddress(X);
            ReadByte[0] = 0x02;
            ReadByte[1] = 0x30;
            ReadByte[2] = XAddressByte[0];
            ReadByte[3] = XAddressByte[1];
            ReadByte[4] = XAddressByte[2];
            ReadByte[5] = XAddressByte[3];
            ReadByte[6] = 0x30;
            ReadByte[7] = 0x32;
            ReadByte[8] = 0x03;
            byte[] CheckSumByte = new byte[9];
            for (int i = 1; i < CheckSumByte.Length + 1; i++)
            {
                CheckSumByte[i - 1] = ReadByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            ReadByte[9] = Check2Byte[0];
            ReadByte[10] = Check2Byte[1];
            return ReadByte;
        }
        public static byte[] ReadS(string S)
        {
            //bool Flag = false;
            byte[] ReadByte = new byte[11];
            byte[] SAddressByte = GetS_ReadAddress(S);
            ReadByte[0] = 0x02;
            ReadByte[1] = 0x30;
            ReadByte[2] = SAddressByte[0];
            ReadByte[3] = SAddressByte[1];
            ReadByte[4] = SAddressByte[2];
            ReadByte[5] = SAddressByte[3];
            ReadByte[6] = 0x30;
            ReadByte[7] = 0x32;
            ReadByte[8] = 0x03;
            byte[] CheckSumByte = new byte[9];
            for (int i = 1; i < CheckSumByte.Length + 1; i++)
            {
                CheckSumByte[i - 1] = ReadByte[i];
            }
            byte[] Check2Byte = new byte[2];
            Check2Byte = CheckSum(CheckSumByte);
            ReadByte[9] = Check2Byte[0];
            ReadByte[10] = Check2Byte[1];
            return ReadByte;
        }
        public static void OpenMitsubishiPLC(SerialPort serialPort,string COM)
        {
            try
            {
                serialPort.PortName = COM;
                serialPort.BaudRate = Convert.ToInt32(9600);
                serialPort.Parity = Parity.Even;
                serialPort.DataBits = Convert.ToInt32(7);
                serialPort.StopBits = StopBits.One;
                serialPort.Handshake = Handshake.None;
                serialPort.WriteTimeout = 500;
                serialPort.ReadTimeout = 500;
                if (serialPort.IsOpen == false)
                {
                    serialPort.Open();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        public static byte[] GetXAddress(string X)
        {

            string XAddress = "";
            switch (X)
            {
                case "X0":
                    XAddress = "0004";
                    break;
                case "X1":
                    XAddress = "0104";
                    break;
                case "X2":
                    XAddress = "0204";
                    break;
                case "X3":
                    XAddress = "0304";
                    break;
                case "X4":
                    XAddress = "0404";
                    break;
                case "X5":
                    XAddress = "0504";
                    break;
                case "X6":
                    XAddress = "0604";
                    break;
                case "X7":
                    XAddress = "0704";
                    break;
            }
            byte[] YAddressByte = new byte[4];
            ASCIIEncoding charToASCII = new ASCIIEncoding();
            YAddressByte = charToASCII.GetBytes(XAddress.ToArray());
            return YAddressByte;
        }
        public static byte[] GetYAddress(string Y)
        {

            string YAddress="";
            switch (Y)
            {
                case "Y0":
                    //05 00
                    YAddress = "0005";
                    break;
                case "Y1":
                    //05 01
                    YAddress = "0105";
                    break;
                case "Y2":
                    //05 02
                    YAddress = "0205";
                    break;
                case "Y3":
                    //05 03
                    YAddress = "0305";
                    break;
                case "Y4":
                    //05 04
                    YAddress = "0405";
                    break;
                case "Y5":
                    //05 05
                    YAddress = "0505";
                    break;
                case "Y6":
                    //05 06
                    YAddress = "0605";
                    break;
                case "Y7":
                    //05 07
                    YAddress = "0705";
                    break;
                case "Y10":
                    //05 00
                    YAddress = "0805";
                    break;
                case "Y11":
                    //05 01
                    YAddress = "0905";
                    break;
                case "Y12":
                    //05 02
                    YAddress = "0A05";
                    break;
                case "Y13":
                    //05 03
                    YAddress = "0B05";
                    break;
                case "Y14":
                    //05 04
                    YAddress = "0C05";
                    break;
                case "Y15":
                    //05 05
                    YAddress = "0D05";
                    break;
                case "Y16":
                    //05 06
                    YAddress = "0E05";
                    break;
                case "Y17":
                    //05 07
                    YAddress = "0F05";
                    break;
            }
            byte[] YAddressByte = new byte[4]; 
            ASCIIEncoding charToASCII = new ASCIIEncoding();
            YAddressByte = charToASCII.GetBytes(YAddress.ToArray());
            return YAddressByte;
        }
        public static byte[] GetSAddress(string S)
        {

            string SAddress = "";
            switch (S)
            {
                case "S0":
                    SAddress = "0000";
                    break;
                case "S1":
                    SAddress = "0100";
                    break;
                case "S2":
                    SAddress = "0200";
                    break;
                case "S3":
                    SAddress = "0300";
                    break;
                case "S4":
                    SAddress = "0400";
                    break;
                case "S5":
                    SAddress = "0500";
                    break;
                case "S6":
                    SAddress = "0600";
                    break;
                case "S7":
                    SAddress = "0700";
                    break;
                case "S8":
                    SAddress = "0800";
                    break;
                case "S9":
                    SAddress = "0900";
                    break;
                case "S10":
                    SAddress = "0A00";
                    break;
                case "S11":
                    SAddress = "0B00";
                    break;
                case "S12":
                    SAddress = "0C00";
                    break;
                case "S13":
                    SAddress = "0D00";
                    break;
                case "S14":
                    SAddress = "0E00";
                    break;
                case "S15":
                    SAddress = "0F00";
                    break;
            }
            byte[] YAddressByte = new byte[4];
            ASCIIEncoding charToASCII = new ASCIIEncoding();
            YAddressByte = charToASCII.GetBytes(SAddress.ToArray());
            return YAddressByte;
        }
        public static byte[] GetX_ReadAddress(string X)//For Read
        {
            // X0-X7读取的地址相同，将得到的数字转为2进制判断通断。
            string XAddress = "";
            switch (X)
            {
                case "X0":
                    XAddress = "0080";
                    break;
                case "X1":
                    XAddress = "0080";
                    break;
                case "X2":
                    XAddress = "0080";
                    break;
                case "X3":
                    XAddress = "0080";
                    break;
                case "X4":
                    XAddress = "0080";
                    break;
                case "X5":
                    XAddress = "0080";
                    break;
                case "X6":
                    XAddress = "0080";
                    break;
                case "X7":
                    XAddress = "0080";
                    break;
                case "X10":
                    XAddress = "0081";
                    break;
                case "X11":
                    XAddress = "0081";
                    break;
                case "X12":
                    XAddress = "0081";
                    break;
                case "X13":
                    XAddress = "0081";
                    break;
                case "X14":
                    XAddress = "0081";
                    break;
                case "X15":
                    XAddress = "0081";
                    break;
                case "X16":
                    XAddress = "0081";
                    break;
                case "X17":
                    XAddress = "0081";
                    break;
            }
            byte[] YAddressByte = new byte[4];
            ASCIIEncoding charToASCII = new ASCIIEncoding();
            YAddressByte = charToASCII.GetBytes(XAddress.ToArray());
            return YAddressByte;
        }
        public static byte[] GetS_ReadAddress(string S)//For Read
        {
            // X0-X7读取的地址相同，将得到的数字转为2进制判断通断。
            string SAddress = "";
            switch (S)
            {
                case "S0":
                    SAddress = "0000";
                    break;
                case "S1":
                    SAddress = "0000";
                    break;
                case "S2":
                    SAddress = "0000";
                    break;
                case "S3":
                    SAddress = "0000";
                    break;
                case "S4":
                    SAddress = "0000";
                    break;
                case "S5":
                    SAddress = "0000";
                    break;
                case "S6":
                    SAddress = "0000";
                    break;
                case "S7":
                    SAddress = "0000";
                    break;
                case "S8":
                    SAddress = "0001";
                    break;
                case "S9":
                    SAddress = "0001";
                    break;
                case "S10":
                    SAddress = "0001";
                    break;
                case "S11":
                    SAddress = "0001";
                    break;
                case "S12":
                    SAddress = "0001";
                    break;
                case "S13":
                    SAddress = "0001";
                    break;
                case "S14":
                    SAddress = "0001";
                    break;
                case "S15":
                    SAddress = "0001";
                    break;
            }
            byte[] YAddressByte = new byte[4];
            ASCIIEncoding charToASCII = new ASCIIEncoding();
            YAddressByte = charToASCII.GetBytes(SAddress.ToArray());
            return YAddressByte;
        }
    }
}
崇文馆居士
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c#rs232与三菱通讯_c#上位机与三菱PLC(FX3U)串口通讯
weixin_39726697的博客
12-20 2526
项目中会经常用到上位机与PLC之间的串口通信，本文介绍一下C#如何编写上位机代码与三菱FX3U进行通讯1. 第一种方法是自己写代码实现，主要代码如下：//对PLC的Y7进行置1byte[] Y007_ON = { 0x02, 0x37, 0x30, 0x37, 0x30, 0x35, 0x03, 0x30, 0x36};//选择串口参数SerialPort sp = new SerialPort(...
C#跟三菱PLC通信
GoldenLionKing的博客
06-09 1228
/2个寄存器的数据(小数)public short MDT_Int16;//多个寄存器的short。//2个寄存器的数据(整数)public short dt_Int16;//单个寄存器的数据。//上限40个，但是解不出来，上限8个能解的出来。#region QR指令数组。
VB、C#等高级语言与三菱PLC（Q系列、L系列、FX系列）串口、以太网通讯的DLL及源代码
不是我的博客
04-16 1万+
http://blog.sina.com.cn/s/blog_16d7d3ecb0102x6wj.html 1.0 通讯组件概述 通讯组件用于PC与可编程控制器(PLC)、智能仪表等进行数据通讯，适用于基于PC高级语言的工业自动化控制系统。组件采用动态链接库文件(*.DLL)的形式，在PC系统的项目工程里引用该组件，调用相应的属性与方法函数，即可快速实现PC与PLC的高效数据交换。
C#与三菱PLC通讯连接
最新发布
weixin_44743959的博客
05-28 875
连接方式：选用三菱官方软件建立通讯连接，通讯线使用三菱原装下载通讯线。
C# SerialPort 读写三菱FX系列PLC
anqiaoej627921的博客
12-29 476
1：串口初始化 com = new SerialPort("COM3", 9600, Parity.Even, 7, StopBits.One); 2：打开关闭串口 if (com.IsOpen) {com.Close();} com.Open(); if (com.IsOpen) { com.Close();} 3：C# ASCII转字符及字符...
PC与三菱PLC串口通信 C#实例源程序
01-08
【工控老马出品，必属精品，质量保证，亲测能用】 资源名：PC与三菱PLC串口通信 C#实例源程序 资源类型：程序源代码 源码说明： A控制B，那A就是上位机，A发送协议内规定的一串数据，B接收到确认数据没错再返回其对应的数据。相对应的B就是下位机，plc常见的上位机有pc，HMI，其他plc，与pc通讯， 适合人群：新手及有一定经验的开发人员
使用C#与三菱PLC通讯
热门推荐
weixin_46846685的博客
02-13 1万+
使用C#与三菱PLC通讯一、三菱PLC驱动程序安装 一、三菱PLC驱动程序安装
QRCode_2co2.xys_android_
10-02
【标题】"QRCode_2co2.xys_android_" 指的是一个关于在Android平台上使用Zxing库来实现二维码扫描和生成的项目。Zxing（又名“ZXing”，意为“zebra crossing”，斑马线）是一个开源的、多平台的条码图像处理库，它...
XYS_ELECIty.zip
03-05
"XYS_Electricity.zip"这个压缩包就是这样一个实例，它包含了Unity游戏引擎中用于构建智慧城市模型的科技风格描边Shader脚本。接下来，我们将深入探讨Unity游戏开发中的相关知识点，以及如何通过这些技术提升智慧...
C#web打印之WebBrowser
12-01
在IT领域，C#是一种广泛使用的编程语言，尤其在开发Windows桌面应用和Web应用程序时。WebBrowser控件是.NET框架提供的一种强大工具，允许开发者在应用程序中嵌入一个基于Internet Explorer内核的浏览器，用于显示...
XYS[远程控制]内部无壳
06-12
XYS-VIP内部专用无壳哦！[BY：XYS YY频道：21592103[新] Q群：112339258[新]！！！！]
Using UART in CC111xFx,CC243xFx,cc251xFx and CC253xFx
12-14
This design note ...Fx USART peripheral in UART mode. The main objective is to explain the CC111xFx/CC243xFx/CC251xFx/CC253x Fx software required to operate the UART, with and without DMA support.
C#实现简单的串口通信
banchi3271的专栏
09-29 1102
前言 本着学习研究的态度，用c#语言实现简单的串口通信工具。 一、串口通信原理 串口通信 串口通信（Serial Communications）的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。它很简单并且能够实现远距离通信。由于串口通信是异步的，端口能够在一根线上发送数据同时...
C#中显现串口通信SerialPort类
06-11 1105
SerialPort类的常用属性 名　　称 说　　明 BaseStream 获取 SerialPort 对象的基础 Stream 对象 BaudRate 获取或设置串行波特率 BreakState 获取或...
基于C#开发PLC上位机（一）—三菱PLC使用MX通信
qq_34191294的博客
07-13 1万+
PLC用着用着，就突然很好奇PLC是如何和上位机通信的，至于为什么开发上位机，上位机相比单纯的PLC有什么优势等内容在此不再赘述。 以三菱PLC为例。第一反应是先去咨询客服，是否有现成的开源OPC，但是三菱客服说官方没有相应示例，直接给了一个第三方OPC付费应用商，这背后绝对有什么肮脏的交易......后来百度之下才知道三菱提供专门的插件，这个软件为MX Component。 首先安装C#编程软件，我这里使用的是VS2015，.NET FrameWork ...
C#调用三菱的MX Component控件与三菱PLC进行通讯
zls365365的博客
12-14 1万+
本文章讲的是MX Component软件的安装以及软件需要的设置，c#如何调用控件与三菱FX5U的通讯，按道理只要是三菱的就可以用这个控件通讯，在文末会有中文编程手册链接以及c#的demo...
VC环境下三菱PLC与微机的串行通信
tomliks的专栏
02-17 4754
VC环境下三菱PLC与微机的串行通信 发表于 2008/6/20 10:12:46 摘 要：主要介绍三菱FX系列PLC与上位机之间的通讯协议，并采用CSerial类来实现串行通信，本文给出了程序设计方法和部分源代码。引言可编程控制器（PLC）是集计算机技术、自动控制技术、通信技术为一体的新型自动控制装置。由于体积小、可靠性高以及组态灵活等优点，PLC在工业控制领域得到了广泛
c#rs232与三菱通讯_C#对三菱PLC的以太网和串口通讯以及台达PLC的以太网通讯
weixin_39601641的博客
12-20 661
【实例简介】C#对三菱PLC的以太网和串口通讯以及台达PLC的以太网通讯【实例截图】【核心代码】Conn└── Conn├── Conn.sln└── ConnTest├── bin│ └── Debug│ ├── ConnTest.exe│ ├── ConnTest.pdb│ ├── ConnTest.vshost.exe│ ├── ConnT...
xys = np.asarray(xys)怎么解决
04-30
这段代码的意思是将列表 xys 转换为 NumPy 数组。如果出现问题，可能是因为未导入 NumPy 库，您可以使用以下代码导入 NumPy 库： ``` import numpy as np ``` 如果您已经导入了 NumPy 库，但仍然遇到问题，请确保您的 xys 列表中的元素是数字类型，例如整数或浮点数。如果 xys 列表中包含字符串或其他非数字类型的元素，则无法将其转换为 NumPy 数组。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值