opctest.cpp

工业标准通讯OPC协议的客户端测试源代码

			break;
		case '4':
			printf("This test not yet implemented\n");
			break;
		case '5':
			if( pGRP1GSM ) TryDataObject(pGRP1GSM, 2, g_sh);
//			if( pGRP1DO ) TryDO( pGRP1DO );
			break;
		case '6':
			if( pGRP1GSM ) TryConnectionPoint(pGRP1GSM, 2, g_sh);	// Try ConnectionPoint for 1st group V2.0
//			if( pGRP1CPC ) TryCPC( pGRP1CPC );
			break;
		case 'x':
			loop = 0;
			break;
		}
	}
	printf("IOPCGroup test complete\n");
}

//---------------------------------------------------------
// TryRemoveGroup
// Note - this can sometimes cause crash of the Inproc sample server
// because that server is not currently threadsafe
//
void TryRemoveGroup(IOPCServer * pOPC)
{
	HRESULT r1;
	// When done
	// Release the Group interface 
	// and remove the group from the server
	// (Which should take care of deleting any items)
	//
	if(!pGRP1U)
	{
		printf("Add needs to be done first\n");
		return;
	}

	if(pGRP1GSM) pGRP1GSM->Release();
	if(pGRP1PGSM) pGRP1PGSM->Release();
	if(pGRP1SIO) pGRP1SIO->Release();
	if(pGRP1ASIO) pGRP1ASIO->Release();
	if(pGRP1ASIO2) pGRP1ASIO2->Release();
	if(pGRP1IM) pGRP1IM->Release();
	if(pGRP1DO) pGRP1DO->Release();
	if(pGRP1CPC) pGRP1CPC->Release();

	pGRP1GSM = 0;
	pGRP1PGSM = 0;
	pGRP1SIO = 0;
	pGRP1ASIO = 0;
	pGRP1ASIO2 = 0;
	pGRP1IM = 0;
	pGRP1DO = 0;
	pGRP1CPC = 0;

	if(pGRP1U)
	{
		pGRP1U->Release();
		r1 = pOPC->RemoveGroup(hServerGroup1, FALSE);
		if (FAILED(r1))
		{
			printf("Error from RemoveGroup (TestGroup1) (%lx)\n", r1);
		} else printf("Group 1 removed\n"); 
		pGRP1U = 0;
	}
	if(pGRP2)
	{
		pGRP2->Release();
		r1 = pOPC->RemoveGroup(hServerGroup2, FALSE);
		if (FAILED(r1))
		{
			printf("Error from RemoveGroup (TestGroup2) (%lx)\n", r1);
		} else printf("Group 2 (empty) removed\n"); 
		pGRP2 = 0;
	}

	if(bGroup3)
	{
		r1 = pOPC->RemoveGroup(hServerGroup3, FALSE);	// the 'cloned' group
		if (FAILED(r1))
		{
			printf("Error from RemoveGroup (TestGroup3 - the cloned group) (%lx)\n", r1);
		} else printf("Group 3 (clone) removed\n"); 
		bGroup3 = 0;
	}


	add_done = 0;	// clear the 'items added' flag.
	printf("Remove Groups test complete\n");
}



//---------------------------------------------------------
// TryEnumUnknown1
// 
void TryEnumUnknown1(IOPCServer * pOPC)
{
	HRESULT r1;
	IEnumUnknown * pEnum;

	r1 = pOPC->CreateGroupEnumerator(OPC_ENUM_ALL, IID_IEnumUnknown, (IUnknown**)&pEnum);
	if (FAILED(r1))
	{
		printf("Error from CreateGroupEnumerator for EnumUnknown (%lx)\n", r1);
	} 
	else
	{
		HRESULT r2 = S_OK;
		IUnknown *pUnk;
		IOPCGroupStateMgt * pGRP;
		ULONG actual;

		printf("Got an IEnumUnknown from CreateGroupEnumerator()...\n");

		while((r2 = pEnum->Next(1, &pUnk, &actual)) == S_OK)
		{
			HRESULT r3;

			r3 = pUnk->QueryInterface(IID_IOPCGroupStateMgt, (void**)&pGRP);
			
			if (FAILED(r3))
			{
				printf("Error from QI after Next(%lx)\n", r3);
			}
			else
			{
				TryGetGroupState(pGRP);
				pGRP->Release();
			}

			pUnk->Release();
		}
		if (FAILED(r2))
		{
			printf("Error from Next(%lx)\n", r2);
		}

		// Release the interface
		//
		pEnum->Release();
	}
}



//---------------------------------------------------------
// TryEnumString
// 
void TryEnumString(IOPCServer * pOPC)
{
	HRESULT r1;
	IEnumString * pEnum;

	r1 = pOPC->CreateGroupEnumerator(OPC_ENUM_ALL, IID_IEnumString, (IUnknown **)&pEnum);
	if (FAILED(r1))
	{
		printf("Error from CreateGroupEnumerator for EnumString (%lx)\n", r1);
	} 
	else
	{
		HRESULT r2 = S_OK;
		LPOLESTR pStr;
		ULONG actual;

		printf("Got an IEnumString...\n");

		while((r2 = pEnum->Next(1, &pStr, &actual)) == S_OK)
		{
			printf("EnumString returns: %ls\n", pStr);

			// Free the string(s) that Next Returned
			//
			pIMalloc->Free(pStr);
		}
		if (FAILED(r2))
		{
			printf("Error from Next(%lx)\n", r2);
		}
		
		// Release the interface
		//
		pEnum->Release();
	}
}


//---------------------------------------------------------
// TryItemReadWrite
// 
void TryItemReadWrite(IOPCSyncIO *pSIO, int nItem, OPCHANDLE *sh)
{
	HRESULT	r1;
	HRESULT *hr;
	VARIANT	v[2];
	OPCITEMSTATE *is;
	char buffer[40];

	if(!add_done)
	{
		printf("Must do Add first\n");
		return;
	}

	// try to write and then read each item
	//

	v[0].vt = VT_R8;
	v[0].dblVal = 1.11;
	v[1].vt = VT_R8;
	v[1].dblVal = 2.22;

	printf("Do you want to try ItemWrite[y/n]\n");
	switch(*gets(buffer))
	{
	case 'y':
	case 'Y':
		printf("We will write VT_R8 / 1.11 and 2.22 to the 2 items\n");
		r1 = pSIO->Write(2, sh, v, &hr);
		if (FAILED(r1))
		{
			printf("Error from Write(%lx)\n", r1);
		} else
		{
			printf("HResult[0] = %lx)\n", hr[0]);
			printf("HResult[1] = %lx)\n", hr[1]);
			pIMalloc->Free(hr);		//acc001
		}
		break;
	}
	

	printf("Read from CACHE:\n");
	r1 = pSIO->Read(OPC_DS_CACHE, 2, sh, &is, &hr);
	if (FAILED(r1))
	{
		printf("Error from Read(%lx)\n", r1);
	} 
	else
	{
		// if the read worked then show the results
		// (Which are assumed to be VT_R4 for now!)
		//

		printf("Read[0] hr=%lx, Quality = %2x Value=", hr[0], is[0].wQuality); //zzz add DumpQuality()
		if(!FAILED(hr[0])) DumpVariant(&is[0].vDataValue);
		printf("\n");

		printf("Read[1] hr=%lx, Quality = %2x Value=", hr[1], is[1].wQuality);
		if(!FAILED(hr[1])) DumpVariant(&is[1].vDataValue);
		printf("\n");

		// Free returned items
		//
		pIMalloc->Free(hr);
		VariantClear(&is[0].vDataValue);	//acc0997
		VariantClear(&is[1].vDataValue);
		pIMalloc->Free(is);
	}


	printf("Read from DEVICE:\n");
	r1 = pSIO->Read(OPC_DS_DEVICE, 2, sh, &is, &hr);
	if (FAILED(r1))
	{
		printf("Error from Read(%lx)\n", r1);
	} 
	else
	{
		// if the read worked then show the results
		// (Which are assumed to be VT_R4 for now!)
		//

		printf("Read[0] hr=%lx, Quality = %2x Value=", hr[0], is[0].wQuality); //zzz add DumpQuality()
		if(!FAILED(hr[0])) DumpVariant(&is[0].vDataValue);
		printf("\n");

		printf("Read[1] hr=%lx, Quality = %2x Value=", hr[1], is[1].wQuality);
		if(!FAILED(hr[1])) DumpVariant(&is[1].vDataValue);
		printf("\n");

		// Free returned items
		//
		pIMalloc->Free(hr);
		VariantClear(&is[0].vDataValue);	//acc0997
		VariantClear(&is[1].vDataValue);
		pIMalloc->Free(is);
	}
}


//---------------------------------------------------------
// TryEnumItemAttributes
// 
void TryEnumItemAttributes(IOPCItemMgt * pOPC)
{
	HRESULT r1;
	IEnumOPCItemAttributes * pEnum;

	r1 = pOPC->CreateEnumerator(IID_IEnumOPCItemAttributes, (IUnknown **)&pEnum);
	if (FAILED(r1))
	{
		printf("Error from CreateEnumerator for EnumItemAttributes (%lx)\n", r1);
	} 
	else
	{
		HRESULT r2 = S_OK;
		OPCITEMATTRIBUTES *pIA;
		ULONG actual;

		printf("Got an IEnumItemAttr...\n");

		while((r2 = pEnum->Next(1, &pIA, &actual)) == S_OK)
		{
			printf("EnumItemAttr returns ItemID:%ls, hServer=%d hClient=%d\n", 
				pIA->szItemID, 
				pIA->hServer, 
				pIA->hClient);
			// zzz later print out other stuff...

			// Free all the stuff inside the ITEMATTR
			// that Next Returned
			//
			if(pIA->szAccessPath) pIMalloc->Free(pIA->szAccessPath);
			if(pIA->szItemID) pIMalloc->Free(pIA->szItemID);
			if(pIA->pBlob) pIMalloc->Free(pIA->pBlob);
			VariantClear(&pIA->vEUInfo);

			// And finally, free the ITEMATTR itself
			//
			pIMalloc->Free(pIA);
			
		}
		if (FAILED(r2))
		{
			printf("Error from Next(%lx)\n", r2);
		}
 
		// Release the enumerator
		//
		pEnum->Release();
	}
}



//---------------------------------------------------------
// TryPersistFile
// Use the OPCServer to perform some functions just to insure
// that the interface pointer really works.
//
void TryPersistFile(IPersistFile* pOPC)
{
	HRESULT r4;
	CLSID	cls;

	// Request an IPersistFile interface from the object.
	//
	
	// Try out a couple of methods on the interface
	//
	r4 = pOPC->GetClassID(&cls);
	if (FAILED(r4))
	{
		printf("Error from GetClassID (%lx)\n", r4);
	} else
	{
		printf("GetClassID worked\n");
	}
	printf("IPersistFile test complete\n\n");
}



//---------------------------------------------------------
// LocalCleanup
// This is generic cleanup for any task using COM.
void LocalCleanup(void)
{
	// Finally, release the memory manager
	// as well as COM
	//
	pIMalloc->Release();
	CoUninitialize();
}



//---------------------------------------------------------
// DumpVariant
// This shows the value of a Variant
void	DumpVariant(VARIANT *v)
{
	switch(v->vt)
	{
	case VT_I2:
		printf(" value(VT_I2)   = %d ", v->iVal );
		break;
	case VT_I4:
		printf(" value(VT_I4)   = %ld ", v->lVal );
		break;
	case VT_R4:
		printf(" value(VT_R4)   = %5.2f ", v->fltVal );
		break;
	case VT_R8:
		printf(" value(VT_R8)   = %9.4f ", v->dblVal );
		break;
	case VT_BSTR:
		printf(" value(VT_BSTR) = %ls ", v->bstrVal );
		break;
	default:
		printf(" value(unknown type:%d) ", v->vt );
		break;
	}
}