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

2023-11-11

花了两三天写了一个这个，本来想着自己用的，看到有很多替代品，果断开源了吧:
下载地址: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;
        }
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

c

PLC

C# 三菱FX PLC XYS读写，串口读写的相关文章

使用sqlbulkcopy之前如何创建表

我有一个 DBF 文件我正在尝试导入该文件然后将其写入 SQL 表我遇到的问题是如果我使用 SqlBulkCopy 它需要我提前创建表但在我的场景中这是不可能的因为 dbf 文件不断变化到目前为止这是我的代码 public
成员字段、构建顺序

在 C 中当执行如下所示的操作时构造顺序是否得到保证 Logger Logger kFilePath logs runtime log logFile kFilePath 是的施工顺序始终得到保证但是不能保证它与对象在初始值设定项
C# 中直接从 URL 获取图像尺寸

我正在尝试使用以下代码直接从网络上获取图片的尺寸 string image http www hephaestusproject com csharp3 png byte imageData new WebClient DownloadDa
读取大文件并制作字典

我有一个大文件我需要读取它并从中制作字典我希望这一切能够尽可能快然而我的Python代码太慢了这是一个显示问题的最小示例首先制作一些假数据 paste lt seq 20000000 lt seq 2 20000001 gt la
在异步请求中使用超时回调

我之前问过这个问题但我将用提出的解决方案来完成这个问题并提出另一个问题我正在使用这个类来进行异步网络请求 http msdn microsoft com en us library system net webrequest aspx
何时使用 C++ 私有继承而不是组合？

你能给我一个具体的例子吗什么时候使用私有继承优于组合就我个人而言我将使用组合而不是私有继承但在某些情况下使用私有继承可能是特定问题的最佳解决方案正在阅读C faq http www parashift com c faq lit
ASMX Web 服务，测试表单仅在本地计算机上适用于一种 WebMethod

我有一个正在测试的 ASMX WebService 并且在大多数方法上我都可以使用测试表单进行测试然而我确实有一种方法测试表上写着 The test form is only available for requests from t
确定相关词的编程方式？

使用网络服务或软件库我希望能够识别与词根相关的单词例如座位和安全带共享词根座位但西雅图不会被视为匹配简单的字符串比较对于这类事情似乎是不可行的除了定义我自己的字典之外是否有任何库或 Web 服务不仅可以返回单词定义
使用联合对 IP 地址进行多种解释？

在工作中我们使用以下构造来将 IP 地址解释为 4 字节数组或 32 位整数 union IPv4 std uint32 t ip std uint8 t data 4 这很好用但是读完这本书的第 97 章不要使用联合来重新解释表示
如何阻止 Control-I 在 CoreWindow 范围内的 UWP 文本框中插入选项卡？

当我在 UWP 应用程序中有一个 TextBox 时对我来说奇怪的行为在 Windows 10 中创建通用的空白应用程序 UWP 应用程序使用以下代码将文本框添加到默认网格
如何使 WinForms UserControl 填充其容器的大小

我正在尝试创建一个多布局主屏幕应用程序我在顶部有一些按钮链接到应用程序的主要部分例如模型中每个实体的管理窗口单击这些按钮中的任何一个都会在面板中显示关联的用户控件面板包含用户控件而用户控件又包含用户界面 WinForms User
在 lua 中加载 C++ 模块时出现“尝试索引字符串值”错误

我正在尝试使用 lua 用 C 编写的函数下面给出的是cpp文件 extern C include lua h include lauxlib h include lualib h static int add 5 lua State L
在 C# 窗口应用程序中运行 C/C++ 控制台应用程序？

现在我想开发一个简单的应用程序因此我决定最快的编码方式是 C NET 但现在我很难实现我需要的功能之一我想做的是在 C 应用程序的窗口内运行 C C 控制台应用程序就像在虚幻前端中一样添加一点通信方式以便我可以为控制台应用程序
如何使用“路径”查询 XDocument？

我想查询一个XDocument给定路径的对象例如 path to element I want 但我不知道如何继续您可以使用以下方法System Xml XPath Extensions http msdn microsoft com
包含从代码隐藏 (ASP.NET C#) 到 ASPX 中的图像概述的图像列表 [关闭]

就目前情况而言这个问题不太适合我们的问答形式我们希望答案得到事实参考资料或专业知识的支持但这个问题可能会引发辩论争论民意调查或扩展讨论如果您觉得这个问题可以改进并可能重新开放访问帮助中心 help reopen questi
Web API 2.0 使用 pascalcase 模型接收驼峰式命名的 JSON 数据

我正在尝试对我的 Web API 进行 PUT 调用我在 WebApiConfig cs 中设置了以下内容以处理以驼峰形式将数据发送回我的 Web 项目 config Formatters JsonFormatter Serialize
在两个点之间创建一条曲线，每个点都具有标准化向量

因此我需要一种写入方法来在两点之间创建一条曲线每个点都有一个指向任意方向的归一化向量我一直在尝试设计这样一种方法但一直无法理解数学在这里由于一张图片胜过一千个文字这就是我所需要的在图中矢量垂直于红线我相信向量需要进行相同
boost::spirit::qi::语法和可变参数模板

我在使用可变参数模板定义语法时面临一个问题我首先定义一些包含在某些结构中的简单语法例如纬度经度如下所示 include
是否可以检测流是否已被客户端关闭？

简要介绍一下情况我有一项服务可以通过套接字接收信息并发送回复连接不安全我想设置另一个可以为这些连接提供 TLS 的服务这个新服务将提供单个端口并根据提供的客户端证书分发连接我不想使用 stunnel 有几个原因其中之一是每个接收
如何创建实体集或模型而不在数据库中创建相应的表 - 实体框架

我的 sqlserver 数据库中有一个存储过程它返回多个结果集我正在使用 msdn 中的以下链接从实体框架中的 SP 读取多个结果集 https msdn microsoft com en us library jj691402 v

随机推荐

内网安全-黄金票据和白银票据

文章目录前言黄金票据原理应用场景应用条件防御白银票据原理应用条件黄金票据和白银票据的区别前言前置知识是需要熟悉Kerberos协议的认证流程可以看前一篇文章黄金票据原理在熟悉了Kerberos协议的认证流程后
java毕业设计球迷信息交流论坛源码+lw文档+mybatis+系统+mysql数据库+调试

java毕业设计球迷信息交流论坛源码 lw文档 mybatis 系统 mysql数据库调试 java毕业设计球迷信息交流论坛源码 lw文档 mybatis 系统 mysql数据库调试项目架构 B S架构开发语言 Java语言开发软
WIN11如何设置环境变量

在win11系统中运行环境比如node js的时候我们需要进行额外的参数设置才能继续进行操作而这个参数设置就是常说的环境变量设置那么win11系统的环境变量到底怎么进行配置呢 1 键盘输入 win R 打开运行框 2 输入命令 c
（十六）Mybatis整合EhCache缓存框架用法详解

这篇文章主要讲述Mybatis整合EhCache缓存框架用法详解写的非常详细对大家的学习或者工作具有一定的参考学习价值需要的朋友们下面随着小编来一起学习学习吧目录什么是EhCache 代码示例 1 导入第三方缓存包 2 配置缓存元
关于javamail的一些笔记

1 为什么要学习javamail 企业中系统经常需要信息通知和信息校验 2 利用telnet实现邮件收发注册sina和sohu账户 yuyang94895 sina com yuyang94895 sohu com 密码 1qaz2
unityhub登录不上，登录界面刷新不出来, 或检测不到Unity

如果是登录界面白屏的话或检测不到Unity 可以尝试 1 关闭hub 右下角也要退出找不到的可以直接任务管理器退出 2 删除 UserProfile AppData Roaming 里面的 UnityHub Cache和 Unity
汇编程序设计与计算机体系结构,《汇编程序设计与计算机体系结构：软件工程师教程》 —2.8　作业...

2 8 作业 2 8 1 内存有这样一个算式 taxableIncome salary exempts percent401k 100 salary 其中的变量 salary 50000 exempts 7000 percent401k
【MySQL】流程控制函数CASE

文章目录 1 流程控制函数CASE 2 练习 1 流程控制函数CASE IF value value1 value2 如果value的值为TRUE 返回value1 否则返回value2 IFNULL value1 value2 如果val
typora插件_如何在Typora中写markdown, 并发布到知乎

你不能阻止鸟从你头上飞过但是你可以阻止鸟在你头上筑巢 by 无名一常见的几种方法与工具 1 vscode zhihu插件缺点不能渲染表格用起来没有想想中的那么简便 2 MarkdownHere 插件缺点并不好用毕竟他主要还
linklist2

include
TYPE-C转串口原理图

板子是采用kicad画的主控芯片采用CH340K 其他型号类似原理图获取方式聚玩库公众号发送 typec串口
Python_反转字符串

Python 反转字符串测开笔试题尽可能用多的方法反转字符串输入 abcde 输出 edcba PS 字符串是不可变类型元素很多时候需要先转为list 再join 1 方法1 切片反转 def fanzhuan s return s
html checkbox的checked属性问题和value属性问题

示例代码
wsl2安装图形化界面联网中文输入法

时长两天搞定的遇到了很多坑我主要是根据自己的实践经历说一下坑点然后复盘我的思路过程首先我参考了这个资料 WSL2 Ubuntu图形界面使用指南 csdn出品其实也主要是参考官网的教程链接如下 https learn micro
数据结构—递归与非递归实现DFS与BFS

老师上数据结构课的作业我皮了一下用 c c c 的vector写的其实也不难详情请参见代码如果有不会DFS与BFS的参见资料递归BFS include
html读取json文件+数据渲染
android源码学习-Handler机制及其六个核心点

前言该文属于安卓源码探究专栏中的文章专栏所有文章清单链接如下欢迎大家阅读安卓源码探究这里是图片001 https blog csdn net rzleilei category 6506586 html spm 1001 2014
【MYSQL基础(一）】——数据类型的详细解析. 数据库基本操作

个人主页努力学习的少年版权本文由努力学习的少年原创在CSDN首发需要转载请联系博主如果文章对你有帮助欢迎关注点赞收藏一键三连和订阅专栏哦目录一为什么要使用MySQL数据库二数据库的基本概念数据库和数据库
win10计算机程序员怎么用,如何用好 Windows 10 中的多功能「计算器」应用程序

从 1985 年 Microsoft 首次推出 Windows 1 0 以来至今系统内置的 Widows 计算器已经走过了漫长的功能扩展道路 Windows 10 的多功能计算器针对不同用户和使用场景内置了多种功能模式其中就包括
C# 三菱FX PLC XYS读写，串口读写

花了两三天写了一个这个本来想着自己用的看到有很多替代品果断开源了吧下载地址 https github com t39q MitsubishiFX PLC XYS 以下是原理后面有帮助类和调用方法调用方法 private void

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

C# 三菱FX PLC XYS读写，串口读写 的相关文章

随机推荐

热门标签

C# 三菱FX PLC XYS读写，串口读写的相关文章