Recently we got increasing interest in providing sample code in C++.

 

While C++ is a very powerful language you should be aware that .NET provides you with many little things that make your life as a developer much easier.

 

In the following post I will create a simple command line application that gets the snapshot of tags. The usage is:

 

PISDK_GetSnapshot <SERVERNAME> <Tagname1> <Tagname2> <…>

 

So as you may guess, we start with an empty C++ command line project:

 

2262.image001.png

 

Now let’s go to the code. First some includes:

 

#include "stdafx.h"
#include
<iostream>
#include
<string>
#include
"ATLComTime.h" // for COleDateTime

Then we import the PI SDK libraries.

 

//need to import sdk
#import
"E:\PIPC\PISDK\PISDKCommon.dll"    no_namespace
#import
"E:\PIPC\LIBRARY\PITimeServer.dll" no_namespace
#import "E:\PIPC\PISDK\PISDK.dll"          rename("Connected", "PISDKConnected") no_namespace

One of the things that constantly drives me crazy when switching between C++ and C#.NET is handling the PIValue, especially the variant PIValue->Value – so the very first thing I’d like to do is introducing a simple class that does this for me:

 

class MyPIValue
{
      
_PIValuePtr spPIValue;

public
:
      
MyPIValue (_PIValuePtr);
      
double  dblValue;
      
int     intValue;
      
_bstr_t bstrValue;
      
_bstr_t bstrTimeStamp;
      
COleDateTime codtTimeStamp;
      
VARTYPE vt;
};

The purpose of my simple class is to get variables that handle much better than the variant (at least in my simple sample code snippets).

 

Now let’s go to the constructor. Actually we need to figure where to find the data – and that is derived by the variant type. The following code gets me first a COleDateTime and a string representation of that – this is the timestamp, and later the value part as integer, double or string representation:

 

MyPIValue::MyPIValue (_PIValuePtr pv) {
      
codtTimeStamp = pv->TimeStamp->LocalDate;
      
bstrTimeStamp = (_bstr_t)codtTimeStamp.Format(_T("%d-%b-%Y %H:%M:%S"));
      
DigitalStatePtr tmpDigitalState = NULL;
      
IDispatchPtr    tmpDispatch = NULL;
      
_PITimePtr      tmpPITime = NULL;
      
COleDateTime    tmpTS;
      
HRESULT         hr = E_FAIL;

      
_variant_t vT = pv->Value;
      
vt = vT.vt;

      
switch (vT.vt) {
      
case VT_I4:
             
// Int32
             
intValue = vT.lVal;
             
dblValue = intValue;
             
bstrValue = (_bstr_t)intValue;
             
break;
      
case VT_I2:
             
// Int16
             
intValue = vT.iVal;
             
dblValue = intValue;
             
bstrValue = (_bstr_t)intValue;
             
break;
      
case VT_R8:
             
// Float64
             
dblValue = vT.dblVal;
             
intValue = (int)dblValue;
             
bstrValue = (_bstr_t)dblValue;
             
break;
      
case VT_R4:
             
// Float16/Float32
             
dblValue = vT.fltVal;
             
intValue = (int)dblValue;
             
bstrValue = (_bstr_t)dblValue;
             
break;
      
case VT_BSTR:
             
// String
             
bstrValue = vT.bstrVal;
             
dblValue = 0;
             
intValue = 0;
             
break;
      
case VT_DISPATCH:
             
// Digital?
             
tmpDispatch = vT.pdispVal;
             
hr =  tmpDispatch.QueryInterface(__uuidof(DigitalState),&tmpDigitalState);
             
if (hr == S_OK) {
                    
bstrValue = tmpDigitalState->Name;
                    
intValue = tmpDigitalState->Code;
                    
dblValue = intValue;
             
}
             
// Timestamp?
             
hr =  tmpDispatch.QueryInterface(__uuidof(_PITime),&tmpPITime);
             
if (hr == S_OK) {
                          
tmpTS = tmpPITime->LocalDate;
                          
bstrValue = (_bstr_t)tmpTS.Format(_T("%d %B %Y %H:%M:%S"));
                          
intValue = 0;
                          
dblValue = 0;
             
}
             
break;
      
default :
             
dblValue = 0.0;
             
intValue = 0;
             
bstrValue = "n/a";
             
break;
      
}

};

Preparation doneJ!

 

As mentioned in the beginning, I want to get the snapshot – so what do I need? The PISDK, the Server, the Point, the Value and just for the fun the PISDK Version J:

 

IPISDKPtr       spPISDK = NULL;            /* The PISDK */
PISDKVersionPtr spSDKVersion = NULL;       /* PI SDK Version */

ServerPtr       spServer = NULL;           /* The Server */
PIPointPtr      spPIPoint = NULL;          /* The PI Point */
_PIValuePtr     spPIValue = NULL;          /* The PI value */

Now the code – we initialize COM, check for the command line parameters and finally create the PISDK. After this has been done, we print out the PI SDK version, connect to PI and print out the snapshot of all tags provided as command line arguments:

 

int _tmain(int argc, _TCHAR* argv[])
{
      
// Initialize COM
      
::CoInitializeEx(NULL,COINIT_APARTMENTTHREADED);
      
// Check the command line switches
      
if (argc < 3) {
             
std::cout << "Command Line:" << std::endl
                     
  << (_bstr_t)argv[0] << " SERVERNAME TAGNAME(s)";
             
return (1);
      
}
      
try                                   
      
{
             
// Create an instance of the PI SDK
             
spPISDK.CreateInstance(__uuidof(PISDK));
             
// Print out the PI SDK version
             
spSDKVersion = spPISDK->PISDKVersion;
             
std::cout << std::endl << "PI-SDK Version "
                     
  << spSDKVersion->Version << " Build "
                     
  << spSDKVersion->BuildID << std::endl;
             
// get the PI Server
             
spServer = spPISDK->GetServers()->GetItem((_bstr_t)argv[1]);
             
// You can use more than just one tagname
             
for (int ii = 2; ii< argc; ii++) {
                    
// Tagname
                    
std::cout << (_bstr_t)argv[ii] << std::endl;
                    
spPIPoint = spServer->PIPoints->GetItem((_bstr_t)argv[ii]);
                    
// Snapshot
                    
spPIValue = spPIPoint->Data->Snapshot;
                    
MyPIValue mPV(spPIValue);
                    
std::cout << mPV.bstrTimeStamp << " ";
                    
std::cout << mPV.bstrValue << std::endl;
             
}
      
}
      
catch( _com_error Err )
      
{
             
std::cout << "Error: "
                        << Err.Description()
                        << " : "
                        << Err.Error()
                        << std::endl;
             
return (1);
      
}
      
return 0;

}

And here is the result:

 

4572.image002.png

 

This was the first post - stay tuned for more examples using C++!