1、 配置opc服务器
对于服务器的配置与同步通讯的配置一样，这里不需再讲解，若有不清楚的，可以参阅之前发布的<运用vc#编程通过opc方式实现pc机与西门子plc通讯>
2、 opc编程
变量组、项的命名规则与同步通讯的一样，这里不再描叙，下面主要就开发一个异步通讯类 asynserver来讲解如何编程。
<1>、引用
在vc#开发环境中添加对opcrcw.da库以及opcrcw.comn库的引用，该库属于.net库，不属于com库，西门子虽然编写了类库，以提供对.net平台的支持，但这些类库仍然难于编程，里面包含了大量的在托管和非托管区传输数据，因此我们需要在它的基础上再开发一个类库，以简化以后的编程，首先在类的开头使用命名空间：
using opcrcw.comn;
using opcrcw.da;
using system.runtime.interopservices;
using system.collections;
<2>、编程
异步编程的原理就是在opc服务器那边检测当前活动的变量组，一但检测到某一个变量，譬如变量q0.0从1变成0，就会执行一个回调函数，以实现针对变量发生变化时需要实现的动作，在这里可以采用委托来实现该功能。
1、 在命名空间的内部、类 asynserver声明之前添加委托的申明：
// 定义用于返回发生变化的项的值和其对应的客户句柄
public delegate void datachange(object[] values,int[] itemsid);
2、 该类继承于西门子提供的库接口iopcdatacallback
public class asynserver:iopcdatacallback
在类的开头部分声明变量：
struct groupstru
{
public int groupid;
public object groupobj;
}
internal const int locale_id = 0x407; //本地语言
private guid iidrequiredinterface;
private string servertype=;
private int hclientgroup = 0; //客户组号
private int nsvrgroupid; // server group handle for the added group
private hashtable hashgroup; //用于把组收集到一起
private int hclientitem=0; //item号
3、编写构造函数，接收委托参数已确定当数据发生变化时需要执行的方法入口点：
//创建服务器
//svrtype 服务器类型的枚举
//datachange 提供用于在数据发生变化时需要执行的函数入口
public asynserver(servertype svrtype,datachange datachange)
{
switch(svrtype)
{
case servertype.opc_simatichmi_ptpr
servertype=opc.simatichmi.ptpro;break;
case servertype.opc_simaticnet:
servertype=opc.simaticnet;break;
case servertype.opc_simaticnet_dp:
servertype=opc.simaticnet.dp;break;
case servertype.opc_simaticnet_pd:
servertype=opc.simaticnet.pd;break;
case servertype.opcserver_wincc:
servertype=opcserver.wincc;break;
}
hashgroup=new hashtable(11);
dtchange=datachange;
}
4、创建服务器
// 创建一个opc server接口
//error 返回错误信息
//若为true，创建成功，否则创建失败
public bool open(out string error)
{
error=;bool success=true;
type svrcomponenttyp ;
//获取 opc server com 接口
iidrequiredinterface = typeof(iopcitemmgt).guid;
svrcomponenttyp = system.type.gettypefromprogid(servertype);
try
{
//创建接口
piopcserver =(iopcserver)system.activator.createinstance(svrcomponenttyp);
error=;
}
catch (system.exception err) //捕捉失败信息
{
error=错误信息:+err.message;success=false;
}
return success;
}
5、 编写添加group的函数
///
/// 添加组
///
///组名
////创建时，组是否被激活
/////组的刷新频率，以ms为单位
///返回错误信息
/// 若为true，添加成功，否则添加失败
public bool addgroup(string groupname,int bactive,int updaterate,out string error)
{
error=;bool success=true;
int dwlcid = 0x407; //本地语言为英语
int prevupdaterate;
float deadband = 0;
// 处理非托管com内存
gchandle hdeadband;
intptr ptimebias = intptr.zero;
hdeadband = gchandle.alloc(deadband,gchandletype.pinned);
try
{
piopcserver.addgroup(groupname, //组名
bactive, //创建时，组是否被激活
updaterate, //组的刷新频率，以ms为单位
hclientgroup, //客户号
ptimebias, //这里不使用
(intptr)hdeadband,
dwlcid, //本地语言
out nsvrgroupid, //移去组时，用到的组id号
out prevupdaterate, //返回组中的变量改变时的最短通知时间间隔
ref iidrequiredinterface,
out pobjgroup1); //指向要求的接口
hclientgroup=hclientgroup+1;
groupstru grp=new groupstru();
grp.groupid=nsvrgroupid;grp.groupobj=pobjgroup1;
this.hashgroup.add(groupname,grp);//储存组信息
// 对异步操作设置回调，初始化接口
piconnectionpointcontainer = (iconnectionpointcontainer)pobjgroup1;
guid iid = typeof(iopcdatacallback).guid;
piconnectionpointcontainer.findconnectionpoint(ref iid,out piconnectionpoint);
piconnectionpoint.advise(this,out dwcookie);
}
catch (system.exception err) //捕捉失败信息
{
error=错误信息:+err.message;success=false;
}
finally
{
if (hdeadband.isallocated) hdeadband.free();
}
return success;
}
6、 编写激活、或者取消激活组的函数
在同步编程中对于组的激活或者取消激活没有实质的意义，但在异步通讯编程中却异常重要，这是因为opc服务器只对当前处于活动状态的组中的变量进行监控，同时这也是很有必要的，因为我们可以把不同界面中的变量编程不同的组，即同一界面中的变量规成一个组，而在某一时刻提供给用户的只有一个界面，让该界面中用到的组处于活动状态，这样执行委托调用时只会执行于该界面中有关的变量检测，而如果让所有的组处于活动状态，则当前没有显示给用户的界面用到的变量若发生变化也会触发对委托函数的调用，这根本是没有必要的，同时会大大降低程序的性能，请严格控制组的激活。
///
/// 激活或者取消激活组
///
///指定组名
///true为激活，false为取消激活
///若有错误，返回错误信息
/// 若为true，添加成功，否则添加失败
public bool acivegroup(string groupname,bool toactive,out string error)
{
error=;bool success=true;
//通过名称获取组
object grp=((groupstru)hashgroup[groupname]).groupobj;
iopcgroupstatemgt groupstatemgt=(iopcgroupstatemgt)grp;
//初始化传递参数
intptr prequestedupdaterate = intptr.zero; //由客户指定的item更新间隔时间
int nrevupdaterate = 0; //由服务器返回的能够更新的最短时间间隔
intptr hclientgroup = intptr.zero; //客户组
intptr ptimebias = intptr.zero;
intptr pdeadband = intptr.zero;
intptr plcid = intptr.zero;
// 激活或者取消激活组
int nactive = 0;
gchandle hactive = gchandle.alloc(nactive,gchandletype.pinned);
if(toactive)
hactive.target = 1;
else
hactive.target = 0;
try
{
groupstatemgt.setstate(prequestedupdaterate,out nrevupdaterate,hactive.addrofpinnedobject(),ptimebias,pdeadband,plcid,hclientgroup);
}
catch(system.exception err)
{
error=错误信息:+err.message;success=false;
}
finally
{
hactive.free();
}
return success;
}
7、 向指定的组中添加变量的函数
///
/// 向指定的组添加一系列项
///
///指定组名
///完整的item名数组
///由服务器返回读写数据时需要使用的item号
/// 无错误，返回true，否则返回false
public bool additems(string groupname,string[] itemsname,int[] itemsid)
{
bool success=true;
opcitemdef[] itemdefarray=new opcitemdef[itemsname.length];
for(int i=0;i {
hclientitem=hclientitem+1; //客户项自动加1
itemdefarray[i].szaccesspath = ; // 可选的通道路径，对于simatiic net不需要。
itemdefarray[i].szitemid = itemsname[i]; // itemid, see above
itemdefarray[i].bactive = 1; // item is active
itemdefarray[i].hclient = hclientitem; // client handle ，在ondatachange中会用到
itemdefarray[i].dwblobsize = 0; // blob size
itemdefarray[i].pblob = intptr.zero; // pointer to blob
itemdefarray[i].vtrequesteddatatype = 4; //dword数据类型
}
//初始化输出参数
intptr presults = intptr.zero;
intptr perrors = intptr.zero;
try
{
// 添加项到组
object grp=((groupstru)hashgroup[groupname]).groupobj;
((iopcitemmgt)grp).additems(itemsname.length,itemdefarray,out presults,out perrors);
int[] errors = new int[itemsname.length];
intptr pos = presults;
marshal.copy(perrors, errors, 0,itemsname.length);
for(int i=0;i {
if (errors[i] == 0)
{
opcitemresult result = (opcitemresult)marshal.ptrtostructure(pos, typeof(opcitemresult));
itemsid[i] = result.hserver;
pos = new intptr(pos.toint32() + marshal.sizeof(typeof(opcitemresult)));
}
else
{
string pstrerror;
piopcserver.geterrorstring(errors[0],0x407,out pstrerror);
success=false;
break;
}
}
setitenclient(groupname,itemsid,itemsid); //要求始终只有一个组被激活，才不会引起冲突。
}
catch (system.exception err) // catch for error in adding items.
{
success=false;
//error=错误信息:+error+err.message;
}
finally
{
// 释放非托管内存
if(presults != intptr.zero)
{
marshal.freecotaskmem(presults);
presults = intptr.zero;
}
if(perrors != intptr.zero)
{
marshal.freecotaskmem(perrors);
perrors = intptr.zero;
}
}
return success;
}
#p#分页标题#e#
说明：使用该函数时，在类的开头，应该先声明整数数据，以用于保存由本函数返回的服务器对每一项分配的item id号：
8、 下面编写的是一个最重要的重载函数，当检测到当前活动组中的某个变量发生变化时，就会调用委托。
//数据变化时处理的问题
public virtual void ondatachange ( int32 dwtransid ,
int32 hgroup ,
int32 hrmasterquality ,
int32 hrmastererror ,
int32 dwcount ,
int[] phclientitems ,
object[] pvvalues ,
short[] pwqualities ,
opcrcw.da.filetime[] pfttimestamps ,
int[] perrors )
{
dtchange(pvvalues,phclientitems);
}
该函数的代码只有一句，即调用委托函数。
以上编写的是需要实现监控的最重要的方法，当然不完善，还有许多方法和重载函数可以编写，这里就不详细介绍。
9、 编写基本的测试程序，用于检测上面编写的异步类asynserver
<1>、 重新创建一个工程，添加对上面编写的异步类的引用，并在类的开头部分添加变量声明：
//声明委托
private s7connection.datachange dt;
//声明服务器
s7connection.asynserver server;
<2>、初始化服务器数据
dt=new s7connection.datachange(datachange);
server =new asynserver(s7connection.servertype.opc_simaticnet,dt);
string err;
server.open(out err);
server.addgroup(maiker,1,300,out err);
server.additems(maiker,m1,nt1);
server.addgroup(maiker1,1,300,out err);
server.additems(maiker1,m2,nt2);
nt[0]=nt1[0];nt[1]=nt1[1];
<3>、添加两个单选按钮，用于选择某个组，并编写相应的程序
string err,err1;
if(server==null) return;
if(radiobutton1.checked)
{ nt[0]=nt1[0];nt[1]=nt1[1];
server.acivegroup(maiker,true,out err);
server.acivegroup(maiker1,false,out err1);
}
else
{
nt[0]=nt2[0];nt[1]=nt2[1];
server.acivegroup(maiker1,true,out err);
server.acivegroup(maiker,false,out err1);
}
<4>、添加文本框、按钮等，并编写委托执行函数：
private void datachange(object[] obj,int[] itemsid)
{
for(int j=0;j {
if(itemsid[j]==nt[0])
this.textbox1.text=obj[j].tostring();
if(itemsid[j]==nt[1])
this.textbox4.text=obj[j].tostring();
}
}
其中参数obj用于返回当前发生变化的变量的结果值，而itemsid返回当前发生变化的变量的id号，其与添加变量时服务器返回的id号对应。以上就是一个基本的测试函数，其相对同步编程来说，应该还简单一些。
3、 同步编程与异步编程的使用场合
一般来讲，同步编程需要使用定时器来循环检测变量，而异步编程则不需要，当服务器检测到数据发生变化时，可以直接调用传入的函数，从这方面来讲，使用异步编程更简单一些，但同步编程使用外部的定时器控制，编程则会更加灵活，一般只监控变量时可以使用异步编程，而当需要写入数据时可以使用同步编程，但这也不是绝对的，我曾编写了一个标准监控程序，没有使用异步编程。
4、 关于开发监控界面的说明
毫无疑问，我们应该开发一系列控件，用于简化界面的设计，否则工作量会异常大。设计一个标准模块，用于第一次运行监控软件时添加变量，并可以设定当前已经组态的界面中的各控件元素与之关联，这样在以后再运行该软件时，不需要再设定，就可以直接连接变量，并进行相应的变化。否则若在编程时编写代码进行关联，其工作量将会异常大。