Aotecar-CAN/CompressorXN_Communication/MyPlc/OmronHelper.cs

using CompressorXN_Common;
using CompressorXN_Model.ViewModel.Plc;
using HslCommunication;
using HslCommunication.Profinet.Omron;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CompressorXN_Communication.MyPlc
{
    /// <summary>
    /// 欧姆龙PLC帮助类
    /// </summary>
    public class OmronHelper
    {
        private static OmronCipNet omronCipNet = null;

        /// <summary>
        /// 获取欧姆龙PLC连接对象
        /// </summary>
        /// <param name="plcIp"></param>
        /// <param name="plcPort"></param>
        /// <param name="connectTimeOut"></param>
        /// <returns></returns>
        public static OmronCipNet GetOmronCipNet(string plcIp, int plcPort, int connectTimeOut = 3000)
        {
            omronCipNet = new OmronCipNet(plcIp, plcPort)
            {
                ConnectTimeOut = connectTimeOut
            };

            var connect = omronCipNet.ConnectServer();

            isConnected = connect.IsSuccess;

            if (connect.IsSuccess)
            {
                GlobalVar.omronCipNet = omronCipNet;
                return omronCipNet;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 链接状态
        /// </summary>
        private static bool isConnected = false;
        public static bool IsConnected
        {
            get { return isConnected; }
        }

        /// <summary>
        /// 获取PLC值--单点位
        /// </summary>
        /// <param name="dataType">数据类型</param>
        /// <param name="pointAddress">点位地址</param>
        /// <param name="length">读取长度</param>
        /// <returns></returns>
        public static (bool ok, string val) GetPlcVal(string dataType, string pointAddress, int length = 1, Encoding encoding = null)
        {
            var strVal = string.Empty;
            try
            {
                if (!isConnected || omronCipNet == null)
                {
                    return (false, strVal);
                }
                switch (dataType)
                {
                    case "bool":
                        var operateBoolResult = omronCipNet.ReadBool(pointAddress);
                        if (!operateBoolResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            var boolVal = operateBoolResult.Content;
                            strVal = boolVal.ToString();
                            return (true, strVal);
                        }
                    case "int":
                        var operateIntResult = omronCipNet.ReadInt32(pointAddress);
                        if (!operateIntResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            var intVal = operateIntResult.Content;
                            strVal = intVal.ToString();
                            return (true, strVal);
                        }
                    case "short":
                        var operateShortResult = omronCipNet.ReadInt16(pointAddress);
                        if (!operateShortResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            var shortVal = operateShortResult.Content;
                            strVal = shortVal.ToString();
                            return (true, strVal);
                        }
                    case "ushort":
                        var operateUshortResult = omronCipNet.ReadUInt16(pointAddress);
                        if (!operateUshortResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            var ushortVal = operateUshortResult.Content;
                            strVal = ushortVal.ToString();
                            return (true, strVal);
                        }
                    case "float":
                        var operateFloatResult = omronCipNet.ReadFloat(pointAddress);
                        if (!operateFloatResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            var floatVal = operateFloatResult.Content;
                            strVal = floatVal.ToString("f3");
                            return (true, strVal);
                        }
                    case "string":
                        var operateStringResult = omronCipNet.ReadString(pointAddress, (ushort)length, encoding == null ? Encoding.UTF8 : encoding);
                        if (!operateStringResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            strVal = operateStringResult.Content;
                            return (true, strVal);
                        }
                    case "byte":
                        var operateByteResult = omronCipNet.Read(pointAddress, (ushort)length);
                        if (!operateByteResult.IsSuccess)
                        {
                            return (false, strVal);
                        }
                        else
                        {
                            if (encoding == null)
                            {
                                strVal = Encoding.ASCII.GetString(operateByteResult.Content);
                            }
                            else
                            {
                                strVal = encoding.GetString(operateByteResult.Content);
                            }
                            return (true, strVal);
                        }
                    default:
                        return (false, strVal);
                }
            }
            catch (Exception)
            {
                return (false, strVal);
            }
        }

        /// <summary>
        /// 值写入PLC
        /// </summary>
        /// <param name="dataType">数据类型</param>
        /// <param name="pointAddress">点位地址</param>
        /// <param name="value">值</param>
        /// <param name="len">长度</param>
        /// <param name="encoding">编码格式</param>
        /// <returns></returns>
        public static (bool isOk, string msg) WriteValToPlc(string dataType, string pointAddress, object value, int len = 1, Encoding encoding = null)
        {
            try
            {
                if (!isConnected || omronCipNet == null)
                {
                    return (false, "PLC未连接");
                }
                OperateResult operateResult = new OperateResult
                {
                    IsSuccess = false
                };
                switch (dataType)
                {
                    case "bool":
                        operateResult = omronCipNet.Write(pointAddress, Convert.ToBoolean(value));
                        break;
                    case "int":
                        operateResult = omronCipNet.Write(pointAddress, Convert.ToInt32(value));
                        break;
                    case "short":
                        operateResult = omronCipNet.Write(pointAddress, Convert.ToInt16(value));
                        break;
                    case "ushort":
                        operateResult = omronCipNet.Write(pointAddress, Convert.ToUInt16(value));
                        break;
                    case "float":
                        operateResult = omronCipNet.Write(pointAddress, Convert.ToSingle(value));
                        break;
                    case "string":
                        operateResult = omronCipNet.Write(pointAddress, value.ToString(), len, encoding ?? Encoding.ASCII);
                        break;
                    case "byte":
                        var bytes = Encoding.ASCII.GetBytes(value.ToString());
                        operateResult = omronCipNet.WriteTag(pointAddress, 0xD1, bytes, len);
                        break;
                }
                if (operateResult.IsSuccess)
                {
                    return (operateResult.IsSuccess, "操作成功");
                }
                return (operateResult.IsSuccess, operateResult.Message);
            }
            catch (Exception ex)
            {
                return (false, ex.Message);
            }
        }

        /// <summary>
        /// 循环点位地址进行读取
        /// </summary>
        /// <param name="variables"></param>
        /// <returns></returns>
        public static List<Variable> ReadPlcByeWhile(List<Variable> variables)
        {
            for (int i = 0; i < variables.Count; i++)
            {
                var result = GetPlcVal(variables[i].DataType, variables[i].VariableName, variables[i].Offset);
                variables.First(m => m.VariableName == variables[i].VariableName).ReadVal = result.val;
            }
            return variables;
        }
    }
}