mexopc.cpp

一个opc服务器

         
         IConnectionPoint *pCallbackCP = 0;
         hr = pCPC->FindConnectionPoint(IID_IOPCShutdown, &pCallbackCP);
         pCPC->Release();
         if( SUCCEEDED(hr) )
         {
            hr = pCallbackCP->Advise(pDoc->shutdownCP, &pDoc->dwShutdownConnection);
            pCallbackCP->Release();
         }
      }
	}

   // Create a single group that will contain all the items
      FLOAT deadband = 0.0;
      DWORD rate;
      hr = pDoc->opcServer.AddGroup( L"Fred", TRUE, m_synctime,  // name, active, rate
                             1324, NULL, &deadband,  // handle, bias, band
                             0, &pDoc->groupHandle, &rate,
                             IID_IOPCGroupStateMgt,   // interface to return
                             pDoc->opcGroup );              // this holds the group ptr
   
      if( FAILED(hr) )
	  {
		  pDoc->ReportError( _T("AddGroup:%s "), hr);
		   z[0] = 2789561;
		   init =0;
          return ;
	  }

   // Test GetGroupByName and SetName
#ifdef FULL_TEST
      IOPCGroupStateMgt* pTest=NULL;
      hr = pDoc->opcServer.GetGroupByName( L"Fred", IID_IOPCGroupStateMgt, (LPUNKNOWN*)&pTest );
      if( SUCCEEDED(hr) )
	  {
         ASSERT( pTest == (IOPCGroupStateMgt*)opcGroup );   // should get the same
         hr = pTest->SetName( L"Group one" );               // set new name
         pTest->Release();
         if( FAILED(hr) )
		 {
            pDoc->ReportError( _T("IOPCGroupStateMgt::SetName:%s "), pErrors[0] );
		 }
         else
		 {
         // should now go by this new name
            hr = pDoc->opcServer.GetGroupByName( L"Group one", IID_IOPCGroupStateMgt, (LPUNKNOWN*)&pTest );
            if( SUCCEEDED(hr) )
			{
              ASSERT( pTest == (IOPCGroupStateMgt*)opcGroup );
              pTest->Release();
			}
		 }
	  }
#endif // FULL_TEST

   // OPC 2.0 ConnectionPoints
      IConnectionPointContainer *pCPC = 0;
      hr = pDoc->opcGroup.QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC);
      if( SUCCEEDED(hr) )  // This server supports 2.0
	  {
	  
          pDoc->usingCP = TRUE;
          IConnectionPoint *pCallbackCP = 0;
          hr = pCPC->FindConnectionPoint(IID_IOPCDataCallback, &pCallbackCP);
          pCPC->Release();
          if( FAILED(hr) )
		  {
              pDoc->ReportError( _T("FindConnectionPoint:%s "), hr);
              pDoc->usingCP = FALSE;  // Try old style
		  }

          hr = pCallbackCP->Advise(pDoc->callbackCP, &pDoc->dwConnection1);
          pCallbackCP->Release();
          if( FAILED(hr) )
		  {
             pDoc->ReportError( _T("Advise ConnectionPoint:%s "), hr );
             pDoc->dwConnection1 = 0;
             pDoc->usingCP = FALSE;  // Try old style
		  }
	  }
      if( !pDoc->usingCP )
	  {
      // OPC 1.0 data advise format
          FORMATETC formatEtc ;
          formatEtc.tymed =  TYMED_HGLOBAL;
          formatEtc.ptd = NULL;
          formatEtc.dwAspect = DVASPECT_CONTENT;
          formatEtc.lindex = -1;

      // IAdviseSink is an interface on OUR object that is passed to
      // the server for callbacks
          IAdviseSink *pAdviseSink = NULL;
          hr = pDoc->testSink->QueryInterface(IID_IAdviseSink, (LPVOID *)&pAdviseSink);
          if( FAILED(hr) )
		  {
           pDoc->ReportError( _T("IAdviseSink:%s "), hr);
           pDoc->opcGroup.Detach();
           pDoc->opcServer.Detach();
		    z[0] = 2789561;
			init =0;
           return ;
		  }

      // Get an IDataObject interface on the group
          DataObject dataObject;
          hr = dataObject.Attach( pDoc->opcGroup );
          if(FAILED(hr) || !dataObject.IsOk() )
		  {
         //  some servers don't do this, so don't quit altogether
            MessageBox( 0, _T("IDataObject not supported by this server\nNo data notifications will take place"), _T("FactorySoft Client"), MB_OK );
             z[0] = 2789561;
			return ;
		  }

      // Register our IAdvise with the group
      // Need to register both formats: data change, and write complete
         formatEtc.cfFormat = OPCSTMFORMATWRITECOMPLETE ;
         hr = dataObject.DAdvise(&formatEtc,
                                ADVF_PRIMEFIRST,    // ADVF flag
                                pAdviseSink,
                                &pDoc->dwConnection2);
	  
         if( FAILED(hr) )
		 {
			pDoc->ReportError( _T("IDataObject::DAdvise:%s "), hr );
			 z[0] = 2789561;
			 init =0;
            return ;
		 }

#ifdef DATATIMEFORMAT
         formatEtc.cfFormat = OPCSTMFORMATDATATIME ;
#else
         formatEtc.cfFormat = OPCSTMFORMATDATA ;
#endif // DATATIMEFORMAT
         hr = dataObject.DAdvise(&formatEtc,
                                ADVF_PRIMEFIRST,    // ADVF flag
                                pAdviseSink,
                                &pDoc->dwConnection1);
         pAdviseSink->Release();
         if( FAILED(hr) )
		 {
         pDoc->ReportError( _T("IDataObject::DAdvise:%s "), hr );
		  z[0] = 2789561;
		  init =0;
         return ;
		 }
	  }
     }       
//**************************************注册函数************************************************	
//************************WRITE写函数************************************************************      
	
//**************************************关闭函数************************************************      
	if(para.Compare( "close" ) == 0||para.Compare( "Close" ) == 0||para.Compare( "CLOSE" ) == 0)
    {
		HRESULT hr = S_OK;
        if( pDoc->opcServer.IsOk() && pDoc->opcGroup.IsOk() )
		{
            if( pDoc->dwShutdownConnection )
			{
               IConnectionPointContainer *pCPC = 0;
               hr = pDoc->opcServer.QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC);
               if( SUCCEEDED(hr) )
			   {
                   IConnectionPoint *pCallbackCP = 0;
                   hr = pCPC->FindConnectionPoint(IID_IOPCShutdown, &pCallbackCP);
                   if( SUCCEEDED(hr) )
				   {
                       hr = pCallbackCP->Unadvise(pDoc->dwShutdownConnection);
                       pCallbackCP->Release();
				   }
                pCPC->Release();
			   } 
			}
            if( pDoc->usingCP )
			{
         // OPC 2.0 ConnectionPoints
            IConnectionPointContainer *pCPC = 0;
            hr = pDoc->opcGroup.QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC);
            if( SUCCEEDED(hr) && pDoc->dwConnection1 )  // This server supports 2.0
			{
            IConnectionPoint *pCallbackCP = 0;
            hr = pCPC->FindConnectionPoint(IID_IOPCDataCallback, &pCallbackCP);
            if( SUCCEEDED(hr) )
            {
               hr = pCallbackCP->Unadvise(pDoc->dwConnection1);
               pCallbackCP->Release();
            }
            pCPC->Release();
			}
			}
            else
      // call IDataObject::DUnadvise to turn off data notification
			{
          DataObject dataObject;
          HRESULT hr = dataObject.Attach( pDoc->opcGroup );
          if( SUCCEEDED(hr) )
          {
             if( pDoc->dwConnection1 )
                hr = dataObject.DUnadvise(pDoc->dwConnection1);
             if( pDoc->dwConnection2 )
                hr = dataObject.DUnadvise(pDoc->dwConnection2);
             dataObject.Detach();
          }
			}
       // test RemoveItems (RemoveGroup cleans up anyway.)
#ifdef FULL_TEST
       
       hr = itemMgt.Attach( opcGroup );
       if( SUCCEEDED(hr) && items.GetCount()>0 )
       {
          HRESULT *pErrors=0;
          OPCHANDLE* handles = new OPCHANDLE[items.GetCount()];
          POSITION pos = items.GetHeadPosition();
          for( int index=0; pos; index++ )
          {
             Item* pItem = items.GetNext( pos );
             handles[index] = pItem->hServerHandle;
          }
          hr = itemMgt.RemoveItems( items.GetCount(), handles, &pErrors );
          if( SUCCEEDED(hr) )
             CoTaskMemFree( pErrors );
          delete [] handles;
       }
#endif // FULL_TEST

       pDoc->opcServer.RemoveGroup(pDoc->groupHandle, FALSE);

   }
       pDoc->opcGroup.Detach();
       pDoc->opcServer.Detach();
   // now that the group is released and unadvised, no more data will
   // be sent from the server. It is safe to delete the items
   while( !pDoc->items.IsEmpty() )
      delete pDoc->items.RemoveTail();
   pDoc->pCurrentItem = NULL;
    init =0;
	}
	//***********************wait***********************************
	    if(para.Compare( "wait" ) == 0)
		{
           
           lock.Lock(m_synctime);
		   if (lock.IsLocked())  
		   lock.Unlock();
	       event->ResetEvent();
		}
   
    z[0]=0;
//************************************************************************************
}
void mexFunction( int nlhs,mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
		//*****************************************//参数的初始化
	CString para=("");
	CString NAME=("");
	CString data=("");
    //************************************//输入，输出矩阵
	input = mxCreateDoubleMatrix(10,1,mxREAL);
	
	//*******************************************//三个输入参数的转化
	int n,n1;
	char *input_buf;
	char *input_buf2;
	char *input_buf3;
	int buflen,status,buflen1,status1,buflen2,status2;
	buflen1 = (mxGetM(prhs[0])*mxGetN(prhs[0]))+1;
    input_buf2 = (char*)mxCalloc(buflen1,sizeof(char));
	sleeptime = mxCreateDoubleMatrix(1,1,mxREAL);
	status1 = mxGetString(prhs[0],input_buf2,buflen1);
	for (int  i = 0 ;i<buflen1-1;i++)
	{
		n1 = para.Insert(i,input_buf2[i]);
        ASSERT(n1 == para.GetLength());
    }
	
	//**************************************///调用动态函数
	if(!init)
           if(para.Compare("Open")==0||para.Compare("open")==0||para.Compare("PARA")==0)
			      init=1;
	       else
		   {
					  AfxMessageBox("请先连接服务器");
					  plhs[0] =mxCreateDoubleMatrix(1,1,mxREAL);
	                  double *z;
	                  z =mxGetPr(plhs[0]);
					  z[0] = 2789561;
					  return;
			}
           if(para.Compare("directread")==0||para.Compare("Directread")==0||para.Compare("DirectRead")==0||para.Compare("DIAECTREAD")==0
		      ||para.Compare("write")==0||para.Compare("Write")==0||para.Compare("WRITE")==0
		      ||para.Compare("read")==0||para.Compare("Read")==0||para.Compare("READ")==0
			  ||para.Compare("directwrite")==0||para.Compare("DirectWrite")==0||para.Compare("DIRECTWRITE")==0)
			{
		      buflen = (mxGetM(prhs[1])*mxGetN(prhs[1]))+1;
	          input_buf = (char*)mxCalloc(buflen,sizeof(char));
	          status = mxGetString(prhs[1],input_buf,buflen);
	          plhs[0] = mxCreateDoubleMatrix(100,1,mxREAL);
	          buflen2 = (mxGetM(prhs[2])*mxGetN(prhs[2]))+1;
              input_buf3 = (char*)mxCalloc(buflen2,sizeof(char));
	          status2 = mxGetString(prhs[2],input_buf3,buflen2);
	          for( i=0;i<buflen-1;i++)
			  {
	              n = NAME.Insert(i, input_buf[i]);
                  ASSERT(n == NAME.GetLength());
			  }
	          for( i=0;i<buflen2-1;i++)
			  {
	              n = data.Insert(i, input_buf3[i]);
                 ASSERT(n == data.GetLength());
			  }
		      if(para=="write"||para =="Write"||para =="WRITE"||para.Compare("directwrite")==0||para.Compare("DirectWrite")==0||para.Compare("DIRECTWRITE")==0)
			  {
		         inth =mxCreateDoubleMatrix(1,1,mxREAL);
		         inth =prhs[2];
			  }
		      if(data=="CString"||data=="cstring"||data=="CSTRING")
			  {
			     plhs[0]=mxCreateString(input_buf4);
	             double *z;
	             z =mxGetPr(plhs[0]);
                 gill(para,NAME,data,z);//这里可以改进，我想，也可以不改进    
			  }
		     else
			 {
	             plhs[0] =mxCreateDoubleMatrix(1,1,mxREAL);
	             double *z;
	             z = mxGetPr(plhs[0]);
	             gill(para,NAME,data,z);
			 }
			  }
	        else
			{
				/*if(para.Compare("wait")==0||para.Compare("sleep")==0)
				{
					 buflen = (mxGetM(prhs[1])*mxGetN(prhs[1]))+1;
	                 input_buf = (char*)mxCalloc(buflen,sizeof(char));
	                 status = mxGetString(prhs[1],input_buf,buflen);
					 for( i=0;i<buflen-1;i++)
					 {
	                     n = NAME.Insert(i, input_buf[i]);
                         ASSERT(n == NAME.GetLength());
					 }
                     inth =mxCreateDoubleMatrix(1,1,mxREAL);
		             inth =prhs[2];
					 plhs[0] =mxCreateDoubleMatrix(1,1,mxREAL);
				     double *z;
				     z = mxGetPr(plhs[0]);
					 dill(para,NAME,z);
				}
				else
				{*/
				plhs[0] =mxCreateDoubleMatrix(1,1,mxREAL);
				double *z;
				z = mxGetPr(plhs[0]);
                fill(para,z);
				//}
			}  
}