epics/pvAccess
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

starting work on pvaget

Browse Source
This commit is contained in:
Matej Sekoranja
2011-05-25 09:58:29 +02:00
parent 5c31e553a0
commit 859da06a50
2 changed files with 532 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
testApp/remote/Makefile
View File

@@ -42,6 +42,10 @@ PROD_HOST += testServer
testServer_SRCS += testServer.cpp
testServer_LIBS += pvData pvAccess Com
PROD_HOST += pvaget
pvaget_SRCS += pvaget.cpp
pvaget_LIBS += pvData pvAccess Com
include $(TOP)/configure/RULES
#----------------------------------------
# ADD RULES AFTER THIS LINE

528
testApp/remote/pvaget.cpp Normal file
View File

@@ -0,0 +1,528 @@
#include <iostream>
#include <clientFactory.h>
#include <stdio.h>
#include <epicsStdlib.h>
#include <epicsGetopt.h>
#include <vector>
#include <string>
using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel);
void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel);
void convertStructureArray(StringBuilder buffer,PVStructureArray * pvdata,int indentLevel);
void convertToString(StringBuilder buffer,PVField * pv,int indentLevel)
{
Type type = pv->getField()->getType();
if(type==structure) {
convertStructure(buffer,static_cast<PVStructure*>(pv),indentLevel);
return;
}
*buffer += "\t";
if(type==scalarArray) {
convertArray(buffer,static_cast<PVScalarArray *>(pv),indentLevel);
return;
}
if(type==structureArray) {
convertStructureArray(
buffer,static_cast<PVStructureArray*>(pv),indentLevel);
return;
}
PVScalar *pvScalar = static_cast<PVScalar*>(pv);
ScalarConstPtr pscalar = pvScalar->getScalar();
ScalarType scalarType = pscalar->getScalarType();
switch(scalarType) {
case pvBoolean: {
PVBoolean *data = static_cast<PVBoolean*>(pv);
bool value = data->get();
if(value) {
*buffer += "true";
} else {
*buffer += "false";
}
}
return;
case pvByte: {
PVByte *data = static_cast<PVByte*>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvShort: {
PVShort *data = static_cast<PVShort*>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvInt: {
PVInt *data = static_cast<PVInt*>(pv);
char xxx[30];
sprintf(xxx,"%d",(int)data->get());
*buffer += xxx;
}
return;
case pvLong: {
PVLong *data = static_cast<PVLong*>(pv);
char xxx[30];
sprintf(xxx,"%lld",(int64)data->get());
*buffer += xxx;
}
return;
case pvFloat: {
PVFloat *data = static_cast<PVFloat*>(pv);
char xxx[30];
sprintf(xxx,"%g",data->get());
*buffer += xxx;
}
return;
case pvDouble: {
PVDouble *data = static_cast<PVDouble*>(pv);
char xxx[30];
sprintf(xxx,"%lg",data->get());
*buffer += xxx;
}
return;
case pvString: {
PVString *data = static_cast<PVString*>(pv);
*buffer += data->get();
}
return;
default:
*buffer += "(unknown ScalarType)";
}
}
void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel)
{
PVFieldPtrArray fieldsData = data->getPVFields();
if (fieldsData != 0) {
int length = data->getStructure()->getNumberFields();
for(int i=0; i<length; i++) {
PVField *fieldField = fieldsData[i];
convertToString(buffer,fieldField,indentLevel + 1);
}
}
}
void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel)
{
ScalarArrayConstPtr array = pv->getScalarArray();
ScalarType type = array->getElementType();
switch(type) {
case pvBoolean: {
PVBooleanArray *pvdata = static_cast<PVBooleanArray*>(pv);
BooleanArrayData data = BooleanArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ",";
int num = pvdata->get(i,1,&data);
if(num==1) {
BooleanArray value = data.data;
if(value[data.offset]) {
*buffer += "true";
} else {
*buffer += "false";
}
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvByte: {
PVByteArray *pvdata = static_cast<PVByteArray*>(pv);
ByteArrayData data = ByteArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ",";
int num = pvdata->get(i,1,&data);
if(num==1) {
int val = data.data[data.offset];
char buf[16];
sprintf(buf,"%d",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvShort: {
PVShortArray *pvdata = static_cast<PVShortArray*>(pv);
ShortArrayData data = ShortArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
int val = data.data[data.offset];
char buf[16];
sprintf(buf,"%d",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvInt: {
PVIntArray *pvdata = static_cast<PVIntArray*>(pv);
IntArrayData data = IntArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
int val = data.data[data.offset];
char buf[16];
sprintf(buf,"%d",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvLong: {
PVLongArray *pvdata = static_cast<PVLongArray*>(pv);
LongArrayData data = LongArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
int64 val = data.data[data.offset];
char buf[16];
sprintf(buf,"%lld",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvFloat: {
PVFloatArray *pvdata = static_cast<PVFloatArray*>(pv);
FloatArrayData data = FloatArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
float val = data.data[data.offset];
char buf[16];
sprintf(buf,"%g",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += "]";
break;
}
case pvDouble: {
PVDoubleArray *pvdata = static_cast<PVDoubleArray*>(pv);
DoubleArrayData data = DoubleArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ',';
int num = pvdata->get(i,1,&data);
if(num==1) {
double val = data.data[data.offset];
char buf[16];
sprintf(buf,"%lg",val);
*buffer += buf;
} else {
*buffer += "???? ";
}
}
*buffer += ("]");
break;
}
case pvString: {
PVStringArray *pvdata = static_cast<PVStringArray*>(pv);
StringArrayData data = StringArrayData();
*buffer += "[";
for(int i=0; i < pvdata->getLength(); i++) {
if(i!=0) *buffer += ",";
int num = pvdata->get(i,1,&data);
StringArray value = data.data;
if(num==1) {
if(value[data.offset].length()>0) {
*buffer += value[data.offset].c_str();
} else {
*buffer += "null";
}
} else {
*buffer += "null";
}
}
*buffer += "]";
break;
}
default:
*buffer += "(array element is unknown ScalarType)";
}
}
void convertStructureArray(StringBuilder buffer,
PVStructureArray * pvdata,int indentLevel)
{
int length = pvdata->getLength();
if(length<=0) {
return;
}
StructureArrayData data = StructureArrayData();
pvdata->get(0, length, &data);
for (int i = 0; i < length; i++) {
PVStructure *pvStructure = data.data[i];
if (pvStructure == 0) {
*buffer += "null";
} else {
convertToString(buffer,pvStructure,indentLevel+1);
}
}
}
#define DEFAULT_TIMEOUT 3.0
#define DEFAULT_REQUEST "field(value)"
double caTimeout = DEFAULT_TIMEOUT;
string request(DEFAULT_REQUEST);
PVStructure::shared_pointer pvRequest;
void usage (void)
{
fprintf (stderr, "\nUsage: pvaget [options] <PV name>...\n\n"
" -h: Help: Print this message\n"
"options:\n"
" -r <pv request>: Request, specifies what fields to return and options, default is '%s'\n"
" -w <sec>: Wait time, specifies timeout, default is %f second(s)\n"
"\nExample: pvaget my_channel \n\n"
, DEFAULT_REQUEST, DEFAULT_TIMEOUT);
}
class ChannelGetRequesterImpl : public ChannelGetRequester
{
private:
ChannelGet::shared_pointer m_channelGet;
epics::pvData::PVStructure::shared_pointer m_pvStructure;
epics::pvData::BitSet::shared_pointer m_bitSet;
public:
virtual String getRequesterName()
{
return "ChannelGetRequesterImpl";
};
virtual void message(String message,MessageType messageType)
{
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << messageTypeName[messageType] << ")" << std::endl;
}
virtual void channelGetConnect(const epics::pvData::Status& status,ChannelGet::shared_pointer const & channelGet,
epics::pvData::PVStructure::shared_pointer const & pvStructure,
epics::pvData::BitSet::shared_pointer const & bitSet)
{
// TODO remove (cyclic shared_pointers)
m_channelGet = channelGet;
m_pvStructure = pvStructure;
m_bitSet = bitSet;
channelGet->get(true);
}
virtual void getDone(const epics::pvData::Status& status)
{
std::cout << "getDone(" << status.toString() << ")" << std::endl;
if (status.isSuccess())
{
String str;
m_pvStructure->toString(&str);
//convertToString(&str, m_pvStructure.get(), 0);
std::cout << str;
std::cout << std::endl;
}
}
};
class ChannelRequesterImpl : public ChannelRequester
{
virtual String getRequesterName()
{
return "ChannelRequesterImpl";
};
virtual void message(String message,MessageType messageType)
{
std::cout << "[" << getRequesterName() << "] message(" << message << ", " << messageTypeName[messageType] << ")" << std::endl;
}
virtual void channelCreated(const epics::pvData::Status& status, Channel::shared_pointer const & channel)
{
if (status.isSuccess())
{
// show warning
if (!status.isOK())
{
std::cout << "channel create: " << status.toString() << std::endl;
}
}
else
{
std::cout << "failed to create a channel: " << status.toString() << std::endl;
}
}
virtual void channelStateChange(Channel::shared_pointer const & channel, Channel::ConnectionState connectionState)
{
if (connectionState == Channel::CONNECTED)
{
ChannelGetRequester::shared_pointer getRequester(new ChannelGetRequesterImpl());
channel->createChannelGet(getRequester, pvRequest);
}
/*
else if (connectionState != Channel::DESTROYED)
{
std::cout << "channel state change: " << Channel::ConnectionStateNames[connectionState] << std::endl;
}
*/
}
};
/*+**************************************************************************
*
* Function: main
*
* Description: pvaget main()
* Evaluate command line options, set up CA, connect the
* channels, print the data as requested
*
* Arg(s) In: [options] <pv-name>...
*
* Arg(s) Out: none
*
* Return(s): Standard return code (0=success, 1=error)
*
**************************************************************************-*/
int main (int argc, char *argv[])
{
int opt; /* getopt() current option */
setvbuf(stdout,NULL,_IOLBF,BUFSIZ); /* Set stdout to line buffering */
while ((opt = getopt(argc, argv, ":hr:w:")) != -1) {
switch (opt) {
case 'h': /* Print usage */
usage();
return 0;
case 'w': /* Set CA timeout value */
if(epicsScanDouble(optarg, &caTimeout) != 1)
{
fprintf(stderr, "'%s' is not a valid timeout value "
"- ignored. ('cainfo -h' for help.)\n", optarg);
caTimeout = DEFAULT_TIMEOUT;
}
break;
case 'r': /* Set CA timeout value */
request = optarg;
break;
case '?':
fprintf(stderr,
"Unrecognized option: '-%c'. ('pvaget -h' for help.)\n",
optopt);
return 1;
case ':':
fprintf(stderr,
"Option '-%c' requires an argument. ('pvaget -h' for help.)\n",
optopt);
return 1;
default :
usage();
return 1;
}
}
int nPvs = argc - optind; /* Remaining arg list are PV names */
if (nPvs < 1)
{
fprintf(stderr, "No pv name specified. ('pvaget -h' for help.)\n");
return 1;
}
vector<string> pvs; /* Array of PV structures */
for (int n = 0; optind < argc; n++, optind++)
pvs.push_back(argv[optind]); /* Copy PV names from command line */
try {
pvRequest = getCreateRequest()->createRequest(request);
} catch (std::exception &ex) {
printf("failed to parse request string: %s\n", ex.what());
return 1;
}
ClientFactory::start();
ChannelProvider::shared_pointer provider = getChannelAccess()->getProvider("pvAccess");
ChannelRequester::shared_pointer channelRequester(new ChannelRequesterImpl());
Channel::shared_pointer tmpChannel = provider->createChannel(pvs[0], channelRequester); // TODO
epicsThreadSleep ( 3.0 );
ClientFactory::stop();
return 0;
}