OPC自定义接口来实现客户端数据的读取

上篇博文分享了我的知识库,被好多人关注,受宠若惊。今天我把我在项目中封装的OPC自定义接口的程序分享一下。下面将会简单简单介绍下OPC DA客户端数据访问,以及搭配整个系统的运行环境。

  • OPC(OLE for Process Control)其实就是一套标准,我对这套标准理解不多,使用过程中就把它理解一套协议或者规范,主要用于工控领域。OPC中有很多规范,我主要使用OPC DA规范来进行数据的读写操作。还有其他规范,比如OPC UA、OPC HDA等。如果你做的是OPC Server开发查下这方面的资料了解下,这篇博文主要介绍OPC Client开发的知识。

  使用OPC DA进行Client的读写操作时,我们使用Custom接口,出此之外还有Automation接口。以下是Custome接口开发时涉及到的三个关键对象:OpcServer、OpcGroup、OpcItem,下图是他们之间的逻辑关系:

  

 

  在客户端开发时,要使用OpcServer对象来实现客户端与Opc服务器之间的连接。一个OpcServer对象下有多个OpcGroup,一个OpcGroup下有多个OpcItem,在自定义接口下的Client开发,是以Group为单位的操作,数据读写都是通过OpcGroup进行的。

  •   搭建程序运行环境

    程序运行需要的软硬件环境:

    1. .Net Framework 4.0
    2. Simatic Net 2008(Or Other) HF1
    3. 西门子300(Or Other) PLC

    我们可以通过本机的配置来实现OPC的远程连接,我没有采用这种方式,一是这种配置比较麻烦,而是这种方式不稳定。所以我采用本机安装一个OPCServer来实现与PLC的交互。

    对于OPCServer软件,我选择的是SimaticNet 2008 HF1(安装WinCC的时候会有选择安装SimaticNet的选项),没有特别的原因,就是比较熟悉了而已,而且PLC选用的是西门子的。

    我们可以不写OPC Client程序来测试,如何通过OPCServer与PLC之间的交互。首先当我们安装完毕SimaticNet之后,需要对Station Configuration Editor进行配置,如下图:

    

    首先我们要指定Station的名称,上图叫PCStation,点击下方的StationName可以进行更改。下一步在1号栈上选择一个OPCServer,3号栈上选择一个通信网卡。

    接下来我们需要在Step 7中建立Station Configuration Editor与PLC之间的连接,我们暂且叫组态。组态的过程中要建立与Station Configuration Editor中对应的Opc Server和IE General(所在栈号相同),Station Configuration Edition起到桥接的作用    用,主要让PLC与Opc Server之间建立一条S7连接。暂时没有拿到组态图,以后补上。

    当我们组态完毕时,如何判断组态是否正确呢?在SimaticNet的目录上有个叫Opc Scout(Opc Scout V10)的软件,打开如下图:

    

    上图列出来了本机所有的Server,我们能使用名为OPC.SimaticNET的Server。双击这个Server添加一个组,多次双击这个Server可以添加多个组,验证了上图的Server与Group的关系了。

    我们双击新建的Group,进入如下图的界面:

    

    上图列出了所有的连接。上文说到的组态中建立的S7连接可以在S7节点中看到,展开这个节点可以看到我们建立的S7连接,如下图:

    

       上图列出了名为S7 connection_1的S7连接,展开Object对象,列出PLC的结构。我们选择一种来新建我们的Item,由于我这里没有PLC模块,所以无法截图给大家看。

    至此我们的OPC Client的运行环境搭建完毕。

  •  编写OPC Client端程序。

    我们需要使用OPC Foundation提供的自定义接口来进行开发,在Visual Studio引用名为:OpcRcw.Comn.dll和OpcRcw.Da.dll这两个DLL。

    我们定义一个名为OpcDaCustomAsync的类,让这个类继承自:IOPCDataCallback,IDisposable

    

复制代码

  1 using System;
  2 using System.Collections.Generic;
  3 using OpcRcw.Comn;
  4 using OpcRcw.Da;
  5 using System.Runtime.InteropServices;
  6 
  7 namespace Opc.Net
  8 {
  9     /// <summary>
 10     /// Opc自定义接口-异步管理类
 11     /// <author name="lm" date="2012.3.14"/>
 12     /// </summary>
 13     public class OpcDaCustomAsync : IOPCDataCallback,IDisposable
 14     {
 15         /// <summary>
 16         /// OPC服务器对象
 17         /// </summary>
 18         IOPCServer iOpcServer;
 19         /// <summary>
 20         /// 事务ID
 21         /// </summary>
 22         int transactionID;
 23         /// <summary>
 24         /// OPC服务器名称
 25         /// </summary>
 26         string opcServerName;
 27         /// <summary>
 28         /// OPC服务器IP地址
 29         /// </summary>
 30         IOPCAsyncIO2 _iopcAsyncIo2;
 31         /// <summary>
 32         /// OPC服务器IP地址
 33         /// </summary>
 34         string opcServerIPAddress;
 35         /// <summary>
 36         /// Opc组列表
 37         /// </summary>
 38         List<OpcDaCustomGroup> opcDaCustomGroups;
 39         /// <summary>
 40         /// 连接指针容器
 41         /// </summary>
 42         IConnectionPointContainer IConnectionPointContainer = null;
 43         /// <summary>
 44         /// 连接指针
 45         /// </summary>
 46         IConnectionPoint IConnectionPoint = null;
 47         /// <summary>
 48         /// Opc组管理器
 49         /// </summary>
 50         IOPCGroupStateMgt IOPCGroupStateMgt = null;
 51 
 52 
 53         //接收数据事件
 54         public event EventHandler<OpcDaCustomAsyncEventArgs> OnDataChanged;
 55         /// <summary>
 56         /// 异步写入数据完成事件
 57         /// </summary>
 58         public event EventHandler<OpcDaCustomAsyncEventArgs> OnWriteCompleted;
 59         /// <summary>
 60         /// 异步读取数据完成事件
 61         /// </summary>
 62         public event EventHandler<OpcDaCustomAsyncEventArgs> OnReadCompleted;
 63 
 64         /// <summary>
 65         /// 构造函数
 66         /// </summary>
 67         /// <param name="opcDaCustomGroups">Opc组列表</param>
 68         /// <param name="opcServerName">OPC服务器名称</param>
 69         /// <param name="opcServerIpAddress">OPC服务器IP地址</param>
 70         public OpcDaCustomAsync(List<OpcDaCustomGroup> opcDaCustomGroups, string opcServerName, string opcServerIpAddress)
 71         {
 72             this.opcDaCustomGroups = opcDaCustomGroups;
 73             this.opcServerName = opcServerName;
 74             this.opcServerIPAddress = opcServerIpAddress;
 75             Init();
 76         }
 77         /// <summary>
 78         /// 初始化参数
 79         /// </summary>
 80         public void Init()
 81         {
 82             if (Connect())
 83             {
 84                 AddOpcGroup();
 85             }
 86         }
 87 
 88         /// <summary>
 89         /// 连接Opc服务器
 90         /// </summary>
 91         /// <returns></returns>
 92         public bool Connect()
 93         {
 94             return Connect(opcServerName, opcServerIPAddress);
 95         }
 96         /// <summary>
 97         /// 连接Opc服务器
 98         /// </summary>
 99         /// <returns></returns>
100         public bool Connect(string remoteOpcServerName, string remoteOpcServerIpAddress)
101         {
102             var returnValue = false;
103             if (!string.IsNullOrEmpty(remoteOpcServerIpAddress) && !string.IsNullOrEmpty(remoteOpcServerName))
104             {
105                 var opcServerType = Type.GetTypeFromProgID(remoteOpcServerName, remoteOpcServerIpAddress);
106                 if (opcServerType != null)
107                 {
108                     iOpcServer = (IOPCServer)Activator.CreateInstance(opcServerType);
109                     returnValue = true;
110                 }
111             }  
112             return returnValue;
113         }
114         /// <summary>
115         /// 添加Opc组
116         /// </summary>
117         private void AddOpcGroup()
118         {
119             try
120             {
121                 foreach (OpcDaCustomGroup opcGroup in opcDaCustomGroups)
122                 {
123                     AddOpcGroup(opcGroup);
124                 }
125             }
126             catch(COMException ex)
127             {
128                 throw ex;
129             }
130         }
131         /// <summary>
132         /// 添加Opc项
133         /// </summary>
134         /// <param name="opcGroup"></param>
135         private void AddOpcGroup(OpcDaCustomGroup opcGroup)
136         {
137             try
138             {
139 
140                 //添加OPC组
141                 iOpcServer.AddGroup(opcGroup.GroupName, opcGroup.IsActive, opcGroup.RequestedUpdateRate, opcGroup.ClientGroupHandle, opcGroup.TimeBias.AddrOfPinnedObject(), opcGroup.PercendDeadBand.AddrOfPinnedObject(), opcGroup.LCID, out opcGroup.ServerGroupHandle, out opcGroup.RevisedUpdateRate, ref opcGroup.Riid, out opcGroup.Group);
142                 InitIoInterfaces(opcGroup);
143                 if (opcGroup.OpcDataCustomItems.Length > 0)
144                 {
145                     //添加OPC项
146                     AddOpcItem(opcGroup);
147                     //激活订阅回调事件
148                     ActiveDataChanged(IOPCGroupStateMgt);
149                 }
150             }
151             catch (COMException ex)
152             {
153                 throw ex;
154             }
155             finally
156             {
157                 if (opcGroup.TimeBias.IsAllocated)
158                 {
159                     opcGroup.TimeBias.Free();
160                 }
161                 if (opcGroup.PercendDeadBand.IsAllocated)
162                 {
163                     opcGroup.PercendDeadBand.Free();
164                 }
165             }
166         }
167         /// <summary>
168         /// 初始化IO接口
169         /// </summary>
170         /// <param name="opcGroup"></param>
171         public void InitIoInterfaces(OpcDaCustomGroup opcGroup)
172         {
173             int cookie;
174             //组状态管理对象,改变组的刷新率和激活状态
175             IOPCGroupStateMgt = (IOPCGroupStateMgt)opcGroup.Group;
176             IConnectionPointContainer = (IConnectionPointContainer)opcGroup.Group;
177             Guid iid = typeof(IOPCDataCallback).GUID;
178             IConnectionPointContainer.FindConnectionPoint(ref iid, out IConnectionPoint);
179             //创建客户端与服务端之间的连接
180             IConnectionPoint.Advise(this, out 
181                     cookie);
182         }
183         /// <summary>
184         /// 激活订阅回调事件
185         /// </summary>
186         private void ActiveDataChanged(IOPCGroupStateMgt IOPCGroupStateMgt)
187         {
188             IntPtr pRequestedUpdateRate = IntPtr.Zero;
189             IntPtr hClientGroup = IntPtr.Zero;
190             IntPtr pTimeBias = IntPtr.Zero;
191             IntPtr pDeadband = IntPtr.Zero;
192             IntPtr pLCID = IntPtr.Zero;
193             int nActive = 0;
194             GCHandle hActive = GCHandle.Alloc(nActive, GCHandleType.Pinned);
195             try
196             {
197                 hActive.Target = 1;
198                 int nRevUpdateRate = 0;
199                 IOPCGroupStateMgt.SetState(pRequestedUpdateRate, out nRevUpdateRate,
200                         hActive.AddrOfPinnedObject(), pTimeBias, pDeadband, pLCID, hClientGroup);
201             }
202             catch (COMException ex)
203             {
204                 throw ex;
205             }
206             finally
207             {
208                 hActive.Free();
209             }
210         }
211 
212         /// <summary>
213         /// 添加Opc项
214         /// </summary>
215         /// <param name="opcGroup"></param>
216         private void AddOpcItem(OpcDaCustomGroup opcGroup)
217         {
218             OpcDaCustomItem[] opcDataCustomItemsService = opcGroup.OpcDataCustomItems;
219             IntPtr pResults = IntPtr.Zero;
220             IntPtr pErrors = IntPtr.Zero;
221             OPCITEMDEF[] itemDefyArray = new OPCITEMDEF[opcGroup.OpcDataCustomItems.Length];
222             int i = 0;
223             int[] errors = new int[opcGroup.OpcDataCustomItems.Length];
224             int[] itemServerHandle = new int[opcGroup.OpcDataCustomItems.Length];
225             try
226             {
227                 foreach (OpcDaCustomItem itemService in opcDataCustomItemsService)
228                 {
229                     if (itemService != null)
230                     {
231                         itemDefyArray[i].szAccessPath = itemService.AccessPath;
232                         itemDefyArray[i].szItemID = itemService.ItemID;
233                         itemDefyArray[i].bActive = itemService.IsActive;
234                         itemDefyArray[i].hClient = itemService.ClientHandle;
235                         itemDefyArray[i].dwBlobSize = itemService.BlobSize;
236                         itemDefyArray[i].pBlob = itemService.Blob;
237                         itemDefyArray[i].vtRequestedDataType = itemService.RequestedDataType;
238                         i++;
239                     }
240 
241                 }
242                 //添加OPC项组
243                 ((IOPCItemMgt)opcGroup.Group).AddItems(opcGroup.OpcDataCustomItems.Length, itemDefyArray, out pResults, out pErrors);
244                 IntPtr Pos = pResults;
245                 Marshal.Copy(pErrors, errors, 0, opcGroup.OpcDataCustomItems.Length);
246                 for (int j = 0; j < opcGroup.OpcDataCustomItems.Length; j++)
247                 {
248                     if (errors[j] == 0)
249                     {
250                         if (j != 0)
251                         {
252                             Pos = new IntPtr(Pos.ToInt32() + Marshal.SizeOf(typeof(OPCITEMRESULT)));
253                         }
254                         var result = (OPCITEMRESULT)Marshal.PtrToStructure(Pos, typeof(OPCITEMRESULT));
255                         itemServerHandle[j] = opcDataCustomItemsService[j].ServerHandle = result.hServer;
256                         Marshal.DestroyStructure(Pos, typeof(OPCITEMRESULT));
257                     }
258                 }
259             }
260             catch (COMException ex)
261             {
262                 throw ex;
263             }
264             finally
265             {
266                 if (pResults != IntPtr.Zero)
267                 {
268                     Marshal.FreeCoTaskMem(pResults);
269                 }
270                 if (pErrors != IntPtr.Zero)
271                 {
272                     Marshal.FreeCoTaskMem(pErrors);
273                 }
274             }
275         }
276         /// <summary>
277         /// 异步读取信息
278         /// </summary>
279         public void Read()
280         {
281             foreach (OpcDaCustomGroup opcGroup in opcDaCustomGroups)
282             {
283                 IntPtr pErrors = IntPtr.Zero;
284                 try
285                 {
286                     _iopcAsyncIo2 = (IOPCAsyncIO2)opcGroup.Group;
287                     if (_iopcAsyncIo2 != null)
288                     {
289                         int[] serverHandle = new int[opcGroup.OpcDataCustomItems.Length];
290                         opcGroup.PErrors = new int[opcGroup.OpcDataCustomItems.Length];
291                         for (int j = 0; j < opcGroup.OpcDataCustomItems.Length; j++)
292                         {
293                             serverHandle[j] = opcGroup.OpcDataCustomItems[j].ServerHandle;
294                         }
295                         int cancelId=0;
296                         _iopcAsyncIo2.Read(opcGroup.OpcDataCustomItems.Length, serverHandle, 2, out cancelId, out pErrors);
297                         Marshal.Copy(pErrors, opcGroup.PErrors, 0, opcGroup.OpcDataCustomItems.Length);
298                     }
299                 }
300                 catch (COMException ex)
301                 {
302                     throw ex;
303                 }
304                 finally
305                 {
306                     if (pErrors != IntPtr.Zero)
307                     {
308                         Marshal.FreeCoTaskMem(pErrors);
309                     }
310                 }
311             }
312         }
313 
314         /// <summary>
315         /// 异步写入数据
316         /// </summary>
317         /// <param name="values">要写入的值</param>
318         /// <param name="serverHandle">要写入的项的服务器句柄</param>
319         /// <param name="errors">错误信息,等于表示写入成功,否则写入失败</param>
320         /// <param name="opcGroup">要写入的Opc组</param>
321         public void Write(object[] values,int[] serverHandle,out int[] errors,OpcDaCustomGroup opcGroup)
322         {
323             _iopcAsyncIo2 = (IOPCAsyncIO2)opcGroup.Group;
324             IntPtr pErrors = IntPtr.Zero;
325             errors = new int[values.Length];
326             if (_iopcAsyncIo2 != null)
327             {
328                 try
329                 {
330                     //异步写入数据
331                     int cancelId;
332                     _iopcAsyncIo2.Write(values.Length, serverHandle, values, transactionID + 1, out cancelId, out pErrors);
333                     Marshal.Copy(pErrors, errors, 0, values.Length);
334                 }
335                 catch (COMException ex)
336                 {
337                     throw ex;
338                 }
339                 finally
340                 {
341                     if (pErrors != IntPtr.Zero)
342                     {
343                         Marshal.FreeCoTaskMem(pErrors);
344                     }
345                 }
346             }
347         }
348         /// <summary>
349         /// 数据订阅事件
350         /// </summary>
351         /// <param name="dwTransid"></param>
352         /// <param name="hGroup"></param>
353         /// <param name="hrMasterquality"></param>
354         /// <param name="hrMastererror"></param>
355         /// <param name="dwCount"></param>
356         /// <param name="phClientItems"></param>
357         /// <param name="pvValues"></param>
358         /// <param name="pwQualities"></param>
359         /// <param name="pftTimeStamps"></param>
360         /// <param name="pErrors"></param>
361         public virtual void OnDataChange(Int32 dwTransid,
362             Int32 hGroup,
363             Int32 hrMasterquality,
364             Int32 hrMastererror,
365             Int32 dwCount,
366             int[] phClientItems,
367             object[] pvValues,
368             short[] pwQualities,
369             OpcRcw.Da.FILETIME[] pftTimeStamps,
370             int[] pErrors)
371         
372         {
373             var e = new OpcDaCustomAsyncEventArgs
374             {
375                 GroupHandle = hGroup,
376                 Count = dwCount,
377                 Errors = pErrors,
378                 Values = pvValues,
379                 ClientItemsHandle = phClientItems
380             };
381             if (OnDataChanged != null)
382             {
383                 OnDataChanged(this, e);
384             }
385         }
386 
387         /// <summary>
388         /// 取消事件
389         /// </summary>
390         /// <param name="dwTransid"></param>
391         /// <param name="hGroup"></param>
392         public virtual void OnCancelComplete(Int32 dwTransid, Int32 hGroup)
393         {
394 
395         }
396 
397         /// <summary>
398         /// 写入数据完成事件
399         /// </summary>
400         /// <param name="dwTransid"></param>
401         /// <param name="hGroup"></param>
402         /// <param name="hrMastererr"></param>
403         /// <param name="dwCount"></param>
404         /// <param name="pClienthandles"></param>
405         /// <param name="pErrors"></param>
406         public virtual void OnWriteComplete(Int32 dwTransid,
407             Int32 hGroup,
408             Int32 hrMastererr,
409             Int32 dwCount,
410             int[] pClienthandles,
411             int[] pErrors)
412         {
413             if (OnWriteCompleted != null)
414             {
415                 var e = new OpcDaCustomAsyncEventArgs
416                 {
417                     Errors = pErrors
418                 };
419                 if (OnWriteCompleted != null)
420                 {
421                     OnWriteCompleted(this, e);
422                 }
423             }
424         }
425         /// <summary>
426         /// 读取数据完成事件
427         /// </summary>
428         /// <param name="dwTransid"></param>
429         /// <param name="hGroup"></param>
430         /// <param name="hrMasterquality"></param>
431         /// <param name="hrMastererror"></param>
432         /// <param name="dwCount">要读取的组的项的个数</param>
433         /// <param name="phClientItems"></param>
434         /// <param name="pvValues">项值列表</param>
435         /// <param name="pwQualities"></param>
436         /// <param name="pftTimeStamps"></param>
437         /// <param name="pErrors">项错误列表</param>
438         public virtual void OnReadComplete(Int32 dwTransid,
439             Int32 hGroup,
440             Int32 hrMasterquality,
441             Int32 hrMastererror,
442             Int32 dwCount,
443             int[] phClientItems,
444             object[] pvValues,
445             short[] pwQualities,
446             OpcRcw.Da.FILETIME[] pftTimeStamps,
447             int[] pErrors)
448         {
449             if (OnReadCompleted != null)
450             {
451                 var e = new OpcDaCustomAsyncEventArgs
452                 {
453                     GroupHandle = hGroup,
454                     Count = dwCount,
455                     Errors = pErrors,
456                     Values = pvValues,
457                     ClientItemsHandle = phClientItems
458                 };
459                 OnReadCompleted(this, e);
460             }
461         }
462         public void Dispose()
463         {
464 
465         }
466     }
467 }

复制代码

我们看下IOPCDataCallback接口的定义:

这个接口提供了4个函数。如果我们采用订阅模式(默认的模式),会执行OnDataChange函数,主动读数据则执行OnReadComplete函数,写数据则执行OnWriteComplete函数。在OpcDaCustomAsync类中,我已经对这四个函数进行了实现,每个实现对应一个事件。

OpcDaCustomAsync类的实现,我主要是扒了SimaticNet下的一个Sample,自己封装了下。使用这个类的时候需要提供Group列表和OPCServer的名称,以及OPCServer所在的主机的IP地址。

OpcGroup的封装:

复制代码

  1 using System;
  2 using System.Runtime.InteropServices;
  3 using OpcRcw.Da;
  4 
  5 namespace Opc.Net
  6 {
  7     /// <summary>
  8     /// 自定义接口OPC组对象
  9     /// </summary>
 10     public class OpcDaCustomGroup
 11     {
 12         private string groupName;
 13         private int isActive=1;
 14         private int requestedUpdateRate;
 15         private int clientGroupHandle=1;
 16         private GCHandle timeBias = GCHandle.Alloc(0, GCHandleType.Pinned);
 17         private GCHandle percendDeadBand = GCHandle.Alloc(0, GCHandleType.Pinned);
 18         private int lcid = 0x409;
 19         private int itemCount;
 20         private bool onRead;
 21 
 22         /// <summary>
 23         /// 输出参数,服务器为新创建的组对象产生的句柄
 24         /// </summary>
 25         public int ServerGroupHandle;
 26 
 27         /// <summary>
 28         /// 输出参数,服务器返回给客户端的实际使用的数据更新率
 29         /// </summary>
 30         public int RevisedUpdateRate;
 31 
 32         /// <summary>
 33         /// 引用参数,客户端想要的组对象的接口类型(如 IIDIOPCItemMgt)
 34         /// </summary>
 35         public Guid Riid = typeof(IOPCItemMgt).GUID;
 36 
 37         /// <summary>
 38         /// 输出参数,用来存储返回的接口指针。如果函数操作出现任务失败,此参数将返回NULL。
 39         /// </summary>
 40         public object Group;
 41         private OpcDaCustomItem[] opcDataCustomItems;
 42 
 43         public int[] PErrors { get; set; }
 44 
 45         /// <summary>
 46         /// 组对象是否激活
 47         /// 1为激活,0为未激活,默认激活
 48         /// </summary>
 49         public int IsActive
 50         {
 51             get
 52             {
 53                 return isActive;
 54             }
 55             set
 56             {
 57                 if (isActive == value)
 58                     return;
 59                 isActive = value;
 60             }
 61         }
 62         /// <summary>
 63         /// 组是否采用异步读方式
 64         /// </summary>
 65         public bool OnRead
 66         {
 67             get
 68             {
 69                 return onRead;
 70             }
 71             set
 72             {
 73                 if (onRead == value)
 74                     return;
 75                 onRead = value;
 76             }
 77         }
 78         /// <summary>
 79         /// 项的个数
 80         /// </summary>
 81         public int ItemCount
 82         {
 83             get { return itemCount; }
 84             set 
 85             {
 86                 if(itemCount == value)
 87                     return;
 88                 itemCount=value;
 89             }
 90         }
 91         /// <summary>
 92         /// 客户端指定的数据变化率
 93         /// </summary>
 94         public int RequestedUpdateRate
 95         {
 96             get
 97             {
 98                 return requestedUpdateRate;
 99             }
100             set
101             {
102                 if (requestedUpdateRate == value)
103                     return;
104                 requestedUpdateRate = value;
105             }
106         }
107 
108         /// <summary>
109         /// OPC组名称
110         /// </summary>
111         public string GroupName
112         {
113             get
114             {
115                 return groupName;
116             }
117             set
118             {
119                 if (groupName == value)
120                     return;
121                 groupName = value;
122             }
123         }
124 
125         /// <summary>
126         /// 客户端程序为组对象提供的句柄
127         /// </summary>
128         public int ClientGroupHandle
129         {
130             get
131             {
132                 return clientGroupHandle;
133             }
134             set
135             {
136                 if (clientGroupHandle == value)
137                     return;
138                 clientGroupHandle = value;
139             }
140         }
141 
142         /// <summary>
143         /// 指向Long类型的指针
144         /// </summary>
145         public GCHandle TimeBias
146         {
147             get
148             {
149                 return timeBias;
150             }
151             set
152             {
153                 if (timeBias == value)
154                     return;
155                 timeBias = value;
156             }
157         }
158 
159         /// <summary>
160         /// 一个项对象的值变化的百分比,可能引发客户端程序的订阅回调。
161         /// 此参数只应用于组对象中有模拟dwEUType(工程单位)类型的项对象。指针为NULL表示0.0
162         /// </summary>
163         public GCHandle PercendDeadBand
164         {
165             get
166             {
167                 return percendDeadBand;
168             }
169             set
170             {
171                 if (percendDeadBand == value)
172                     return;
173                 percendDeadBand = value;
174             }
175         }
176 
177         /// <summary>
178         /// 当用于组对象上的操作的返回值为文本类型时,服务器使用的语言
179         /// </summary>
180         public int LCID
181         {
182             get
183             {
184                 return lcid;
185             }
186             set
187             {
188                 if (lcid == value)
189                     return;
190                 lcid = value;
191             }
192         }
193 
194         /// <summary>
195         /// OPC项数组
196         /// </summary>
197         public OpcDaCustomItem[] OpcDataCustomItems
198         {
199             get
200             {
201                 return opcDataCustomItems;
202             }
203             set
204             {
205                 if (opcDataCustomItems != null && opcDataCustomItems == value)
206                     return;
207                 opcDataCustomItems = value;
208             }
209         }
210     }
211 }

复制代码

OpcItem的封装:

复制代码

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 using System.Runtime.InteropServices;
  6 using OpcRcw.Da;
  7 
  8 namespace Opc.Net
  9 {
 10     /// <summary>
 11     /// 自定义接口Opc项
 12     /// </summary>
 13     public class OpcDaCustomItem
 14     {
 15         private string name;
 16         private string accessPath="";
 17         private string itemID;
 18         private int isActive = 1;
 19         private int clientHandle = 0;
 20         private int blobSize = 0;
 21         private IntPtr blob = IntPtr.Zero;
 22         private short requestedDataType = 0;
 23         private object itemValue;
 24         private int serverHandle;
 25 
 26         /// <summary>
 27         /// 项名称
 28         /// </summary>
 29         public string Name
 30         {
 31             get
 32             {
 33                 return name;
 34             }
 35             set
 36             {
 37                 if (name == value)
 38                     return;
 39                 name = value;
 40             }
 41         }
 42         /// <summary>
 43         /// 项对象的访问路径
 44         /// </summary>
 45         public string AccessPath
 46         {
 47             get
 48             {
 49                 return accessPath;
 50             }
 51             set
 52             {
 53                 if (accessPath == value)
 54                     return;
 55                 accessPath = value;
 56             }
 57         }
 58 
 59         /// <summary>
 60         /// 项对象的ItemIDea,唯一标识该数据项
 61         /// </summary>
 62         public string ItemID
 63         {
 64             get
 65             {
 66                 return itemID;
 67             }
 68             set
 69             {
 70                 if (itemID == value)
 71                     return;
 72                 itemID = value;
 73             }
 74         }
 75 
 76         /// <summary>
 77         /// 项对象的激活状态
 78         /// 1为激活,0为未激活,默认激活
 79         /// </summary>
 80         public int IsActive
 81         {
 82             get
 83             {
 84                 return isActive;
 85             }
 86             set
 87             {
 88                 if (isActive == value)
 89                     return;
 90                 isActive = value;
 91             }
 92         }
 93 
 94         /// <summary>
 95         /// 项对象的客户端句柄
 96         /// </summary>
 97         public int ClientHandle
 98         {
 99             get
100             {
101                 return clientHandle;
102             }
103             set
104             {
105                 if (clientHandle == value)
106                     return;
107                 clientHandle = value;
108             }
109         }
110         public int BlobSize
111         {
112             get
113             {
114                 return blobSize;
115             }
116             set
117             {
118                 if (blobSize == value)
119                     return;
120                 blobSize = value;
121             }
122         }
123         public IntPtr Blob
124         {
125             get
126             {
127                 return blob;
128             }
129             set
130             {
131                 if (blob == value)
132                     return;
133                 blob = value;
134             }
135         }
136 
137         /// <summary>
138         /// OPC项的数据类型
139         /// VbBoolean:11,VbByte:17,VbDecimal:14,VbDouble:5,Vbinteger:2,VbLong:3,VbSingle:4,VbString:8
140         /// </summary>
141         public short RequestedDataType
142         {
143             get
144             {
145                 return requestedDataType;
146             }
147             set
148             {
149                 if (requestedDataType == value)
150                     return;
151                 requestedDataType = value;
152             }
153         }
154 
155        /// <summary>
156        /// OPC项的值
157        /// </summary>
158         public object Value
159         {
160             get
161             {
162                 return itemValue;
163             }
164             set
165             {
166                 if (itemValue == value)
167                     return;
168                 itemValue = value;
169             }
170         }
171 
172         /// <summary>
173         /// OPC项的服务器句柄
174         /// </summary>
175         public int ServerHandle
176         {
177             get
178             {
179                 return serverHandle;
180             }
181             set
182             {
183                 if (serverHandle == value)
184                     return;
185                 serverHandle = value;
186             }
187         }
188     }
189 }

复制代码

项的客户端句柄和服务器句柄实际是一样的,项的数据类型用short表示,在下面的配置文件中体现出来了。

以下是我设计的配置文件:

复制代码

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <System>
 3   <OpcServer ServerName="OPC.SimaticNET" IPAddress="10.102.102.118">
 4     <!--采煤机参数-->
 5     <ShearerInfo GroupName="ShearerInfoGroup" ClientHandle="1" UpdateRate="100">
 6       <!--左牵,1表示左牵,0表示未运动-->
 7       <Item ItemID="S7:[S7 connection_2]DB201,X20.2" ClientHandle="1" RequestedDataType="11"></Item>
 8       <!--右牵,1表示右牵,0表示未运动-->
 9       <Item ItemID="S7:[S7 connection_2]DB201,X20.1" ClientHandle="2" RequestedDataType="11"></Item>
10       <!--牵引速度-->
11       <Item ItemID="S7:[S7 connection_2]DB201,REAL40" ClientHandle="3" RequestedDataType="5"></Item>
12       <!--采煤机位置-->
13       <Item ItemID="S7:[S7 connection_2]DB201,REAL44" ClientHandle="4" RequestedDataType="5"></Item>
14       <!--左滚筒高度-->
15       <Item ItemID="S7:[S7 connection_2]DB201,REAL48" ClientHandle="5" RequestedDataType="5"></Item>
16       <!--右滚筒高度-->
17       <Item ItemID="S7:[S7 connection_2]DB201,REAL52" ClientHandle="6" RequestedDataType="5"></Item>
18       <!--左截电流-->
19       <Item ItemID="S7:[S7 connection_2]DB201,INT6" ClientHandle="7" RequestedDataType="2"></Item>
20       <!--右截电流-->
21       <Item ItemID="S7:[S7 connection_2]DB201,INT8" ClientHandle="8" RequestedDataType="2"></Item>
22       <!--左牵电流-->
23       <Item ItemID="S7:[S7 connection_2]DB201,INT2" ClientHandle="9" RequestedDataType="2"></Item>
24       <!--右牵电流-->
25       <Item ItemID="S7:[S7 connection_2]DB201,INT4" ClientHandle="10" RequestedDataType="2"></Item>
26       <!--左截启-->
27       <Item ItemID="S7:[S7 connection_2]DB201,X20.6" ClientHandle="11" RequestedDataType="11"></Item>
28       <!--右截启-->
29       <Item ItemID="S7:[S7 connection_2]DB201,X20.5" ClientHandle="12" RequestedDataType="11"></Item>
30       <!--左截温度-->
31       <Item ItemID="S7:[S7 connection_2]DB201,INT10" ClientHandle="13" RequestedDataType="2"></Item>
32       <!--右截温度-->
33       <Item ItemID="S7:[S7 connection_2]DB201,INT12" ClientHandle="14" RequestedDataType="2"></Item>
34       <!--油泵电机电流-->
35       <Item ItemID="S7:[S7 connection_2]DB201,INT14" ClientHandle="15" RequestedDataType="2"></Item>
36       <!--工作模式 2人工 4学习 8自动割煤 16 传感器配置-->
37       <Item ItemID="S7:[S7 connection_2]DB201,INT34" ClientHandle="16" RequestedDataType="2"></Item>
38     </ShearerInfo>
39   </OpcServer>
40 </System>

复制代码

上述配置文件中,OpcServer节点对应的OpcServer对象,定义了ServerName和IPAddress属性,用来连接OPCServer。

ShearerInfo节点则对应一个OpcGroup,在OpcServer下定义多个OPCGrupo节点,OPCGroup节点需要指定组的客户端句柄和刷新频率。上文说到OPC的读写操作都是以组进行的,我们需要根据客户端句柄来判断是哪一个组,如果我们采用的事订阅模式读取数据,则还需要刷新频率,OpcServer对订阅模式的实现不太清楚,实际使用的过程发现,并没有按照刷新频率来,所以我就采用了直接读的方式来保证数据的实时性。

Item的ItemID是一个地址,由于我使用的是西门子的产品,所以格式是:S7:[S7连接名称]地址,我们只需要更改S7连接的名称和地址就好了。如果你使用的事其他类型的PLC,请参照他们的地址格式。

有了配置文件如何操作呢?下面我定义了一个实现类:

 View Code

这个类可以根据自己设计的配置文件进行相应的实现。

复制代码

 1 private OpcManager opcManager;
 2         private System.Timers.Timer opcTimer;
 3         private int[] pErrors;
 4         private Dictionary<int, object> items;
 5         /// <summary>
 6         /// 写入采煤机位置数据
 7         /// </summary>
 8         /// <param name="sender"></param>
 9         /// <param name="e"></param>
10         private void button1_Click(object sender, EventArgs e)
11         {
12             items = new Dictionary<int, object>();
13             items.Add(2, textBox2.Text);
14             opcManager.Write(items, 1, pErrors);
15         }
16 
17         private void FrmMain_Load(object sender, EventArgs e)
18         {
19             opcManager = new OpcManager(AppDomain.CurrentDomain.BaseDirectory+"\\Opc.config.xml");
20             opcManager.OnReadCompleted += new EventHandler<OpcDaCustomAsyncEventArgs>(opcManager_OnReadCompleted);
21 
22             opcTimer = new System.Timers.Timer()
23             {
24                 Interval = 100,
25                 AutoReset = true,
26                 Enabled = true
27             };
28             opcTimer.Elapsed += new ElapsedEventHandler(opcTimer_Elapsed);
29         }
30 
31         void opcTimer_Elapsed(object sender, ElapsedEventArgs e)
32         {
33             opcManager.Read();
34         }
35 
36         void opcManager_OnReadCompleted(object sender, OpcDaCustomAsyncEventArgs e)
37         {
38             Invoke((ThreadStart)(() =>
39             {
40 
41                 if (OpcHelper.ShowValue(e, 3) != null)
42                 {
43                     textBox1.Text = OpcHelper.ShowValue(e, 3).ToString();
44                 }
45             }));
46         }

复制代码

以上实现了数据的读取和写入。

源码戳这里:http://pan.baidu.com/s/1ntp1JAx

  • 2
    点赞
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值