【源代码】西门子Simatic.NET与Visual C#异步通讯的代码

/*********************************************************************
 * 模块名称：OPC服务器类
 * 版    本：Version 0.97a
 * 作    者：龙少爷
 * 时    间：2010-11-16 11:43
 * 备    注： 
 *      OPC服务器的常用操作：连接，断开，读，写，设置状态
 * 附    注：
 *            
 * *******************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Runtime.InteropServices;

using OpcRcw.Da;
using OpcRcw.Comn;

namespace Utility.PLC
{
    /// <summary>
    /// OPC服务器类 By 龙少爷 2010
    /// </summary>
    public class OPCServer
    {
        #region OPCServer Common Fields
        private OpcRcw.Da.IOPCServer ServerObj;//OPCServer  

        private OpcRcw.Da.IOPCAsyncIO2 IOPCAsyncIO2Obj = null;//异步读写对象  
        private OpcRcw.Da.IOPCGroupStateMgt IOPCGroupStateMgtObj = null;//组管理对象  

        private IConnectionPointContainer pIConnectionPointContainer = null;
        private IConnectionPoint pIConnectionPoint = null;

        public const int LOCALE_ID = 0x407;

        private Object MyobjGroup1 = null;
        private int[] ItemServerHandle;
        private int pSvrGroupHandle = 0;
        private Int32 dwCookie = 0;

        #endregion

        #region OPCServer User-Defined Variables
        #endregion

        #region OPCServer Constructors
        public OPCServer()
        {

        }
        #endregion

        #region Methods

        /// <summary>
        /// 建立PC到PLC的连接，返回OPC服务器对象
        /// </summary>
        /// <param name="programID">将要连接的进程ID</param>
        /// <param name="server">服务器IP地址</param>
        /// <returns>OPC服务器对象</returns>
        public bool CreateServer(string programID, string server)
        {
            Type svrComponenttyp;
            try
            {
                svrComponenttyp = Type.GetTypeFromProgID(programID, server);//OPCServer  
                ServerObj = (IOPCServer)Activator.CreateInstance(svrComponenttyp);//注册  
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        /// <summary>
        /// 添加一个组对象，并返回该组对象的引用
        /// </summary>
        /// <param name="form">回调对象</param>
        /// <returns>是否执行成功</returns>
        public bool AddGroup(object form)
        {
            Int32 dwRequestedUpdateRate = 1000;
            Int32 hClientGroup = 1;
            Int32 pRevUpdateRate;

            float deadband = 0;

            int TimeBias = 0;
            GCHandle hTimeBias, hDeadband;
            hTimeBias = GCHandle.Alloc(TimeBias, GCHandleType.Pinned);
            hDeadband = GCHandle.Alloc(deadband, GCHandleType.Pinned);
            Guid iidRequiredInterface = typeof(IOPCItemMgt).GUID;

            try
            {
                ServerObj.AddGroup("MyOPCGroup1",//组对象  
                    0,
                    dwRequestedUpdateRate,
                    hClientGroup,
                    hTimeBias.AddrOfPinnedObject(),
                    hDeadband.AddrOfPinnedObject(),
                    LOCALE_ID,
                    out pSvrGroupHandle,
                    out pRevUpdateRate,
                    ref iidRequiredInterface,
                    out MyobjGroup1);

                IOPCAsyncIO2Obj = (IOPCAsyncIO2)MyobjGroup1;
                //Query interface for Async calls on group object  

                IOPCGroupStateMgtObj = (IOPCGroupStateMgt)MyobjGroup1;

                pIConnectionPointContainer = (IConnectionPointContainer)MyobjGroup1;
                //定义特定组的异步调用连接  

                Guid iid = typeof(IOPCDataCallback).GUID;
                // Establish Callback for all async operations  
                pIConnectionPointContainer.FindConnectionPoint(ref iid, out pIConnectionPoint);

                // Creates a connection between the OPC servers's connection point and this client's sink (the callback object)  
                pIConnectionPoint.Advise(form, out dwCookie);

                return true;
            }
            catch (Exception ex)// catch for group adding  
            {
                return false;
            }
            finally
            {
                if (hDeadband.IsAllocated)
                    hDeadband.Free();
                if (hTimeBias.IsAllocated)
                    hTimeBias.Free();
            }
        }
        /// <summary>
        /// 添加一个读写的Items数组对象
        /// Ex:
        ///     OpcRcw.Da.OPCITEMDEF[] ItemArray = new OPCITEMDEF[3];//  
        ///     ItemArray[0].szAccessPath = "";
        ///     ItemArray[0].szItemID = "S7:[S7 connection_1]DB13,DWORD0";
        ///     //地址，不同数据类型表示方法不同  
        ///     ItemArray[0].bActive = 1;//是否激活  
        ///     ItemArray[0].hClient = 1;//表示ID  
        ///     ItemArray[0].dwBlobSize = 0;
        ///     ItemArray[0].pBlob = IntPtr.Zero;
        ///     ItemArray[0].vtRequestedDataType = 2;
        /// </summary>
        /// <param name="items">Items读写对象数组</param>
        /// <returns>Items是否执行成功</returns>
        public bool AddItems(OPCITEMDEF[] items)
        {
            IntPtr pResults = IntPtr.Zero;
            IntPtr pErrors = IntPtr.Zero;

            try
            {
                ((IOPCItemMgt)MyobjGroup1).AddItems(items.Length, items, out  pResults, out pErrors);

                int[] errors = new int[items.Length];
                Marshal.Copy(pErrors, errors, 0, items.Length);

                ItemServerHandle = new int[items.Length];

                IntPtr pos = pResults;

                OPCITEMRESULT result;

                if (errors[0] == 0)
                {
                    result = (OPCITEMRESULT)Marshal.PtrToStructure(pos, typeof(OPCITEMRESULT));
                    ItemServerHandle[0] = result.hServer;
                }
                for (int i = 1; i < errors.Length; i++)
                {
                    if (errors[i] == 0)
                    {
                        pos = new IntPtr(pos.ToInt32() + Marshal.SizeOf(typeof(OPCITEMRESULT)));
                        result = (OPCITEMRESULT)Marshal.PtrToStructure(pos, typeof(OPCITEMRESULT));
                        ItemServerHandle[i] = result.hServer;
                    }
                }
                return true;
            }
            catch (Exception ex) // catch for add item  
            {
                return false;
            }
            finally
            {
                // Free the memory  
                if (pResults != IntPtr.Zero)
                {
                    Marshal.FreeCoTaskMem(pResults);
                    pResults = IntPtr.Zero;
                }
                if (pErrors != IntPtr.Zero)
                {
                    Marshal.FreeCoTaskMem(pErrors);
                    pErrors = IntPtr.Zero;
                }
            }
        }
        /// <summary>
        /// 发送异步读命令,结果的读取要通过实现IOPCDataCallback接口的OnReadComplete函数实现
        /// </summary>
        /// <param name="itemServerHandles">Item读写对象句柄数组</param>
        /// <returns>是否执行成功</returns>
        public bool Read()
        {
            int nCancelid;
            IntPtr pErrors = IntPtr.Zero;
            if (IOPCAsyncIO2Obj != null)
            {
                try
                {
                    IOPCAsyncIO2Obj.Read(ItemServerHandle.Length, ItemServerHandle, ItemServerHandle.Length, out nCancelid, out pErrors);
                    int[] errors = new int[ItemServerHandle.Length];
                    Marshal.Copy(pErrors, errors, 0, ItemServerHandle.Length);
                    return false;
                }
                catch (Exception ex)
                {
                    return false;
                }
            }
            else
                return false;
        }
        /// <summary>
        /// 发送异步写命令,结果的状态，要通过实现IOPCDataCallback接口的OnWriteComplete函数实现
        /// </summary>
        /// <param name="itemIndex">要写的Item项</param>
        /// <param name="values">要写入到PLC中的值数组</param>
        /// <returns>是否执行成功</returns>
        public bool Write(int itemIndex, object[] values)
        {
            int nCancelid;
            IntPtr pErrors = IntPtr.Zero;

            int[] phServer = new int[1];
            phServer[0] = itemIndex;

            if (IOPCAsyncIO2Obj != null)
            {
                try
                {
                    IOPCAsyncIO2Obj.Write(1, phServer, values, itemIndex, out nCancelid, out pErrors);

                    int[] errors = new int[1];
                    Marshal.Copy(pErrors, errors, 0, 1);

                    if (errors[0] != 0)//Error in reading item
                    {
                        Marshal.FreeCoTaskMem(pErrors);
                        pErrors = IntPtr.Zero;
                        return false;
                    }
                    return true;
                }
                catch (Exception ex)
                {
                    return false;
                }
            }
            else
                return false;
        }
        /// <summary>
        /// 发送异步写命令,结果的状态，要通过实现IOPCDataCallback接口的OnWriteComplete函数实现
        /// </summary>
        /// <param name="values">要写入到PLC中的值数组</param>
        /// <returns>是否执行成功</returns>
        public bool Write(object[] values)
        {
            int nCancelid;
            IntPtr pErrors = IntPtr.Zero;

            if (IOPCAsyncIO2Obj != null)
            {
                try
                {
                    IOPCAsyncIO2Obj.Write(ItemServerHandle.Length, ItemServerHandle, values, ItemServerHandle.Length, out nCancelid, out pErrors);

                    int[] errors = new int[ItemServerHandle.Length];
                    Marshal.Copy(pErrors, errors, 0, ItemServerHandle.Length);

                    bool bError = false;
                    foreach (int err in errors)//Error in reading item
                    {
                        if (err != 0)
                        {
                            bError = true;
                            break;
                        }
                    }
                    if (bError)
                    {
                        Marshal.FreeCoTaskMem(pErrors);
                        pErrors = IntPtr.Zero;
                        return false;
                    }
                    return true;
                }
                catch (Exception ex)
                {
                    return false;
                }
            }
            else
                return false;
        }
        /// <summary>
        /// 设置PLC状态，使之处罚OnDataChange事件函数
        /// </summary>
        /// <param name="group"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetState(bool value)
        {
            IntPtr pRequestedUpdateRate = IntPtr.Zero;
            int nRevUpdateRate = 0;
            IntPtr hClientGroup = IntPtr.Zero;
            IntPtr pTimeBias = IntPtr.Zero;
            IntPtr pDeadband = IntPtr.Zero;
            IntPtr pLCID = IntPtr.Zero;
            int nActive = 0;

            // activates or deactivates group according to checkbox status  
            GCHandle hActive = GCHandle.Alloc(nActive, GCHandleType.Pinned);
            if (value != true)
                hActive.Target = 0;
            else
                hActive.Target = 1;
            try
            {
                IOPCGroupStateMgtObj.SetState(pRequestedUpdateRate, out nRevUpdateRate, hActive.AddrOfPinnedObject(), pTimeBias, pDeadband, pLCID, hClientGroup);
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
            finally
            {
                hActive.Free();
            }
        }
        /// <summary>
        /// 断开PC到PLC的连接
        /// </summary>
        /// <returns>是否成功执行</returns>
        public bool DisConnect()
        {
            try
            {
                if (dwCookie != 0)
                {
                    pIConnectionPoint.Unadvise(dwCookie);
                    dwCookie = 0;
                }
                // Free unmanaged code  
                Marshal.ReleaseComObject(pIConnectionPoint);
                pIConnectionPoint = null;

                Marshal.ReleaseComObject(pIConnectionPointContainer);
                pIConnectionPointContainer = null;

                if (IOPCAsyncIO2Obj != null)
                {
                    Marshal.ReleaseComObject(IOPCAsyncIO2Obj);
                    IOPCAsyncIO2Obj = null;
                }

                ServerObj.RemoveGroup(pSvrGroupHandle, 0);
                if (IOPCGroupStateMgtObj != null)
                {
                    Marshal.ReleaseComObject(IOPCGroupStateMgtObj);
                    IOPCGroupStateMgtObj = null;
                }
                if (MyobjGroup1 != null)
                {
                    Marshal.ReleaseComObject(MyobjGroup1);
                    MyobjGroup1 = null;
                }
                if (ServerObj != null)
                {
                    Marshal.ReleaseComObject(ServerObj);
                    ServerObj = null;
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }

        }
        #endregion

        #region  Public Properity
        public OpcRcw.Da.IOPCServer Server
        {
            get
            {
                return this.ServerObj;
            }
        }
        #endregion
    }

}

如何使用的范例：

由于上面的代码只是简单的封装了OPC的基本操作，然而却在项目中使用并不简洁方便，为此又写了一个接口。

/*********************************************************************
 * 模块名称：定义在操作PLC的常用操作和属性
 * 作    者：龙少爷
 * 时    间：2010-11-24 11:44
 * 备    注：
 * 
 * 历史修改记录
 * 作    者：
 * 修改时间：
 * 备    注：
 * 
 * *******************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Picking
{
    /// <summary>
    /// 定义在操作PLC的常用操作和属性
    /// </summary>
    public interface IPLCOperator
    {
        /// <summary>
        /// 数据库是否已经连接上
        /// </summary>
        bool IsConnected { get; set; }
        /// <summary>
        /// 建立PC到PLC的连接，由指定的adviser参数对象来处理事件的结果
        /// </summary>
        /// <param name="adviser">接受处理结果的对象</param>
        /// <returns>true/false</returns>
        bool ConnectToPLC(string programID, string server, object adviser);

        bool ReadFromPLCDB();

        bool WriteIntoPLCDB(object[] values);

        bool SetPLCState(bool state);

        bool DisConnectFromPLC();


    }
}

与PLC交互的代码，之所以这样写一个单独的类，是为了在同时读写多个ITEM项时，能把每个操作独立出来处理：

/*********************************************************************
 * 模块名称：
 * 作    者：龙少爷
 * 时    间：2010-11-24 13:44
 * 备    注：
 * 
 * 历史修改记录
 * 作    者：
 * 修改时间：
 * 备    注：
 * 
 * *******************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Utility.PLC;

using OpcRcw.Da;

namespace Picking
{
    /// <summary>
    /// 
    /// </summary>
    public class DLStopLine : IOPCDataCallback, IPLCOperator
    {
        #region  私有变量
        private OPCServer opcServer = null;
        #endregion

        #region Public Constructor
        public DLStopLine()
        {
            opcServer = new OPCServer();
        }
        #endregion

        #region IPLCOperator 成员

        public bool IsConnected
        {
            get;
            set;
        }

        public bool ConnectToPLC(string programID, string server, object adviser)
        {
            if (!opcServer.CreateServer(programID, server))
            {
                IsConnected = false;
                return false;
            }
            if (!opcServer.AddGroup(adviser))
            {
                IsConnected = false;
                return false;
            }
            OpcRcw.Da.OPCITEMDEF[] items = new OPCITEMDEF[1];//定义读写的item，共个变量   
            items[0].szAccessPath = "";
            items[0].szItemID = "S7:[S7 connection_1]DB20,B1";    //地址，不同数据类型表示方法不同   
            items[0].bActive = 1;//是否激活   
            items[0].hClient = 1;//表示ID   
            items[0].dwBlobSize = 0;
            items[0].pBlob = IntPtr.Zero;
            items[0].vtRequestedDataType = 17;

            if (!opcServer.AddItems(items))
            {
                IsConnected = false;
                return false;
            }
            IsConnected = true;
            return true;
        }

        public bool ConnectToPLC(string programID, string server)
        {
            return ConnectToPLC(programID, server, this);
        }

        public bool ConnectToPLC(object adviser)
        {
            return ConnectToPLC("OPC.SimaticNet", "localhost", adviser);
        }

        public bool ConnectToPLC()
        {
            return ConnectToPLC("OPC.SimaticNet", "localhost", this);
        }

        public bool ReadFromPLCDB()
        {
            return opcServer.Read();
        }

        public bool WriteIntoPLCDB(object[] values)
        {
            return opcServer.Write(values);
        }

        public bool SetPLCState(bool state)
        {
            return opcServer.SetState(state);
        }

        public bool DisConnectFromPLC()
        {
            return opcServer.DisConnect();
        }

        #endregion

        #region IOPCDataCallback 成员

        public void OnCancelComplete(int dwTransid, int hGroup)
        {

        }

        public void OnDataChange(int dwTransid, int hGroup, int hrMasterquality, int hrMastererror, int dwCount, int[] phClientItems, object[] pvValues, short[] pwQualities, FILETIME[] pftTimeStamps, int[] pErrors)
        {

        }

        public void OnReadComplete(int dwTransid, int hGroup, int hrMasterquality, int hrMastererror, int dwCount, int[] phClientItems, object[] pvValues, short[] pwQualities, FILETIME[] pftTimeStamps, int[] pErrors)
        {

        }

        public void OnWriteComplete(int dwTransid, int hGroup, int hrMastererr, int dwCount, int[] pClienthandles, int[] pErrors)
        {

        }

        #endregion

        #region  Destructor
        ~DLStopLine()
        {
            if (IsConnected)
                opcServer.DisConnect();
        }
        #endregion

    }
}

　在项目中，编写相应的调用代码即可。

            DLStopLine stopLine = new DLStopLine();
            stopLine.ConnectToPLC();

            values = new object[1];
            values[0] = 1;
            stopLine.WriteIntoPLCDB(values);