cafe/cpp
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Connection time optimized

Browse Source
This commit is contained in:
chrin
2017-11-14 09:18:27 +01:00
parent 4d9a8fd116
commit 350ddab997
47 changed files with 350899 additions and 701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
include/PVCtrlHolder.h
View File

@@ -42,7 +42,8 @@ private:
CAFE_DATATYPE_UNION lowerCtrlLimit;
Helper helper;
public:
PVCtrlHolder(){
@@ -205,12 +206,13 @@ private:
print(nelem) ;
}
void print(unsigned int nelemToPrint) {
nelemToPrint=min(nelemToPrint,nelem);
std::cout << "------------------------------------------" << std::endl;
std::cout << "PVCtrlHolder:" << std::endl;
std::cout << "processVariable= " << pv << std::endl;
std::cout << "processVariable= " << pv << std::endl;
if (strcmp(pvAlias,pv)) {
std::cout << "pvAlias = " << pvAlias << std::endl;
}
@@ -220,11 +222,15 @@ private:
<< " (" << dataType << ") " << std::endl;
std::cout << "dbrTypeRequest = " << dbr_type_to_text(dbrDataType)<< std::endl;
if (dataType!=CAFE_NO_ACCESS || dataType != CAFE_TYPENOTCONN) {
std::cout << "nelem = " << nelem << std::endl;
std::cout << "nelem = " << nelem << std::endl;
std::cout << "alarmStatus = " << alarmStatus << std::endl;
std::cout << "alarmSeverity = " << alarmSeverity << std::endl;
std::cout << "precision = " << precision << std::endl;
//std::cout << "alarmStatus = " << alarmStatus << " [" << acond.asString(alarmStatus)<< "]" << std::endl;
//std::cout << "alarmSeverity = " << alarmSeverity << " [" << aseve.asString(alarmSeverity) << "]"<< std::endl;
std::cout << "alarmStatus = " << acond.asString(alarmStatus) << " (" << alarmStatus << ")" << std::endl;
std::cout << "alarmSeverity = " << aseve.asString(alarmSeverity) << " (" <<alarmSeverity << ")" << std::endl;
std::cout << "precision = " << precision << std::endl;
std::cout << "units = " << units << std::endl;
/*
if (dataType==CAFE_DOUBLE){

11
include/PVDataHolder.h
View File

@@ -159,6 +159,7 @@ public:
std::cout << "Variable has not been applied to a get operation!" << std::endl;
return;
}
std::cout << "------------------------------------------" << std::endl;
//std::cout << "PVDataHolder:" << std::endl;
@@ -171,7 +172,8 @@ public:
std::cout << "attrib = " << attrib << std::endl;
std::cout << "dataType = " << cafeDataTypeCode.message(dataType).c_str()
<< " (" << dataType << ") " << std::endl;
std::cout << "dbrTypeRequest = " << dbr_type_to_text(dbrDataType)<< std::endl;
std::cout << "dbrTypeRequest = " << dbr_type_to_text(dbrDataType)
<< " (" << dbrDataType << ") " << std::endl;
//std::cout << "dataType = " << CAFEDataTypeCode.message(dataType).c_str() << std::endl;
@@ -187,15 +189,16 @@ public:
}
if (dbr_type_is_STS(dbrDataType) || dbr_type_is_TIME(dbrDataType) ) {
std::cout << "alarmStatus = " << alarmStatus << std::endl;
std::cout << "alarmSeverity = " << alarmSeverity << std::endl;
std::cout << "alarmStatus = " << acond.asString(alarmStatus) << " (" << alarmStatus << ")" << std::endl;
std::cout << "alarmSeverity = " << aseve.asString(alarmSeverity) << " (" <<alarmSeverity << ")" << std::endl;
if (dbr_type_is_TIME(dbrDataType)) {
std::cout << "epicsTimeStamp = " << ts.secPastEpoch << " sec. and " << ts.nsec << " nsec" << std::endl;
}
}
if(beamEventNo!=0) {std::cout << "beamEventNo = " << beamEventNo << std::endl;};
std::cout << "status = " << cafeStatusCode.message(status).c_str() << std::endl;
std::cout << "status = " << cafeStatusCode.message(status).c_str() << " (" << status << ") " << std::endl;
std::cout << "value(s) = " ;
switch (dataType) {

4
include/PVGroup.h
View File

@@ -156,6 +156,8 @@ public:
CAFEStatus cstat; cstat.report(statusGroup);
}
for (unsigned int i=0; i<npvToPrint; ++i) {
std::cout << "------------------------------------------" << std::endl;
std::cout << "Element [" << i << "] of " << npvToPrint << " in group: " << name << endl;
pvdata[i].print();
}
}
@@ -169,6 +171,8 @@ public:
CAFEStatus cstat; cstat.report(statusGroup);
}
for (unsigned int i=0; i<npvToPrint; ++i) {
std::cout << "------------------------------------------" << std::endl;
std::cout << "Element [" << i << "] of " << npvToPrint << " in group: " << name << endl;
pvdata[i].print(min(maxNelemWF,pvdata[i].getNelem()));
}
}

421
include/PVHolder.h
View File

@@ -48,6 +48,9 @@ protected:
short alarmStatus; //alarm.h 0-22 0=NO_ALARM
short alarmSeverity; //alarm.h 0=NO_ALARM 1=MINOR 2=MAJOR 3=INVALID
CAFEGlobalAlarmCondition acond;
CAFEGlobalAlarmSeverity aseve;
unsigned int userNo; //e.g. add handle
unsigned int beamEventNo;
@@ -98,10 +101,14 @@ public:
boost::shared_ptr<vector<double> > ValVD_ptr;
boost::shared_ptr<vector<float> > ValVF_ptr;
//boost::shared_ptr<vector<short> > ValVS_ptr;
boost::shared_ptr<vector<short> > ValVS_ptr;
boost::shared_ptr<vector<int> > ValVI_ptr;
//boost::shared_ptr<vector<unsigned char> > ValVC_ptr;
//boost::shared_ptr<vector<unsigned short> > ValVUS_ptr;
boost::shared_ptr<vector<long> > ValVL_ptr;
boost::shared_ptr<vector<unsigned long> > ValVUL_ptr;
boost::shared_ptr<vector<long long> > ValVLL_ptr;
boost::shared_ptr<vector<unsigned long long> > ValVULL_ptr;
boost::shared_ptr<vector<unsigned char> > ValVC_ptr;
boost::shared_ptr<vector<unsigned short> > ValVUS_ptr;
boost::shared_ptr<vector<string> > ValVStr_ptr;
typedef boost::shared_ptr<double []> ValDPtr;
@@ -135,7 +142,7 @@ public:
return;
};
void setBSStatus(int st) {status=st;} //for bsread
const char * getPV() const {return pv;};
const char * getPVName() const {return pv;};
@@ -148,12 +155,15 @@ public:
CAFE_DATATYPE_UNION_SEQ getVal() const {return val.get();};
short getAlarmStatus() const {return alarmStatus;};
short getAlarmStatus() const {return alarmStatus;};
short getAlarmSeverity() const {return alarmSeverity;};
string getAlarmStatusAsString() {return acond.asString(alarmStatus);};
string getAlarmSeverityAsString() {return aseve.asString(alarmSeverity);};
unsigned int getBeamEventNo() const {return beamEventNo;};
bool getRule() const {return rule;};
bool getHasAlarm() const{return hasAlarm;};
bool getHasAlarm() const{return hasAlarm;};
int getStatus() const {return status;};
CAFE_DATATYPE getDataTypeClient() const {return dataType;};
CAFE_DATATYPE getDataType() const {return dataType;};
@@ -194,6 +204,8 @@ public:
void setString(std::string str) {strcpy(val[0].str,str.c_str()); dataType=CAFE_STRING;};
void setDouble(double d) {val[0].d=d; dataType=CAFE_DOUBLE;};
void setInt(int l) {val[0].l=l; dataType=CAFE_LONG;};
void setVString(vector<std::string> Vstr) {
if(Vstr.size()!=nelem) {nelem=Vstr.size();}
for (unsigned int i=0; i<nelem; ++ i) {
@@ -206,6 +218,64 @@ public:
if(Vl.size()!=nelem) {nelem=Vl.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].l=Vl[i];} dataType=CAFE_LONG;};
void set(vector<std::string> Vstr) {
if(Vstr.size()!=nelem) {nelem=Vstr.size();}
for (unsigned int i=0; i<nelem; ++ i) {
strcpy(val[i].str,Vstr[i].c_str());} dataType=CAFE_STRING;};
void set(vector<double> Vd) {
if(Vd.size()!=nelem) {nelem=Vd.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].d=Vd[i];} dataType=CAFE_DOUBLE;};
void set(vector<float> Vf) {
if(Vf.size()!=nelem) {nelem=Vf.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].f=Vf[i];} dataType=CAFE_FLOAT;};
void set (vector<int> Vl) {
if(Vl.size()!=nelem) {nelem=Vl.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].l=Vl[i];} dataType=CAFE_LONG;};
void set (vector<long> Vl) {
if(Vl.size()!=nelem) {nelem=Vl.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].l=Vl[i];} dataType=CAFE_LONG;};
void set (vector<unsigned long> Vul) {
if(Vul.size()!=nelem) {nelem=Vul.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].d=Vul[i];} dataType=CAFE_DOUBLE;};
void set (vector<long long> Vll) {
if(Vll.size()!=nelem) {nelem=Vll.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].d=Vll[i];} dataType=CAFE_DOUBLE;};
void set (vector<unsigned long long> Vull) {
if(Vull.size()!=nelem) {nelem=Vull.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].d=Vull[i];} dataType=CAFE_DOUBLE;};
void set (vector<short> Vs) {
if(Vs.size()!=nelem) {nelem=Vs.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].s=Vs[i];} dataType=CAFE_SHORT;};
void set (vector<unsigned short> Vus) {
if(Vus.size()!=nelem) {nelem=Vus.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].us=Vus[i];} dataType=CAFE_ENUM;};
void set (vector<unsigned char> Vc) {
if(Vc.size()!=nelem) {nelem=Vc.size();}
for (unsigned int i=0; i<nelem; ++ i) {
val[i].ch=Vc[i];} dataType=CAFE_CHAR;};
void set(unsigned int l) {val[0].l= (int) l; dataType=CAFE_LONG;};
void set(unsigned short us) {val[0].us=us; dataType=CAFE_ENUM;};
@@ -287,9 +357,10 @@ public:
}
boost::shared_ptr<vector<double> > getAsVDouble(){
#define __METHOD__ "PVHolder::getVDouble "
#define __METHOD__ "PVHolder::getAsVDouble "
ValVD_ptr.reset(new vector<double>());
ValVD_ptr->reserve(nelem);
switch (dataType)
{
@@ -322,9 +393,10 @@ public:
}
boost::shared_ptr<vector<float> > getAsVFloat(){
#define __METHOD__ "PVHolder::getVFloat "
#define __METHOD__ "PVHolder::getAsVFloat "
ValVF_ptr.reset(new vector<float>());
ValVF_ptr->reserve(nelem);
switch (dataType)
{
@@ -357,6 +429,10 @@ public:
//cout << "size/// " << vf[0].size() << endl;
//cout << vf[0][0] << " val " << val[0].f << endl;
//cout << vf[0][1] << " val " << val[1].f << endl;
//vector<float> vf= *ValVF_ptr.get();
//cout << "size/// " << vf.size() << endl;
//cout << vf[0] << " val " << val[0].f << endl;
//cout << vf[1] << " val " << val[1].f << endl;
return ValVF_ptr;
#undef __METHOD__
@@ -364,10 +440,11 @@ public:
boost::shared_ptr<vector<int> > getAsVInt(){
#define __METHOD__ "PVHolder::getVInt "
#define __METHOD__ "PVHolder::getAsVInt "
ValVI_ptr.reset(new vector<int>());
ValVI_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
@@ -398,16 +475,338 @@ public:
#undef __METHOD__
}
boost::shared_ptr<vector<long> > getAsVLong(){
#define __METHOD__ "PVHolder::getAsVInt "
ValVL_ptr.reset(new vector<long>());
ValVL_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back( getAsLong(i));}
break;
}
return ValVL_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<unsigned long> > getAsVULong(){
#define __METHOD__ "PVHolder::getAsVInt "
ValVUL_ptr.reset(new vector<unsigned long>());
ValVUL_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back( getAsULong(i));}
break;
}
return ValVUL_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<long long> > getAsVLongLong(){
#define __METHOD__ "PVHolder::getAsVLongLong "
ValVLL_ptr.reset(new vector<long long>());
ValVLL_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back( getAsLongLong(i));}
break;
}
return ValVLL_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<unsigned long long> > getAsVULongLong(){
#define __METHOD__ "PVHolder::getAsVLongLong "
ValVULL_ptr.reset(new vector<unsigned long long>());
ValVULL_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back( getAsULongLong(i));}
break;
}
return ValVULL_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<short> > getAsVShort(){
#define __METHOD__ "PVHolder::getAsVShort "
ValVS_ptr.reset(new vector<short>());
ValVS_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back(val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((unsigned short) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back( getAsShort(i));}
break;
}
return ValVS_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<unsigned short> > getAsVUShort(){
#define __METHOD__ "PVHolder::getAsVUShort "
ValVUS_ptr.reset(new vector<unsigned short>());
ValVUS_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short)val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back( val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back( getAsUShort(i));}
break;
}
return ValVUS_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<unsigned char> > getAsVUChar(){
#define __METHOD__ "PVHolder::getAsVUChar "
ValVC_ptr.reset(new vector<unsigned char>());
ValVC_ptr->reserve(nelem);
switch (dataType)
{
case CAFE_DOUBLE:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].d);}
break;
case CAFE_FLOAT:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].f);}
break;
case CAFE_LONG:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].l);}
break;
case CAFE_SHORT:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char)val[i].s);}
break;
case CAFE_ENUM:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back( (unsigned char)val[i].us);}
break;
case CAFE_CHAR:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].ch);}
break;
case CAFE_STRING:
default:
for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back( (unsigned char) getAsChar(i));}
break;
}
return ValVC_ptr;
#undef __METHOD__
}
boost::shared_ptr<vector<string> > getAsVString(){
#define __METHOD__ "PVHolder::getVString "
#define __METHOD__ "PVHolder::getAsVString "
ValVStr_ptr.reset(new vector<string>());
ValVStr_ptr->reserve(nelem);
for (unsigned i=0; i<nelem; ++i) {ValVStr_ptr->push_back( getAsString(i));}
return ValVStr_ptr;
#undef __METHOD__
}
vector<string> getAsVectorString() {
boost::shared_ptr<vector<string> > spVs = getAsVString();
return *spVs.get();
}
vector<float> getAsVectorFloat() {
boost::shared_ptr<vector<float> > spVf = getAsVFloat();
return *spVf.get();
}
vector<double> getAsVectorDouble() {
boost::shared_ptr<vector<double> > spVd = getAsVDouble();
return *spVd.get();
}
vector<int> getAsVectorInt() {
boost::shared_ptr<vector<int> > spVi = getAsVInt();
return *spVi.get();
}
vector<long> getAsVectorLong() {
boost::shared_ptr<vector<long> > spVl = getAsVLong();
return *spVl.get();
}
vector<unsigned long> getAsVectorULong() {
boost::shared_ptr<vector<unsigned long> > spVul = getAsVULong();
return *spVul.get();
}
vector<long long> getAsVectorLongLong() {
boost::shared_ptr<vector<long long> > spVll = getAsVLongLong();
return *spVll.get();
}
vector<unsigned long long> getAsVectorULongLong() {
boost::shared_ptr<vector<unsigned long long> > spVull = getAsVULongLong();
return *spVull.get();
}
vector<short> getAsVectorShort() {
boost::shared_ptr<vector<short> > spVsh = getAsVShort();
return *spVsh.get();
}
vector<unsigned short> getAsVectorUShort() {
boost::shared_ptr<vector<unsigned short> > spVus = getAsVUShort();
return *spVus.get();
}
vector<unsigned char> getAsVectorUChar() {
boost::shared_ptr<vector<unsigned char> > spVc = getAsVUChar();
return *spVc.get();
}
ValDPtr getDouble(){
#define __METHOD__ "PVHolder::getDouble "
if (dataType!=CAFE_DOUBLE) {

115
include/PyCafe2_api.h Normal file
View File

@@ -0,0 +1,115 @@
/* Generated by Cython 0.23.4 */
#ifndef __PYX_HAVE_API__PyCafe
#define __PYX_HAVE_API__PyCafe
#include "Python.h"
static void (*__pyx_api_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
#define py_cb_wrapper __pyx_api_f_6PyCafe_py_cb_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
#define py_cb_ctrl_wrapper __pyx_api_f_6PyCafe_py_cb_ctrl_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
#define py_cb_handle_wrapper __pyx_api_f_6PyCafe_py_cb_handle_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
#define py_cb_handle_monid_wrapper __pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper)(unsigned int) = 0;
#define py_cb_handle_get_wrapper __pyx_api_f_6PyCafe_py_cb_handle_get_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper)(unsigned int) = 0;
#define py_cb_handle_put_wrapper __pyx_api_f_6PyCafe_py_cb_handle_put_wrapper
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
#define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif
#ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
PyObject *py_name = 0;
PyObject *py_module = 0;
py_name = __Pyx_PyIdentifier_FromString(name);
if (!py_name)
goto bad;
py_module = PyImport_Import(py_name);
Py_DECREF(py_name);
return py_module;
bad:
Py_XDECREF(py_name);
return 0;
}
#endif
#ifndef __PYX_HAVE_RT_ImportFunction
#define __PYX_HAVE_RT_ImportFunction
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%.200s does not export expected C function %.200s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
#endif
static int import_PyCafe(void) {
PyObject *module = 0;
module = __Pyx_ImportModule("PyCafe");
if (!module) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_get_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper, "void (unsigned int)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_put_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper, "void (unsigned int)") < 0) goto bad;
Py_DECREF(module); module = 0;
return 0;
bad:
Py_XDECREF(module);
return -1;
}
#endif /* !__PYX_HAVE_API__PyCafe */

107
include/PyCafe2_api_March7.h Normal file
View File

@@ -0,0 +1,107 @@
#ifndef __PYX_HAVE_API__PyCafe
#define __PYX_HAVE_API__PyCafe
#include "Python.h"
static void (*__pyx_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
#define py_cb_wrapper __pyx_f_6PyCafe_py_cb_wrapper
static void (*__pyx_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
#define py_cb_ctrl_wrapper __pyx_f_6PyCafe_py_cb_ctrl_wrapper
static void (*__pyx_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
#define py_cb_handle_wrapper __pyx_f_6PyCafe_py_cb_handle_wrapper
static void (*__pyx_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
#define py_cb_handle_monid_wrapper __pyx_f_6PyCafe_py_cb_handle_monid_wrapper
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
#define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif
#ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
PyObject *py_name = 0;
PyObject *py_module = 0;
py_name = __Pyx_PyIdentifier_FromString(name);
if (!py_name)
goto bad;
py_module = PyImport_Import(py_name);
Py_DECREF(py_name);
return py_module;
bad:
Py_XDECREF(py_name);
return 0;
}
#endif
#ifndef __PYX_HAVE_RT_ImportFunction
#define __PYX_HAVE_RT_ImportFunction
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%.200s does not export expected C function %.200s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
#endif
static int import_PyCafe(void) {
PyObject *module = 0;
module = __Pyx_ImportModule("PyCafe");
if (!module) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
Py_DECREF(module); module = 0;
return 0;
bad:
Py_XDECREF(module);
return -1;
}
#endif /* !__PYX_HAVE_API__PyCafe */

109
include/PyCafe3_api_March7.h Normal file
View File

@@ -0,0 +1,109 @@
/* Generated by Cython 0.23.4 */
#ifndef __PYX_HAVE_API__PyCafe
#define __PYX_HAVE_API__PyCafe
#include "Python.h"
static void (*__pyx_api_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
#define py_cb_wrapper __pyx_api_f_6PyCafe_py_cb_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
#define py_cb_ctrl_wrapper __pyx_api_f_6PyCafe_py_cb_ctrl_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
#define py_cb_handle_wrapper __pyx_api_f_6PyCafe_py_cb_handle_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
#define py_cb_handle_monid_wrapper __pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
#define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif
#ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
PyObject *py_name = 0;
PyObject *py_module = 0;
py_name = __Pyx_PyIdentifier_FromString(name);
if (!py_name)
goto bad;
py_module = PyImport_Import(py_name);
Py_DECREF(py_name);
return py_module;
bad:
Py_XDECREF(py_name);
return 0;
}
#endif
#ifndef __PYX_HAVE_RT_ImportFunction
#define __PYX_HAVE_RT_ImportFunction
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%.200s does not export expected C function %.200s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
#endif
static int import_PyCafe(void) {
PyObject *module = 0;
module = __Pyx_ImportModule("PyCafe");
if (!module) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
Py_DECREF(module); module = 0;
return 0;
bad:
Py_XDECREF(module);
return -1;
}
#endif /* !__PYX_HAVE_API__PyCafe */

115
include/PyCafe3_api_Sep22.h Normal file
View File

@@ -0,0 +1,115 @@
/* Generated by Cython 0.23.4 */
#ifndef __PYX_HAVE_API__PyCafe
#define __PYX_HAVE_API__PyCafe
#include "Python.h"
static void (*__pyx_api_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
#define py_cb_wrapper __pyx_api_f_6PyCafe_py_cb_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
#define py_cb_ctrl_wrapper __pyx_api_f_6PyCafe_py_cb_ctrl_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
#define py_cb_handle_wrapper __pyx_api_f_6PyCafe_py_cb_handle_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
#define py_cb_handle_monid_wrapper __pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper)(unsigned int) = 0;
#define py_cb_handle_get_wrapper __pyx_api_f_6PyCafe_py_cb_handle_get_wrapper
static void (*__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper)(unsigned int) = 0;
#define py_cb_handle_put_wrapper __pyx_api_f_6PyCafe_py_cb_handle_put_wrapper
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
#define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif
#ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
PyObject *py_name = 0;
PyObject *py_module = 0;
py_name = __Pyx_PyIdentifier_FromString(name);
if (!py_name)
goto bad;
py_module = PyImport_Import(py_name);
Py_DECREF(py_name);
return py_module;
bad:
Py_XDECREF(py_name);
return 0;
}
#endif
#ifndef __PYX_HAVE_RT_ImportFunction
#define __PYX_HAVE_RT_ImportFunction
static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
PyObject *d = 0;
PyObject *cobj = 0;
union {
void (*fp)(void);
void *p;
} tmp;
d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
if (!d)
goto bad;
cobj = PyDict_GetItemString(d, funcname);
if (!cobj) {
PyErr_Format(PyExc_ImportError,
"%.200s does not export expected C function %.200s",
PyModule_GetName(module), funcname);
goto bad;
}
#if PY_VERSION_HEX >= 0x02070000
if (!PyCapsule_IsValid(cobj, sig)) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
goto bad;
}
tmp.p = PyCapsule_GetPointer(cobj, sig);
#else
{const char *desc, *s1, *s2;
desc = (const char *)PyCObject_GetDesc(cobj);
if (!desc)
goto bad;
s1 = desc; s2 = sig;
while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
if (*s1 != *s2) {
PyErr_Format(PyExc_TypeError,
"C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
PyModule_GetName(module), funcname, sig, desc);
goto bad;
}
tmp.p = PyCObject_AsVoidPtr(cobj);}
#endif
*f = tmp.fp;
if (!(*f))
goto bad;
Py_DECREF(d);
return 0;
bad:
Py_XDECREF(d);
return -1;
}
#endif
static int import_PyCafe(void) {
PyObject *module = 0;
module = __Pyx_ImportModule("PyCafe");
if (!module) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_get_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper, "void (unsigned int)") < 0) goto bad;
if (__Pyx_ImportFunction(module, "py_cb_handle_put_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper, "void (unsigned int)") < 0) goto bad;
Py_DECREF(module); module = 0;
return 0;
bad:
Py_XDECREF(module);
return -1;
}
#endif /* !__PYX_HAVE_API__PyCafe */

14
include/cafe.h
View File

@@ -187,7 +187,7 @@ public:
int calcDBPMStatus(int, int, string);
int getDBPM(DBPMHolder &dbpm);
int getBS(BSDataHolder &bsd);
int getDBPM(DBPMKeeper &dbpm);
int readDBPMOffsets(DBPMKeeper &dbpm);
@@ -990,10 +990,22 @@ public:
return status;
}
//Closes channels but does not delete handle
vector<unsigned int> closeDisconnectedChannelsFromWithinGroupV(const unsigned int groupHandle) {
vector<unsigned int> dhV=handleHelper.getDisconnectedHandlesFromWithinGroupV(groupHandle);
if (dhV.size() >0) {closeChannelsKeepHandles(dhV);}
return dhV;
}
vector<unsigned int> getDisconnectedHandlesFromWithinGroupV(const unsigned int groupHandle) {
return handleHelper.getDisconnectedHandlesFromWithinGroupV(groupHandle);
}
vector<unsigned int> getHandlesFromWithinGroupV(const unsigned int groupHandle) {
return handleHelper.getHandlesFromWithinGroupV(groupHandle);
}
unsigned int * getHandlesFromWithinGroup(const unsigned int groupHandle) {
return handleHelper.getHandlesFromWithinGroup(groupHandle);
}

129
include/cafeRoast.h
View File

@@ -383,6 +383,135 @@ int setAndMatchMany(vector<unsigned int> handleSetV, vector<string> valSetV, vec
int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_double_t> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
dbr_double_t tolerance, double timeout, bool printFlag){
cafeDoppio.setMany (handleSet, DBR_DOUBLE, valSet, false);
cafeSoluble.setManyString (handleAction, valAction, false);
return cafeDoppio.compareAndMatchMany(handleSet, DBR_DOUBLE, valSet, handleMatch, tolerance, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_float_t> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
dbr_float_t tolerance, double timeout, bool printFlag){
cafeFrappuccino.setMany (handleSet, DBR_FLOAT, valSet, false);
cafeSoluble.setManyString (handleAction, valAction, false);
return cafeFrappuccino.compareAndMatchMany(handleSet, DBR_FLOAT, valSet, handleMatch, tolerance, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_char_t> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
dbr_char_t tolerance, double timeout, bool printFlag){
cafeCappuccino.setMany (handleSet, DBR_CHAR, valSet, false);
cafeSoluble.setManyString (handleAction, valAction, false);
return cafeCappuccino.compareAndMatchMany(handleSet, DBR_CHAR, valSet, handleMatch, tolerance, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_enum_t> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
dbr_enum_t tolerance, double timeout, bool printFlag){
cafeEspresso.setMany (handleSet, DBR_ENUM, valSet, false);
cafeSoluble.setManyString (handleAction, valAction, false);
return cafeEspresso.compareAndMatchMany(handleSet, DBR_ENUM, valSet, handleMatch, tolerance, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_short_t> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
dbr_short_t tolerance, double timeout, bool printFlag){
cafeSchale.setMany (handleSet, DBR_SHORT, valSet, false);
cafeSoluble.setManyString (handleAction, valAction, false);
return cafeSchale.compareAndMatchMany(handleSet, DBR_SHORT, valSet, handleMatch, tolerance, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_long_t> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
dbr_long_t tolerance, double timeout, bool printFlag){
cafeLatte.setMany (handleSet, DBR_LONG, valSet, false);
cafeSoluble.setManyString (handleAction, valAction, false);
return cafeLatte.compareAndMatchMany(handleSet, DBR_LONG, valSet, handleMatch, tolerance, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSet, vector<long long> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
long long tolerance, double timeout, bool printFlag){
vector<dbr_double_t> valSetDoubleV;
valSetDoubleV.reserve(valSet.size());
std::copy(valSet.begin(), valSet.end(),
std::back_inserter(valSetDoubleV));
dbr_double_t toleranceDouble = tolerance;
return gameSetAndMatch(handleSet, valSetDoubleV,
handleAction, valAction, handleMatch, toleranceDouble, timeout, printFlag);
}
int gameSetAndMatch(vector<unsigned int> handleSetV, vector<string> valSetV,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatchV,
string tolerance, double timeout, bool printFlag){
#define __METHOD__ "gameSetAndMatch (vector<unsigned int> handleSetV, vector<string> valSetV, \
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatchV, \
string tolerance, double timeout, bool printFlag)"
vector<dbr_double_t> valSetDoubleV;
istringstream ss;
dbr_double_t d=0; dbr_double_t toleranceDouble = 0;
for (size_t i=0; i< valSetV.size(); ++i) {
d=0;
ss.clear();
ss.str(valSetV[i]);
ss>>d;
if ( !ss.fail()) {
valSetDoubleV.push_back(d);
}
else {
cout << __METHOD__ << __LINE__ << endl;
cout << "***WARNING*** NO STRING TO DBR_DOUBLE CONVERSION " << endl;
cout << "***WARNING*** COULD NOT CONVERT: ";
cout << valSetV[i];
cout << " TO DOUBLE!" << endl;
return ECAFE_NO_CONVERT;
}
}
d=0;
ss.clear();
ss.str(tolerance);
ss>>d;
if ( !ss.fail()) {
toleranceDouble=d;
}
else {
cout << __METHOD__ << __LINE__ << endl;
cout << "***WARNING*** NO STRING TO DBR_DOUBLE CONVERSION " << endl;
cout << "***WARNING*** COULD NOT CONVERT: ";
cout << tolerance;
cout << " TO DOUBLE!" << endl;
return ECAFE_NO_CONVERT;
}
return gameSetAndMatch(handleSetV, valSetDoubleV, handleAction, valAction, handleMatchV, toleranceDouble, timeout, printFlag);
#undef __METHOD__
}
int setAndMatch(const unsigned int handleSet, dbr_double_t valSet, const unsigned int handleMatch,
dbr_double_t tolerance, double timeout, bool printFlag){
return cafeDoppio.setAndMatch(handleSet, DBR_DOUBLE, valSet, handleMatch, tolerance, timeout, printFlag);

754
include/cafeService.h
View File

@@ -1,8 +1,8 @@
///
/// \file cafeService.h
/// \author Jan Chrin, PSI
/// \date Release July: 2017
/// \version CAFE 1.3.0
/// \date Release October 2017
/// \version CAFE 1.4.0
///
#ifndef CAFE_SERVICE_H
@@ -16,7 +16,6 @@
#if HAVE_ZEROMQ
//include <zhelpers.h>
#include <zmq.h>
#if HAVE_JSON
#include <json/json.h>
@@ -26,22 +25,331 @@
#endif
#endif
/*
class BSData{
friend class CAFE;
class BSChannel {
private:
double val;
epicsTimeStamp ets;
int status;
string name;
int modulo;
int offset;
HandleHelper helper;
public:
double getValue() {return val;}
epicsTimeStamp getEpicsTimeStamp() {return ets;}
int getStatus() { return status;}
BSData(){};
PVDataHolder pvd;
std::vector<std::string> pv;
//void setName(string _name) { name=_name;}
void setOffset(int _offset) { offset=_offset;}
void setModulo(int _modulo) { modulo=_modulo;}
string getName(){return name;}
int getModulo(){return modulo;}
int getOffset(){return offset;}
BSChannel(string _name): modulo(1), offset(0) {
char pv[PVNAME_SIZE];
helper.removeLeadingAndTrailingSpaces(_name.c_str(), pv);
name=(string) pv;};
BSChannel(string _name, int _modulo): offset(0) {
char pv[PVNAME_SIZE];
helper.removeLeadingAndTrailingSpaces(_name.c_str(), pv);
name=(string) pv; modulo=_modulo;};
BSChannel(string _name, int _modulo, int _offset) {
char pv[PVNAME_SIZE];
helper.removeLeadingAndTrailingSpaces(_name.c_str(), pv);
name=(string) pv; modulo=_modulo; offset=_offset;};
};
class BSDataHolder{
friend class CAFE;
private:
int overallStatus;
unsigned long long pulse_id;
vector<BSChannel> bsChannel;
HandleHelper helper;
std::vector<std::string> pv;
bool isBS;
bool BSInitialized;
void *context;
void *receiver;
int rc;
#if HAVE_JSON
Json::Value parsedFromString;
Json::Reader reader;
#endif
bool parsingSuccessful;
public:
BSDataHolder(){};
void *subscriber;
vector<double> getAsDoubleV() {
vector<double> V;
V.reserve(bsChannel.size());
for (size_t i=0; i<bsChannel.size(); ++i){
V.push_back(bsChannel[i].pvd.getAsDouble());
}
return V;
}
vector<string> getAsStringV() {
vector<string> V;
V.reserve(bsChannel.size());
for (size_t i=0; i<bsChannel.size(); ++i){
V.push_back(bsChannel[i].pvd.getAsString());
}
return V;
}
vector<int> getAsIntV() {
vector<int> V;
V.reserve(bsChannel.size());
for (size_t i=0; i<bsChannel.size(); ++i){
V.push_back(bsChannel[i].pvd.getAsInt());
}
return V;
}
vector<double> getAttributeAsDoubleV(string attribute) {
vector<double> V;
V.reserve(bsChannel.size());
char pvAtt[PVNAME_SIZE];
helper.removeLeadingAndTrailingSpaces(attribute.c_str(), pvAtt);
for (size_t i=0; i<bsChannel.size(); ++i){
if ( ((string)pvAtt).compare((string) bsChannel[i].pvd.getAttribute()) ==0){
V.push_back(bsChannel[i].pvd.getAsDouble());
}
}
return V;
}
PVDataHolder getPVData(unsigned int idx) {
if (idx > (bsChannel.size()-1)) {
idx=bsChannel.size()-1;
}
return bsChannel[idx].pvd;
}
PVDataHolder getPVData(string name) {
for (size_t i=0; i< bsChannel.size(); ++i) {
if (bsChannel[i].getName().compare(name) ==0 ) {
return bsChannel[i].pvd;
}
}
}
int getStatus() { return overallStatus;}
static size_t RecvResponseCallback(char * contents, size_t size, size_t nmemb, void * up) {
++nCBs;
//cout << "Callback called: " << nCBs << endl;
//cout << "SIZE No. of Bytes " << size*nmemb << endl;
string sLocal=contents;
//remove \n for newline
std::size_t found = sLocal.find('\n');
if (found != std::string::npos) {
sLocal=sLocal.substr(0, found);
}
contentsBS=contentsBS+sLocal;
return (size_t) size * nmemb;
}
bool setBS(bool BSFlag) {
if(MUTEX){cafeMutex.lock();}
if (BSFlag) {
#if HAVE_CURL
string dataChannels=string("{\"channels\":[");
vector<string> pvNew=pv;
#if HAVE_ZEROMQ
if (!BSInitialized) {
//size_t found;
dataChannels= dataChannels + string("{\"name\":\"");
dataChannels= dataChannels + pvNew[0];
dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}" );
for (size_t i=1; i < pvNew.size(); ++i) {
dataChannels= dataChannels + string(",{\"name\":\"");
dataChannels= dataChannels + pvNew[i];
dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}");
}
dataChannels= dataChannels + string("],");
dataChannels= dataChannels + "\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"keep-as-is\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
cout << dataChannels << endl;
const char * data = dataChannels.c_str();
///cout << "SIZE OF DATA --------------->" << sizeof(data) << endl;
CURL *curl;
CURLcode res;
struct curl_slist * slist;
slist = NULL;
slist = curl_slist_append(slist, "Content-Type: application/json");
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
if (curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://dispatcher-api.psi.ch/sf/stream");
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); //"-F file=@./dbpm.json"); //data); //
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
//cout << "WAITING FOR CALLBACK... " << endl;
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &RecvResponseCallback);
res = curl_easy_perform(curl);
if (res != CURLE_OK) {
cout << "curl_easy_perform failed " << curl_easy_strerror(res) << endl;
}
else {
cout << " CALLBACK DONE" << endl;
curl_easy_cleanup(curl);
curl_slist_free_all(slist);
slist=NULL;
}
}//if curl
cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
curl_global_cleanup();
//cout << " //1// SHOW contentS " << endl;
//cout << contentsBS.c_str() << endl;
Json::Value parsedFromString;
Json::Reader reader;
bool parsingSuccessful;
Json::FastWriter fastWriter;
string globalBSZmqStream="";
//printf("value= %s\n", contentsBS.c_str());
if (contentsBS.size() > 2) {
parsingSuccessful=reader.parse(contentsBS.c_str(), parsedFromString);
if (parsingSuccessful) {
//Json::StyledWriter styledWriter;
//cout << "STYLED: --------------------------------" << endl;
//cout << styledWriter.write(parsedFromString) << endl;
//cout << "----------------------------------" << endl;
cout << parsedFromString["stream"] << endl;
cout << "----------------------------------" << endl;
globalBSZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
cout << globalBSZmqStream << endl;
if ( parsedFromString["stream"].isNull() ) {
globalBSZmqStream.clear();
}
}
else {
cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
cout << contentsBS.c_str() << endl;
cout << reader.getFormattedErrorMessages() << endl;
}
}
if (globalBSZmqStream.empty()) {
cout << "BS Data is not available " << endl;
return isBS=false;
}
context = zmq_ctx_new ();
//// receiver = zmq_socket (context, ZMQ_PULL);
//HWM has no effect for PULL
//See documentation on zmq-socket
//WHEN PUSH Sender reachers HWM, then it blocks
//// int nhwm=10;
//// zmq_setsockopt (receiver,ZMQ_RCVHWM ,&nhwm, sizeof(int));
// rc = zmq_bind (receiver, "tcp://129.129.145.206:5558"); //ZMQ_PULL
//// assert (rc == 0);
subscriber = zmq_socket (context, ZMQ_SUB);
globalBSZmqStream=globalBSZmqStream.substr(1,globalBSZmqStream.size()-3);
//cout << " globalBSZmqStream.c_str() " << globalBSZmqStream.c_str() << endl;
rc = zmq_connect (subscriber, (const char *) globalBSZmqStream.c_str());
if (rc != 0 ) {
cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
}
assert (rc == 0);
int nhwm=1;
int timeoutMS=200; //10; //-1 Wait for Ever
rc=zmq_setsockopt (subscriber,ZMQ_RCVHWM, &nhwm, sizeof(int));
assert (rc == 0);
rc=zmq_setsockopt (subscriber,ZMQ_RCVTIMEO, &timeoutMS, sizeof(int));
assert (rc == 0);
rc=zmq_setsockopt (subscriber,ZMQ_SUBSCRIBE,"",0);
assert (rc == 0);
BSInitialized=true;
}//is BS initialized
#endif //have zeromq
if(MUTEX){cafeMutex.unlock();}
return isBS=BSFlag;
#else //have curl
if(MUTEX){cafeMutex.unlock();}
return isBS=false;
#endif //have curl
}//isBSFlag
if(MUTEX){cafeMutex.unlock();}
return isBS=BSFlag;
} // setBS
};
/*
class RFData{
friend class CAFE;
private:
@@ -87,6 +395,8 @@ private:
std::vector<double> offs_x;
std::vector<double> offs_y;
unsigned long long pulse_id;
bool isAllXOK;
bool isAllYOK;
@@ -101,25 +411,23 @@ private:
size_t nDBPM;
size_t nPV;
bool isBS;
bool BSInitialized;
void *context;
void *receiver;
int rc;
#if HAVE_JSON
Json::Value parsedFromString;
Json::Reader reader;
bool parsingSuccessful;
#endif
bool parsingSuccessful;
public:
std::vector<DBPMData> getX() { return x;}
std::vector<DBPMData> getX() { return x;}
std::vector<DBPMData> getY() { return y;}
std::vector<DBPMData> getQ() { return q;}
std::vector<DBPMData> getEnergy() { return energy;}
@@ -135,7 +443,7 @@ public:
bool getIsAllOK() {return isAllOK;}
std::vector<std::string> getPV(){ return pv;}
std::vector<unsigned int> getHandle() { return handle;}
std::vector<unsigned int> getHandle() { return handle;}
std::vector<std::string> getDevice() { return device;}
std::vector<float> getS() { return s;}
size_t getNDBPM() {return nDBPM;}
@@ -143,17 +451,19 @@ public:
int getStatus() {return status;}
int getPVIdx(string _pv) {
for (size_t i=0; i< pv.size(); ++i) {
int getPVIdx(string _pv) {
for (size_t i=0; i< pv.size(); ++i) {
if ( pv[i].compare(_pv) == 0) {
return i;
return i;
}
}
return -1;
}
unsigned long long getPulse_id(){return pulse_id;}
void setPulse_id(unsigned long long _pulse_id){pulse_id=_pulse_id;}
PVDataHolder * pvd;
int status;
@@ -168,26 +478,15 @@ public:
void *subscriber;
//struct MemoryStruct {
// char *memory;
// size_t size;
//};
static size_t RecvResponseCallback(char * contents, size_t size, size_t nmemb, void * up) {
++nCBs;
cout << "Callback called: " << nCBs << endl;
///Json::Value parsedFromString;
///Json::Reader reader;
///bool parsingSuccessful;
///Json::FastWriter fastWriter;
cout << "SIZE No. of Bytes " << size*nmemb << endl;
//cout << "Callback called: " << nCBs << endl;
//cout << "SIZE No. of Bytes " << size*nmemb << endl;
string sLocal=contents;
//remove \n for newline
std::size_t found = sLocal.find('\n');
if (found != std::string::npos) {
@@ -196,86 +495,13 @@ public:
}
contentsS=contentsS+sLocal;
//if (nCBs%3==1) {
// return size*nmemb;
//}
//printf("value= %s\n", contents);
/*
if (contents != NULL) {
parsingSuccessful=reader.parse(contentsS.c_str(), parsedFromString);
if (parsingSuccessful) {
//Json::StyledWriter styledWriter;
cout << "STYLED: --------------------------------" << endl;
//cout << styledWriter.write(parsedFromString) << endl;
//cout << "----------------------------------" << endl;
cout << parsedFromString["stream"] << endl;
cout << "----------------------------------" << endl;
globalZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
cout << globalZmqStream << endl;
if ( parsedFromString["stream"].isNull() ) {
globalZmqStream.clear();
}
}
else {
cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
cout << reader.getFormattedErrorMessages() << endl;
}
}
contentsS="";
*/
/*
size_t realsize = size * nmemb;
struct MemoryStruct *mem = (struct MemoryStruct *)data;
mem->memory = (char *) realloc(mem->memory, (mem->size + realsize + 1));
if(mem->memory == NULL) {
printf("not enough memory (realloc returned NULL)\n");
return 0;
}
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
//return realsize;
printf("value= %s\n",mem->memory);
if (mem->memory != NULL) {
parsingSuccessful=reader.parse(mem->memory, parsedFromString);
if (parsingSuccessful) {
Json::StyledWriter styledWriter;
cout << "STYLED: --------------------------------" << endl;
cout << styledWriter.write(parsedFromString) << endl;
cout << "----------------------------------" << endl;
cout << parsedFromString["stream"] << endl;
cout << "----------------------------------" << endl;
}
}
*/
return (size_t) size * nmemb;
}
//
bool resetBS() {
bool resetBS() {
closeBS();
return setBS(true);
}
@@ -283,93 +509,50 @@ public:
bool setBS(bool BSFlag) {
if(MUTEX){cafeMutex.lock();}
if(MUTEX){cafeMutex.lock();}
if (BSFlag) {
#if HAVE_CURL
string dataChannels=string("{\"channels\":[");
vector<string> pvNew=pv;
#if HAVE_ZEROMQ
if (!BSInitialized) {
if (BSFlag) {
#if HAVE_CURL
/*
//Complete all or complete latest
//const char * data="{\"channels\":[{\"name\":\"S10BC01-DBPM010:X1\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}, \
{\"name\":\"S10BC01-DBPM010:X1-VALID\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0} \
],\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"adjust-global\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
*/
string dataChannels=string("{\"channels\":[");
vector<string> pvNew=pv;
#if HAVE_ZEROMQ
if (!BSInitialized) {
//pvNew.push_back("SINEG01-DBPM340:X1") ;
//pvNew.push_back("SINSB01-DBPM150:X1") ;
//pvNew.push_back("SINSB02-DBPM150:X1") ;
//pvNew.push_back("SINLH01-DBPM060:X1") ;
//pvNew.push_back("SINLH02-DBPM210:X1") ;
//pvNew.push_back("SINLH02-DBPM240:X1") ;
//pvNew.push_back("SINLH03-DBPM010:X1") ;
//pvNew.push_back("SINLH03-DBPM050:X1") ;
//pvNew.push_back("SINLH03-DBPM090:X1") ;
//pvNew.push_back("SINSB03-DBPM120:X1") ;
//pvNew.push_back("SINSB03-DBPM220:X1") ;
//pvNew.push_back("SINSB04-DBPM120:X1") ;
//pvNew.push_back("SINSB04-DBPM220:X1") ;
//pvNew.push_back("SINEG01-DBPM340:X1-VALID") ;
//pvNew.push_back("SINSB01-DBPM150:X1-VALID") ;
//pvNew.push_back("SINSB02-DBPM150:X1-VALID") ;
//pvNew.push_back("SINLH01-DBPM060:X1-VALID") ;
//pvNew.push_back("SINLH02-DBPM210:X1-VALID") ;
//pvNew.push_back("SINLH02-DBPM240:X1-VALID") ;
//pvNew.push_back("SINLH03-DBPM010:X1-VALID") ;
//pvNew.push_back("SINLH03-DBPM050:X1-VALID") ;
//pvNew.push_back("SINLH03-DBPM090:X1-VALID") ;
//pvNew.push_back("SINSB03-DBPM120:X1-VALID") ;
//pvNew.push_back("SINSB03-DBPM220:X1-VALID") ;
//pvNew.push_back("SINSB04-DBPM120:X1-VALID") ;
//pvNew.push_back("SINSB04-DBPM220:X1-VALID") ;
size_t found;
dataChannels= dataChannels + string("{\"name\":\"");
dataChannels= dataChannels + pvNew[0];
//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}" );
dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}" );
dataChannels= dataChannels + string("{\"name\":\"");
dataChannels= dataChannels + pvNew[0];
//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}" );
dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}" );
for (size_t i=1; i < pvNew.size(); ++i) {
found = pvNew[i].find("SARUN08-DBPM210");
found = pvNew[i].find("SARUN08-DBPM210");
if (found != std::string::npos) continue;
found = pvNew[i].find("SARUN08-DBPM410");
if (found != std::string::npos) continue;
//found = pvNew[i].find("Y1");
//if (found != std::string::npos) continue;
//found = pvNew[i].find("X1");
//if (found != std::string::npos) continue;
found = pvNew[i].find("ENERGY");
if (found != std::string::npos) continue;
dataChannels= dataChannels + string(",{\"name\":\"");
dataChannels= dataChannels + string(",{\"name\":\"");
dataChannels= dataChannels + pvNew[i];
//found = pv[i+1].find("ENERGY");
//if (found != std::string::npos) break;
//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}");
dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}");
}
//dataChannels= dataChannels + string("{\"name\":\"");
//dataChannels= dataChannels + pv[pv.size()-1];
//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}],");
dataChannels= dataChannels + string("],");
dataChannels= dataChannels + "\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"keep-as-is\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
dataChannels= dataChannels + string("],");
dataChannels= dataChannels + "\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"keep-as-is\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
cout << dataChannels << endl;
//sleep(1);
const char * data = dataChannels.c_str();
///cout << "SIZE OF DATA --------------->" << sizeof(data) << endl;
CURL *curl;
@@ -379,27 +562,22 @@ if (!BSInitialized) {
slist = curl_slist_append(slist, "Content-Type: application/json");
curl_global_init(CURL_GLOBAL_ALL);
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
if (curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://dispatcher-api.psi.ch/sf/stream");
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); //"-F file=@./request.json"); //data); //
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); //"-F file=@./dbpm.json"); //data); //
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
cout << "WAITING FOR CALLBACK " << endl;
//cout << "WAITING FOR CALLBACK... " << endl;
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &RecvResponseCallback);
res = curl_easy_perform(curl);
@@ -407,148 +585,122 @@ if (!BSInitialized) {
cout << "curl_easy_perform failed " << curl_easy_strerror(res) << endl;
}
else {
cout << " CALLBACK DONE" << endl;
cout << " CALLBACK DONE" << endl;
cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
curl_easy_cleanup(curl);
curl_easy_cleanup(curl);
curl_slist_free_all(slist);
cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
curl=NULL;
curl_slist_free_all(slist);
cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
slist=NULL;
slist=NULL;
}
}
}//if curl
cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
curl_global_cleanup();
#endif
//cout << " //1// SHOW contentS " << endl;
//cout << contentsS.c_str() << endl;
//sleep(1);
Json::Value parsedFromString;
Json::Reader reader;
bool parsingSuccessful;
Json::FastWriter fastWriter;
string globalZmqStream;
//printf("value= %s\n", contentsS.c_str());
if (contentsS.size() > 2) {
parsingSuccessful=reader.parse(contentsS.c_str(), parsedFromString);
if (parsingSuccessful) {
//Json::StyledWriter styledWriter;
cout << "STYLED: --------------------------------" << endl;
//cout << styledWriter.write(parsedFromString) << endl;
//cout << "----------------------------------" << endl;
cout << parsedFromString["stream"] << endl;
parsingSuccessful=reader.parse(contentsS.c_str(), parsedFromString);
if (parsingSuccessful) {
//Json::StyledWriter styledWriter;
cout << "STYLED: --------------------------------" << endl;
//cout << styledWriter.write(parsedFromString) << endl;
//cout << "----------------------------------" << endl;
cout << parsedFromString["stream"] << endl;
cout << "----------------------------------" << endl;
globalZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
cout << globalZmqStream << endl;
cout << "----------------------------------" << endl;
globalZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
cout << globalZmqStream << endl;
if ( parsedFromString["stream"].isNull() ) {
globalZmqStream.clear();
}
if ( parsedFromString["stream"].isNull() ) {
globalZmqStream.clear();
}
else {
cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
cout << contentsS.c_str() << endl;
cout << reader.getFormattedErrorMessages() << endl;
}
else {
cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
cout << contentsS.c_str() << endl;
cout << reader.getFormattedErrorMessages() << endl;
}
}
}
if (globalZmqStream.empty()) {
cout << "BS Data is not available " << endl;
return isBS=false;
}
//
//#if HAVE_ZEROMQ
//if (!BSInitialized) {
cout << "TESTING STREAM... " << endl;
context = zmq_ctx_new ();
if (globalZmqStream.empty()) {
cout << "BS Data is not available " << endl;
return isBS=false;
}
// else {
// cout << globalZmqStream.c_str() << " is not empty " << endl;
// }
context = zmq_ctx_new ();
/// receiver = zmq_socket (context, ZMQ_PULL);
//HWM has no effect for PULL
//See documentation on zmq-socket
//WHEN PUSH Sender reachers HWM, then it blocks
/// int nhwm=10;
/// zmq_setsockopt (receiver,ZMQ_RCVHWM ,&nhwm, sizeof(int));
//rc = zmq_bind (receiver, "tcp://129.129.145.206:5558"); //ZMQ_PULL
/// rc = zmq_bind (receiver, "tcp://SIN-CVME-DBPM0421:9000");
/// assert (rc == 0);
subscriber = zmq_socket (context, ZMQ_SUB);
//rc = zmq_connect (subscriber, "tcp://129.129.145.206:5556");
//rc = zmq_connect (subscriber, "tcp://SIN-CVME-DBPM0421:9000");
globalZmqStream=globalZmqStream.substr(1,globalZmqStream.size()-3);
//cout << " globalZmqStream.c_str() " << globalZmqStream.c_str() << endl;
//sleep(1);
rc = zmq_connect (subscriber, (const char *) globalZmqStream.c_str()); // "tcp://sf-daqbuf-28.psi.ch:42465"); // //"tcp://sf-daqbuf-30.psi.ch:39927");
if (rc != 0 ) {
cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
}
//rc = zmq_connect (subscriber, "tcp://*:9999");
assert (rc == 0);
int nhwm=1;
int timeoutMS=400; //10; //-1 Wait for Ever
rc=zmq_setsockopt (subscriber,ZMQ_RCVHWM ,&nhwm, sizeof(int));
assert (rc == 0);
rc=zmq_setsockopt (subscriber,ZMQ_RCVTIMEO ,&timeoutMS, sizeof(int));
assert (rc == 0);
//// receiver = zmq_socket (context, ZMQ_PULL);
//HWM has no effect for PULL
//See documentation on zmq-socket
//WHEN PUSH Sender reachers HWM, then it blocks
//// int nhwm=10;
//// zmq_setsockopt (receiver,ZMQ_RCVHWM ,&nhwm, sizeof(int));
// rc = zmq_bind (receiver, "tcp://129.129.145.206:5558"); //ZMQ_PULL
//// assert (rc == 0);
rc=zmq_setsockopt (subscriber,ZMQ_SUBSCRIBE,"",0);
assert (rc == 0);
subscriber = zmq_socket (context, ZMQ_SUB);
//rc = zmq_connect (subscriber, "tcp://129.129.145.206:5556");
//rc = zmq_connect (subscriber, "tcp://SIN-CVME-DBPM0421:9000");
globalZmqStream=globalZmqStream.substr(1,globalZmqStream.size()-3);
//cout << " globalZmqStream.c_str() " << globalZmqStream.c_str() << endl;
rc = zmq_connect (subscriber, (const char *) globalZmqStream.c_str()); //"tcp://sf-daqbuf-30.psi.ch:39927");
if (rc != 0 ) {
cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
}
//rc = zmq_connect (subscriber, "tcp://*:9999");
assert (rc == 0);
int nhwm=1;
int timeoutMS=200; //10; //-1 Wait for Ever
rc=zmq_setsockopt (subscriber,ZMQ_RCVHWM, &nhwm, sizeof(int));
assert (rc == 0);
rc=zmq_setsockopt (subscriber,ZMQ_RCVTIMEO, &timeoutMS, sizeof(int));
assert (rc == 0);
rc=zmq_setsockopt (subscriber,ZMQ_SUBSCRIBE,"",0);
assert (rc == 0);
BSInitialized=true;
}
BSInitialized=true;
}//is BS initialized
#endif //have zeromq
if(MUTEX){cafeMutex.unlock();}
return isBS=BSFlag;
#else
#else //have curl
if(MUTEX){cafeMutex.unlock();}
return isBS=false;
#endif
}
#endif //have curl
}//isBSFlag
if(MUTEX){cafeMutex.unlock();}
return isBS=BSFlag;
}
if(MUTEX){cafeMutex.unlock();}
return isBS=BSFlag;
} // setBS
bool setCA(bool CAFlag) {
return CAFlag;
}
@@ -582,13 +734,13 @@ if (!BSInitialized) {
s.push_back(pos->first); device.push_back(pos->second);
}
pvd = new PVDataHolder[handle.size()];
pvd = new PVDataHolder[handle.size()];
//for (int i=0; i< handle.size(); ++i) {
// pvd[i].setNelem(1);
//}
nDBPM=device.size();
nDBPM=device.size();
nPV=_pv.size();
status=ICAFE_NORMAL;
@@ -612,13 +764,13 @@ if (!BSInitialized) {
device.assign(_dev.begin(), _dev.end());
s.assign(_pos.begin(), _pos.end());
pvd = new PVDataHolder[handle.size()];
pvd = new PVDataHolder[handle.size()];
//for (int i=0; i< handle.size(); ++i) {
// pvd[i].setNelem(1);
//}
nDBPM=device.size();
nDBPM=device.size();
nPV=_pv.size();
status=ICAFE_NORMAL;

6
include/channelRegalia.h
View File

@@ -38,7 +38,7 @@ public:
friend struct change_connectionHandlerArgs;
friend struct change_eventHandlerArgs;
//friend struct change_channelRegalia;
//friend class Connect;
friend class Connect;
friend class HandleHelper;
friend class Conduit;
friend class ConduitGroup;
@@ -64,8 +64,8 @@ protected:
void setReadAccess (unsigned short r){accessRead=r;};
void setWriteAccess(unsigned short w){accessWrite=w;};
void setNelem (unsigned int n) {nelem=n;};
void setConnectionState (long cs) {connectionState=cs;};
void setCafeConnectionState (long ccs) {cafeConnectionState=ccs;};
void setConnectionState (int cs) {connectionState=cs;};
void setCafeConnectionState (int ccs) {cafeConnectionState=ccs;};
public:
chid getChannelID() const {return channelID;};

1
include/conduitConnectionHandlerArgs.h
View File

@@ -240,6 +240,7 @@ struct change_connectionHandlerArgs
c.channelRegalia.cafeConnectionState =ICAFE_CS_DISCONN;
c.channelRegalia.connectFlag = false;
c.status = ICAFE_CA_OP_CONN_DOWN;
}

2
include/conduitGroup.h
View File

@@ -59,6 +59,7 @@ public:
bool * mRule;
unsigned int * mHandle;
virtual ~ConduitGroup();
@@ -80,6 +81,7 @@ public:
unsigned int getGroupHandle(void) const {return groupHandle;};
ChannelTimeoutPolicy getChannelTimeoutPolicySGPut(void) const {return channelTimeoutPolicySGPut;};
ChannelTimeoutPolicy getChannelTimeoutPolicySGGet(void) const {return channelTimeoutPolicySGGet;};
};

146
include/connect.h
View File

@@ -25,6 +25,8 @@
#include <policyHelper.h>
#include <hashConduitGroup.h>
#include <boost/date_time/posix_time/posix_time.hpp>
#if HAVE_BOOST_THREAD
#include <boost/thread/thread_only.hpp>
#include <boost/chrono.hpp>
@@ -51,7 +53,7 @@ class Connect
ExceptionsHelper exceptionsHelper;
ChannelCreatePolicy channelCreatePolicy;
PolicyHelper policyHelper;
HandleHelper handleHelper;
@@ -94,11 +96,17 @@ class Connect
channelOpenGroupPolicy.setPolicy(
CAFENUM::FLUSH_AFTER_EACH_GROUP_CREATION,
CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_SG_PEND_EVENT);
CAFENUM::WITH_POLL, DEFAULT_TIMEOUT_SG_PEND_EVENT);
//CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_SG_PEND_EVENT);
channelOpenPolicy.setPolicy(
CAFENUM::FLUSH_AFTER_EACH_CHANNEL_CREATION,
CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_PEND_EVENT);
CAFENUM::WITH_POLL, DEFAULT_TIMEOUT_PEND_EVENT);
//CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_PEND_EVENT);
channelClosePolicy.setPolicy(
CAFENUM::FLUSH_AFTER_EACH_CHANNEL_CREATION,
CAFENUM::WITH_PEND_IO, DEFAULT_TIMEOUT_PEND_IO);
deviceAttributeDeliminator=DEFAULT_DEVICE_ATTRIBUTE_DELIMINATOR;
@@ -113,6 +121,8 @@ class Connect
PrintErrorPolicy printErrorPolicy;
ChannelCreatePolicy channelCreatePolicy;
ChannelOpenPolicy channelOpenPolicy;
ChannelOpenPolicy channelClosePolicy; //can also use for close
ChannelOpenPolicy channelMonitorPolicy;
@@ -148,7 +158,6 @@ class Connect
CAFEGlobalAlarmCondition getEpicsAlarmCondition() {return epicsAlarmStatus;}
CAFEGlobalAlarmSeverity getEpicsAlarmSeverity() {return epicsAlarmSeverity;}
int flushNow() {return ca_flush_io();}
int _ca_flush_io(){return ca_flush_io();}
@@ -191,39 +200,49 @@ class Connect
void openGroupPrepare(){
channelOpenGroupPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
channelOpenGroupPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
return;
}
void openMonitorPrepare(){
channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO);
channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
void openGroupNowAndWait(double _timeout);
void openGroupNowAndWaitForInputGroups(double _timeout, vector<unsigned int> gHandles);
//Pends for default amount of time
void openGroupNow() {
openGroupNowAndWait(channelOpenGroupPolicy.getTimeout());
return;
}
//Same as above - change nanmin convetnion
void groupOpenPrepare(){
channelOpenGroupPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
return;
}
void groupOpenNowAndWait(double _timeout) { openGroupNowAndWait(_timeout); return; };
void groupOpenNowAndWait(double _timeout, vector<unsigned int> gH)
{ openGroupNowAndWaitForInputGroups(_timeout, gH); return; };
//Pends for default amount of time
void groupOpenNow() {
openGroupNowAndWait(channelOpenGroupPolicy.getTimeout());
return;
}
//-------------------------------------------------------------------------
void openMonitorPrepare(){
channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO);
return;
}
double setOpenDefaultPendTime(double _timeout){
return channelOpenPolicy.setDefaultTimeout(_timeout);
}
double getOpenDefaultPendTime(){
return channelOpenPolicy.getDefaultTimeout();
}
void openGroupNowAndWait(double _timeout){
double dto = channelOpenGroupPolicy.getTimeout();
channelOpenGroupPolicy.setTimeout(_timeout);
channelOpenGroupPolicy.flushSendBufferNow();
//
//reset
channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
channelOpenGroupPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
//channelOpenGroupPolicy.setTimeoutToDefault();
channelOpenGroupPolicy.setTimeout(dto);
return;
}
void openMonitorNow(){
channelMonitorPolicy.flushSendBufferNow();
//reset
@@ -233,44 +252,57 @@ class Connect
}
void openMonitorNowAndWait(double _timeout){
channelMonitorPolicy.setTimeout(_timeout);
channelMonitorPolicy.setTimeout(_timeout);
channelMonitorPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
channelMonitorPolicy.flushSendBufferNow();
//reset
channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO);
return;
}
//------------------------------------------------------------------------
double setOpenDefaultPendTime(double _timeout){
return channelOpenPolicy.setDefaultTimeout(_timeout);
}
double getOpenDefaultPendTime(){
return channelOpenPolicy.getDefaultTimeout();
}
//------------------------------------------------------------------------
void openPrepare() {
channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
channelOpenPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
return;
}
void openNowAndWait(double _timeout) {
double dto = channelOpenPolicy.getTimeout();
channelOpenPolicy.setTimeout(_timeout);
channelOpenPolicy.flushSendBufferNow();
//reset
channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
//channelOpenPolicy.setTimeoutToDefault();
channelOpenPolicy.setTimeout(dto);
return;
}
void openNow() {
channelOpenPolicy.flushSendBufferNow();
channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
return;
}
//Same as openPrepare
void openNoWait(){
channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
return;
}
//Pends for a maximimum of timeout seconds
void openNowAndWait(double _timeout);
//Pends for default amount of time
void openNow() {
openNowAndWait(channelOpenPolicy.getTimeout());
/*
channelOpenPolicy.flushSendBufferNow();
//reset
channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
channelOpenPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
*/
return;
}
//-------------------------------------------------------------------------
bool initCallbackComplete(vector<unsigned int> hV) {
return initCallbackComplete(&hV[0], hV.size());
@@ -292,9 +324,7 @@ class Connect
void printCAFEException_pv(CAFEException_pv & e){exceptionsHelper.printCAFEException_pv(e);};
//closeChannel(s) only close within a context
int closeChannels(unsigned int * handleArray, unsigned int nHandles);
@@ -329,6 +359,12 @@ class Connect
int closeHandles(unsigned int * handleArray, unsigned int nHandles);
int closeHandle(unsigned int handle);
int closeHandles();
//Close Channel Keep Handle
int closeChannelKeepHandle(unsigned int handle);
int closeChannelsKeepHandles(unsigned int * handleArray, unsigned int nHandles);
int closeChannelsKeepHandlesV(vector<unsigned int> v){ return closeChannelsKeepHandles(&v[0], v.size());}
int closeChannelsKeepHandles (vector<unsigned int> v){ return closeChannelsKeepHandles(&v[0], v.size());}
// Monitors
int monitorStart(unsigned int handle, MonitorPolicy &mp);

4
include/defines.h
View File

@@ -55,7 +55,7 @@ typedef char pv_string_t[PVNAME_SIZE];
const bool DEFAULT_SELF_GOVERNING_TIMEOUT = true;
const double DEFAULT_TIMEOUT_PEND_IO_WF = 5.0;
const double TIMEOUT_PEND_IO_MIN = 0.00001;
const double TIMEOUT_PEND_IO_MIN = 0.0001;
const double TIMEOUT_PEND_IO_MAX = 20.0; // max timeout for first attempt (ntries=1)
const unsigned short DEFAULT_PEND_IO_NO_TRIES = 2;
const unsigned short PEND_IO_MAX_TRIES = 10; // safety net
@@ -63,7 +63,7 @@ const double DEFAULT_PEND_IO_INCREMENT_TIME = 2.0;
const double PEND_IO_INCREMENT_TIME_MIN= 0.05;
const double PEND_IO_INCREMENT_TIME_MAX= 10.0;
const double DEFAULT_TIMEOUT_PEND_EVENT = 0.4;
const double DEFAULT_TIMEOUT_PEND_IO = 3.0;
const double DEFAULT_TIMEOUT_PEND_IO = 0.4; // previously 3.0
const double DEFAULT_TIMEOUT_SG_PEND_EVENT = 0.5; // plus nMember/NMEMBER_PER_SEC_SG_PEND_EVENT
const double NMEMBER_PER_SEC_SG_PEND_EVENT = 400; //
const double DEFAULT_TIMEOUT_SG_PEND_IO = 5.0;

6
include/global.h
View File

@@ -20,6 +20,9 @@
extern bool CHECK_CONSISTENCY_CA_STATE;
extern bool MUTEX;
extern epicsMutex cafeMutex;
extern cafeConduit_set cs;
extern cafeGroup_set gs;
extern vector<PVGroup> PVGroupV;
@@ -29,8 +32,9 @@ extern map<vector<unsigned int>, string> groupPseudoMap;
extern vector<string> globalChannelList;
extern string globalZmqStream;
extern string contentsS;
extern string contentsBS;
extern unsigned long nCBs;
#endif // GLOBAL_H

5
include/handleHelper.h
View File

@@ -86,6 +86,8 @@ class HandleHelper : public Helper {
vector<unsigned int> getHandlesFromPVs(vector<string> pvV, ca_client_context * ccc);
vector<unsigned int> getHandlesFromPVs(vector<string> pvV);
vector<unsigned int> getDisconnectedHandlesFromWithinGroupV(unsigned int gh);
vector<unsigned int> getHandlesFromWithinGroupV(unsigned int gh);
unsigned int * getHandlesFromWithinGroup(unsigned int gh);
@@ -167,6 +169,9 @@ class HandleHelper : public Helper {
unsigned int getNextFreeHandle();
bool isChannelConnected(unsigned int handle);
bool allChannelsConnected();
bool allChannelsWithinGroupConnected();
bool allChannelsWithinGroupConnectedV(vector<unsigned int>);
int printHandle (unsigned int h);
int printHandlesV(vector<unsigned int> handleV);

589
include/instant.cpp
View File

@@ -237,6 +237,11 @@ template <class CTYPE> int Instant<CTYPE>::getCache(const unsigned int _handle
return ICAFE_CS_NEVER_CONN;
}
else if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_CLOSED) {
return ICAFE_CS_CLOSED;
}
if (_dbrType > DBR_CTRL_DOUBLE) {
@@ -764,15 +769,15 @@ template <class CTYPE> int Instant<CTYPE>::clientRequests(
if (it_handle != handle_index.end()) {
//union db_access_val * PVDataL;
//unsigned int nelem;
//chtype dbrTypeRequest_DataBuffer;
union db_access_val * PVDataL;
unsigned int nelem;
//unsigned int offset;
chtype dbrTypeRequest_DataBuffer;
//PVDataL = (*it_handle).getPutBuffer ();
//nelem = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
PVDataL = (*it_handle).getPutBuffer ();
nelem = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
//dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
switch(_dbrType) {
case DBR_STRING:
@@ -805,7 +810,15 @@ template <class CTYPE> int Instant<CTYPE>::clientRequests(
return ECAFE_INVALID_SWITCH_CASE;
break;
}
/*
epicsTimeStamp ts;
ts.secPastEpoch= 0; // default value if cache does not have timeStamp
ts.nsec = 0; // default value if cache does not have timeStamp
dbr_short_t alarmStatus =-1; // default value if cache does not have alarmStatus
dbr_short_t alarmSeverity =-1; // default value if cache does not have alarmSeverity
//helper function to set TimeStamps!
helper.setSTS(_handle, alarmStatus, alarmSeverity, ts);
*/
}
else {
@@ -876,6 +889,549 @@ template <class CTYPE> int Instant<CTYPE>::setAndGet(const unsigned int handleS
template <class CTYPE> int Instant<CTYPE>::setMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, bool printFlag) {
#define __METHOD__ "Instant<CTYPE>::setMany(vector<unsigned int>handleSet, chtype, vector<CTYPE>valSet)"
CAFEStatus cstat;
CTYPE valSetA[1];
status=ICAFE_NORMAL;
if (handleSet.size() != valSet.size() ) {
return ECAFE_HANDLE_MISMATCH_SET_AND_MATCH;
}
for (size_t i=0; i< handleSet.size(); ++i) {
if (!helper.isChannelConnected(handleSet[i])) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "NOT ALL CHANNELS CONNECTED: " << endl;
if (!helper.isChannelConnected(handleSet[i])) {
helper.printHandle(handleSet[i]);
status=helper.getStatus(handleSet[i]);
}
}
}
if (status!=ICAFE_NORMAL) {return status;}
if(printFlag) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
}
if (printFlag) {
for (size_t i=0; i< handleSet.size(); ++i) {
if (dbrType==DBR_CHAR) {
cout << "SETTING PV=" << helper.getPVFromHandle(handleSet[i]) << " to " << (unsigned short) valSet[i] << endl;
}
else {
cout << "SETTING PV=" << helper.getPVFromHandle(handleSet[i]) << " to " << valSet[i] << endl;
}
} //for
} //if
for (size_t i=0; i< handleSet.size(); ++i) {
//set No of Elements to 1
unsigned int nelemPrevious, nelemRequestedCheck=0;
unsigned int nelemRequested=1;
nelemPrevious=helper.getNelemClient(handleSet[i]);
//Check the number of elements requested?
if (nelemPrevious>1) {
nelemRequestedCheck = helper.setNelem(handleSet[i],nelemRequested);
if (nelemRequestedCheck != nelemRequested) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
<< nelemPrevious << endl;
cout << "to: " << nelemRequested << " but got instead: "
<< nelemRequestedCheck << endl;
}
}
//policy set synchronous
ChannelRequestPolicy polPrevious, polNow;
policyHelper.getChannelRequestPolicyPut(handleSet[i], polPrevious);
polNow.setMethodKind(WITHOUT_CALLBACK);
polNow.setWaitKind(WAIT);
polNow.setWhenToFlushSendBuffer(FLUSH_AUTOMATIC);
policyHelper.setChannelRequestPolicyPut(handleSet[i], polNow);
valSetA[0] = (CTYPE) valSet[i];
status=set(handleSet[i], dbrType, valSetA);
if (status!=ICAFE_NORMAL) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cstat.report(status);
}
policyHelper.setChannelRequestPolicyPut(handleSet[i], polPrevious);
unsigned int nelemPreviousCheck=nelemPrevious;
nelemRequested=1;
//Switch back to previous value
//if (nelemPrevious>1) {
if(helper.getNelemRequest(handleSet[i])!= nelemPrevious) {
nelemPreviousCheck= helper.setNelem(handleSet[i],nelemPrevious);
if (nelemPreviousCheck != nelemPrevious) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to re-set the no. elements from: "
<< nelemRequested << endl;
cout << "to the previous: " << nelemPrevious << " but got instead: "
<< nelemPreviousCheck << endl;
}
}
} //for size_t
return status;
}
#undef __METHOD__
/**
* \brief Set Channels followed by a corresponding readback of Channels \n
* Method verifies whether or not the set/readback values agree within the given tolerance and timeout \n
* Method returns with ECA_NORMAL as soon as a match is reached
* \param handleSet input: vector of handleSet
* \param dbrType input: chtype of set value
* \param valSet input: vector of CTYPE values to set
* \param handleMatch input: vector of handles of readback channel
* \param tolerance input: CTYPE of tolerance margin
* \param timeout input: double value; maximum time allowed for agreement to occur
* \param printFlag input: bool, set to true for diagnostics
* \return ECA_NORMAL if all OK, else first ECAFE error encountered, else ECAFE_TIMEOUT_SET_AND_MATCH
*/
template <class CTYPE> int Instant<CTYPE>::compareAndMatchMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch,
CTYPE tolerance, double timeout, bool printFlag){
//template <class CTYPE> int Instant<CTYPE>::setTriggerAndMatchMany(vector<unsigned int> handleSet, chtype dbrType, vector<CTYPE> valSet,
// vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
// CTYPE tolerance, double timeout, bool printFlag){
#define __METHOD__ "Instant<CTYPE>::compareAndMatchMany(chtype, vector<CTYPE>valSet, vector<unsigned int>handleMatch, tolerance, timeout, printFlag)"
Connect connect;
CAFEStatus cstat;
CTYPE valGetA[1]; //CTYPE valSetA[1];
status=ICAFE_NORMAL;
if (handleMatch.size() != valSet.size() ) {
return ECAFE_HANDLE_MISMATCH_SET_AND_MATCH;
}
for (size_t i=0; i< handleMatch.size(); ++i) {
if (!helper.isChannelConnected(handleMatch[i])) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "NOT ALL CHANNELS CONNECTED: " << endl;
if (!helper.isChannelConnected(handleMatch[i])) {helper.printHandle(handleMatch[i]); status=helper.getStatus(handleMatch[i]);}
}
}
if (status!=ICAFE_NORMAL) {return status;}
if(printFlag) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
}
if (printFlag) {
for (size_t i=0; i< handleMatch.size(); ++i) {
if (dbrType==DBR_CHAR) {
cout << "SETTING PV= " << helper.getPVFromHandle(handleSet[i]) << " to " << (unsigned short) valSet[i] << endl;
}
else {
cout << "SETTING PV= " << helper.getPVFromHandle(handleSet[i]) << " to " << valSet[i] << endl;
}
cout << "READBACK PV=" << helper.getPVFromHandle(handleMatch[i])
<< " tolerance= " << fabs( (double) tolerance) << endl;
cout << "TIME ALLOWED FOR MATCH IS " << timeout << " (sec) " << endl;
} //for
} //if
vector<CTYPE> valSetUpper; vector<CTYPE> valSetLower;
vector<unsigned int> monitorID;
vector<int> statMonitor;
vector<unsigned short> nMonitors;
vector<CTYPE> valGet;
vector<unsigned int> nelemPreviousCache;
valSetUpper.reserve( valSet.size());
valSetLower.reserve( valSet.size());
monitorID.reserve( valSet.size());
statMonitor.reserve( valSet.size());
valGet.reserve( valSet.size());
nMonitors.reserve( valSet.size() );
nelemPreviousCache.reserve( valSet.size());
for (size_t i=0; i< valSet.size(); ++i) {
switch (dbrType) {
case DBR_LONG :
case DBR_SHORT :
case DBR_ENUM:
valSetUpper[i] = valSet[i] + abs((int)tolerance);
valSetLower[i] = valSet[i] - abs((int)tolerance);
break;
case DBR_CHAR :
valSetUpper[i] = (unsigned short) valSet[i] + abs((unsigned short) tolerance);
valSetLower[i] = (unsigned short) valSet[i] - abs((unsigned short) tolerance);
break;
case DBR_FLOAT:
case DBR_DOUBLE:
default:
valSetUpper[i] = (CTYPE) (valSet[i] + fabs((double)tolerance));
valSetLower[i] = (CTYPE) (valSet[i] - fabs((double)tolerance));
break;
}
vector<MonitorPolicy> mpVMatch;
mpVMatch.clear();
helper.getMonitorPolicyVector(handleMatch[i], mpVMatch);
nMonitors[i]=mpVMatch.size();
monitorID[i]=0;
////valGetA[0][i]=0;
valGet[i]=0;
statMonitor[i]=ICAFE_NORMAL;
}
for (size_t i=0; i< handleMatch.size(); ++i) {
//what is monitorpolicy??
if (nMonitors[i]==0) {
unsigned int _nelemPrevious, _nelemRequestedCheck=0;
unsigned int _nelemRequested=1;
_nelemPrevious=helper.getNelemClient(handleMatch[i]);
//Check the number of elements requested?
if (_nelemPrevious>1) {
_nelemRequestedCheck = helper.setNelem(handleMatch[i],_nelemRequested);
if (_nelemRequestedCheck != _nelemRequested) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
<< _nelemPrevious << endl;
cout << "to: " << _nelemRequested << " but got instead: "
<< _nelemRequestedCheck << endl;
}
}
//first do get to update cache before monitor starts
status=Instant::get(handleMatch[i], dbrType, valGetA);
valGet[i]=valGetA[0];
if (_nelemPrevious>1) {
helper.setNelem(handleMatch[i],_nelemPrevious);
}
if (status!=ICAFE_NORMAL) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cstat.report(status);
}
ChannelWhenToFlushSendBufferPolicyKind whenKind=
connect.channelMonitorPolicy.getWhenToFlushSendBuffer();
connect.channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_AUTOMATIC);
statMonitor[i]=connect.monitorStart(handleMatch[i], monitorID[i]);
if (statMonitor[i]!=ICAFE_NORMAL) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cstat.report(statMonitor[i]);
}
else {
if(printFlag) {cout << "MONITOR NOW IN PLACE FOR READBACK CHANNEL " << helper.getPVFromHandle(handleMatch[i]) << " WITH ID=" << monitorID[i] << endl;}
}
//revert to previous
if (whenKind != FLUSH_AUTOMATIC) {
connect.channelMonitorPolicy.setWhenToFlushSendBuffer(whenKind);
}
} //if nMonitors
//No of elements to get from Cache
//unsigned int nelemPreviousCheck=0;
unsigned int nelemRequested=1; unsigned int nelemRequestedCheck=0;
nelemPreviousCache[i]=helper.getNelemRequest(handleMatch[i]);
//Check the number of elements requested
//See set and Match; this needs to be checked
//Avoid problem when readback channel is the very same as the set(!)
if (nelemPreviousCache[i]>0 && helper.getNelemNative(handleMatch[i])>1) {
nelemRequestedCheck = helper.setNelemToRetrieveFromCache(handleMatch[i],nelemRequested);
if (nelemRequestedCheck != nelemRequested) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
<< nelemPreviousCache[i] << endl;
cout << "to: " << nelemRequested << " but got instead: "
<< nelemRequestedCheck << endl;
}
}
} //for size_t
//start time
double timeElapsed=0; double timeElapsed2=0;
double timeElapsedBase=0;
using namespace boost::posix_time;
ptime timeStart(microsec_clock::local_time());
for (size_t i=0; i< handleMatch.size(); ++i) {
valGetA[0]=0;
status=Instant::getCache(handleMatch[i], dbrType, valGetA);
valGet[i]=valGetA[0];
if (status !=ICAFE_NORMAL) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cstat.report(status);
}
///valGet[i]=valGetA[0][i];
if (dbrType==DBR_CHAR) {valGet[i] = (unsigned short) valGetA[0];}
if(printFlag) {
//cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
if (dbrType==DBR_CHAR) {
cout << "Current Cached Value = " << (unsigned short) valGet[i] << endl;
cout << "Lower/Upper Target Values = " << (unsigned short) valSetLower[i] << " and " << (unsigned short) valSetUpper[i] << endl;
}
else {
cout << "Current Cached Value = " << valGet[i] << endl;
cout << "Lower/Upper Target Values = " << valSetLower[i] << " and " << valSetUpper[i] << endl;
}
}
} //for size_t
ptime timeEnd(microsec_clock::local_time());
time_duration duration(timeEnd-timeStart);
timeElapsed= (double) duration.total_microseconds()/1000000.0;
for (size_t i=0; i< valSet.size(); ++i) {
while ( (valGet[i]>valSetUpper[i] || valGet[i]<valSetLower[i] )
&& timeElapsed < timeout ) {
valGetA[0]=0;
status=Instant::getCache(handleMatch[i], dbrType, valGetA);
valGet[i]=valGetA[0];
//cout <<"Cached value " << valGet[i] << endl;
if (dbrType==DBR_CHAR) {valGet[i] = (unsigned short) valGetA[0];}
//cout << valSetUpper[i] << " U/L " << valSetLower[i] << endl;
ptime timeEnd(microsec_clock::local_time());
time_duration duration(timeEnd-timeStart);
timeElapsed= (double) duration.total_microseconds()/1000000.0;
timeElapsed2=timeElapsed-timeElapsedBase;
if (printFlag && timeElapsed2>1 && status==ICAFE_NORMAL) {
for (size_t ij=0; ij< handleMatch.size(); ++ij) {
status=Instant::getCache(handleMatch[ij], dbrType, valGetA);
valGet[ij]=valGetA[0];
if (valGet[ij]>valSetUpper[ij] || valGet[ij]<valSetLower[ij]) {
if (dbrType==DBR_CHAR) {
cout << "REPORTING " << helper.getPVFromHandle(handleSet[ij])
<< " SET VALUE=" << (unsigned short) valSet[ij]
<< "; READBACK " << helper.getPVFromHandle(handleMatch[ij])
<< " HAS CURRENT VALUE=" << (unsigned short) valGet[ij]
<< " TimeElapsed " << timeElapsed << " (sec) " << endl;
}
else {
cout << "REPORTING " << helper.getPVFromHandle(handleSet[ij])
<< " SET VALUE=" << valSet[ij]
<< "; READBACK " << helper.getPVFromHandle(handleMatch[ij])
<< " HAS CURRENT VALUE=" << valGet[ij]
<< " TimeElapsed " << timeElapsed << " (sec) " << endl;
}
}
}
timeElapsedBase=timeElapsed;
//cout << "REPORTING ON CHANNEL " << helper.getPVFromHandle(handleSet[i]) << " SET VALUE=" << valSet[i] << " // CURRENT READBACK VALUE=" << valGet[i]
// << " TimeElapsed " << timeElapsed << " (sec) " << endl;
//timeElapsedBase=timeElapsed;
}
#if HAVE_BOOST_THREAD
boost::this_thread::sleep_for(boost::chrono::microseconds(20));
#else
#if HAVE_LINUX
usleep(20);
#endif
#endif
}
} //for size_t
if (timeout <=timeElapsed ) {
cout << "*****TIMEOUT REACHED****** AFTER " << timeout << " (sec) " << endl;
cout << "*****NOT ALL READBACK CHANNELS REACHED THEIR DESIRED VALUES WITHIN THE GIVEN TOLERANCE AND TIME PERIOD*****" << endl;
status=ECAFE_TIMEOUT_SET_AND_MATCH;
}
else {
if (printFlag) {
for (size_t i=0; i< handleMatch.size(); ++i) {
valGetA[0]=0;
status=Instant::getCache(handleMatch[i], dbrType, valGetA);
valGet[i]=valGetA[0];
if (dbrType==DBR_CHAR) {
cout << "GAME SET AND MATCH: " << helper.getPVFromHandle(handleSet[i]) << " SET VALUE= " << (unsigned short) valSet[i]
<< " // " << helper.getPVFromHandle(handleMatch[i]) << " READBACK VALUE= " << (unsigned short) valGet[i] //pvdMatch.getAsDouble()
<< " TimeElapsed " << timeElapsed << " (sec) " << endl;
}
else {
cout << "GAME SET AND MATCH: " << helper.getPVFromHandle(handleSet[i]) << " SET VALUE= " << valSet[i]
<< " // " << helper.getPVFromHandle(handleMatch[i]) << " READBACK VALUE= " << valGet[i] //pvdMatch.getAsDouble()
<< " TimeElapsed " << timeElapsed << " (sec) " << endl;
}
} //for
} //printFlag
}
//
for (size_t i=0; i< handleMatch.size(); ++i) {
unsigned int nelemPreviousCheck;
unsigned int nelemRequested=1;
if (nelemPreviousCache[i]>1) {
nelemPreviousCheck= helper.setNelemToRetrieveFromCache(handleMatch[i],nelemPreviousCache[i]);
if (nelemPreviousCheck != nelemPreviousCache[i]) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to re-set the no. elements from: "
<< nelemRequested << endl;
cout << "to the previous: " << nelemPreviousCache[i] << " but got instead: "
<< nelemPreviousCheck << endl;
}
}
if (nMonitors[i]==0 && statMonitor[i]==ICAFE_NORMAL && printFlag) {
cout << "MONITOR NOW STOPPED FOR READBACK CHANNEL " << helper.getPVFromHandle(handleMatch[i]) << " WITH ID =" << monitorID[i] << endl;
int statm;
statm=connect.monitorStop(handleMatch[i], monitorID[i]);
if (status==ICAFE_NORMAL) {status=statm;}
}
} //for
return status;
#undef __METHOD__
}
/**
@@ -895,7 +1451,6 @@ template <class CTYPE> int Instant<CTYPE>::setAndMatchMany(vector<unsigned int>
CTYPE tolerance, double timeout, bool printFlag){
#define __METHOD__ "Instant<CTYPE>::setAndMatchMany(vector<unsigned int>handleSet, chtype, vector<CTYPE>valSet, vector<unsigned int>handleMatch, tolerance, timeout, printFlag)"
Connect connect;
CAFEStatus cstat;
@@ -1296,10 +1851,10 @@ template <class CTYPE> int Instant<CTYPE>::setAndMatchMany(vector<unsigned int>
}
else {
for (size_t i=0; i< handleSet.size(); ++i) {
//if (printFlag) {cout << "MONITOR STARTED WITH ID/2-/=" << monitorID[i] << endl;}
if (printFlag) {
if (printFlag) {
for (size_t i=0; i< handleSet.size(); ++i) {
valGetA[0]=0;
status=Instant::getCache(handleMatch[i], dbrType, valGetA);
valGet[i]=valGetA[0];
@@ -1314,9 +1869,9 @@ template <class CTYPE> int Instant<CTYPE>::setAndMatchMany(vector<unsigned int>
<< " TimeElapsed " << timeElapsed << " (sec) " << endl;
}
}
} //for
} //for
} //printFlag
}
//
@@ -1595,7 +2150,7 @@ template <class CTYPE> int Instant<CTYPE>::setAndMatch(const unsigned int handl
//cout << __METHOD__ << endl;
cout << "Current Cached Value = " ;
if (dbrType==DBR_CHAR) {
cout << (unsigned short) valGetA[0] << cout << endl;
cout << (unsigned short) valGetA[0] << endl;
cout << "Lower/Upper Target Values = " << (unsigned short) valSetLower << " and " << (unsigned short) valSetUpper << endl;
}
else {
@@ -2083,7 +2638,7 @@ template <class CTYPE> int Instant<CTYPE>::matchMany(const chtype dbrType, vect
valGetA[0]=0;
status=Instant::getCache(handleMatch[i], dbrType, valGetA);
valGet[i]=valGetA[0];
cout << "GAME SET AND MATCH: " << " SET VALUE= " << valSet[i] << " // " << helper.getPVFromHandle(handleMatch[i]) << " READBACK VALUE= " << valGet[i] //pvdMatch.getAsDouble()
cout << "GAME SET AND MATCH: " << " SET VALUE= " << valSet[i] << " // " << helper.getPVFromHandle(handleMatch[i]) << " READBACK VALUE= " << valGet[i] //pvdMatch.getAsDouble()
<< " TimeElapsed " << timeElapsed << " (sec) " << endl;
}

131
include/instant.h
View File

@@ -108,14 +108,145 @@ public:
int setAndMatchMany(vector<unsigned int> handleSetV, const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch,
CTYPE tolerance, double timeout, bool printFlag);
int setTriggerAndMatchMany(vector<unsigned int> handleSetV, const chtype dbrType, vector<CTYPE> valSet,
vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
CTYPE tolerance, double timeout, bool printFlag);
int matchMany( const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch,
CTYPE tolerance, double timeout, bool printFlag);
int match( const chtype dbrType, CTYPE valSet, unsigned int handleMatch,
CTYPE tolerance, double timeout, bool printFlag);
int setMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, bool printFlag);
int compareAndMatchMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch,
CTYPE tolerance, double timeout, bool printFlag);
int setManyString(vector<unsigned int> handleSet, vector<string> valSet, bool printFlag) {
#define __METHOD__ "Instant<CTYPE>::setMany(vector<unsigned int>handleSet, chtype, vector<CTYPE>valSet)"
CAFEStatus cstat;
status=ICAFE_NORMAL;
if (handleSet.size() != valSet.size() ) {
return ECAFE_HANDLE_MISMATCH_SET_AND_MATCH;
}
for (size_t i=0; i< handleSet.size(); ++i) {
if (!helper.isChannelConnected(handleSet[i])) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "NOT ALL CHANNELS CONNECTED: " << endl;
if (!helper.isChannelConnected(handleSet[i])) {
helper.printHandle(handleSet[i]);
status=helper.getStatus(handleSet[i]);
}
}
}
if (status!=ICAFE_NORMAL) {return status;}
if(printFlag) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
}
if (printFlag) {
for (size_t i=0; i< handleSet.size(); ++i) {
cout << "SETTING PV=" << helper.getPVFromHandle(handleSet[i]) << " to " << valSet[i] << endl;
} //for
} //if
for (size_t i=0; i< handleSet.size(); ++i) {
//set No of Elements to 1
unsigned int nelemPrevious, nelemRequestedCheck=0;
unsigned int nelemRequested=1;
nelemPrevious=helper.getNelemClient(handleSet[i]);
//Check the number of elements requested?
if (nelemPrevious>1) {
nelemRequestedCheck = helper.setNelem(handleSet[i],nelemRequested);
if (nelemRequestedCheck != nelemRequested) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
<< nelemPrevious << endl;
cout << "to: " << nelemRequested << " but got instead: "
<< nelemRequestedCheck << endl;
}
}
//policy set synchronous
ChannelRequestPolicy polPrevious, polNow;
policyHelper.getChannelRequestPolicyPut(handleSet[i], polPrevious);
polNow.setMethodKind(WITHOUT_CALLBACK);
polNow.setWaitKind(WAIT);
polNow.setWhenToFlushSendBuffer(FLUSH_AUTOMATIC);
policyHelper.setChannelRequestPolicyPut(handleSet[i], polNow);
dbr_string_t valSetA[1];
helper.removeLeadingAndTrailingSpaces(valSet[i].c_str(), valSetA[0]);
status=set(handleSet[i], DBR_STRING, valSetA);
if (status!=ICAFE_NORMAL) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cstat.report(status);
}
policyHelper.setChannelRequestPolicyPut(handleSet[i], polPrevious);
unsigned int nelemPreviousCheck=nelemPrevious;
nelemRequested=1;
//Switch back to previous value
//if (nelemPrevious>1) {
if(helper.getNelemRequest(handleSet[i])!= nelemPrevious) {
nelemPreviousCheck= helper.setNelem(handleSet[i],nelemPrevious);
if (nelemPreviousCheck != nelemPrevious) {
cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
cout << "Internal CAFE FUNNY: Wanted to re-set the no. elements from: "
<< nelemRequested << endl;
cout << "to the previous: " << nelemPrevious << " but got instead: "
<< nelemPreviousCheck << endl;
}
}
} //for size_t
return status;
#undef __METHOD__
}
/**
* \brief Set followed by an immediate get
* \param handleSet input: handle

16
include/makefile
View File

@@ -34,7 +34,7 @@ PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = x86_64-unknown-linux-gnu
host_triplet = x86_64-unknown-linux-gnu
am__append_1 = PyCafe_api.h
#am__append_1 = PyCafe_api.h
#am__append_2 = PyCafe.h
subdir = include
DIST_COMMON = $(am__include_HEADERS_DIST) $(srcdir)/makefile.am \
@@ -90,8 +90,8 @@ CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run aclocal-1.11
AMTAR = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run tar
AM_CPPFLAGS = -fexceptions -fPIC -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/usr/include/QtCore -I/usr/include/QtXml -I/opt/gfa/python-3.5/latest/include/python3.5m
AM_LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/usr/lib64 -Wl,-rpath,/usr/lib64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib
AM_CPPFLAGS = -fexceptions -fPIC -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/usr/include/QtCore -I/usr/include/QtXml
AM_LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/usr/lib64 -Wl,-rpath,/usr/lib64
AR = ar
AUTOCONF = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoconf
AUTOHEADER = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/missing --run autoheader
@@ -102,7 +102,7 @@ CC = gcc
CCDEPMODE = depmode=gcc3
CFLAGS = -g -O2
CPP = gcc -E
CPPFLAGS = -fexceptions -fPIC -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/usr/include/QtCore -I/usr/include/QtXml -I/opt/gfa/python-3.5/latest/include/python3.5m
CPPFLAGS = -fexceptions -fPIC -I/usr/local/epics/base/include/ -I/usr/local/epics/base/include/os/Linux -I/opt/gfa/cafe/boost/boost_1_61_0/include/boost -I/opt/gfa/cafe/boost/boost_1_61_0/include -I/usr/include/QtCore -I/usr/include/QtXml
CXX = g++
CXXCPP = g++ -E
CXXDEPMODE = depmode=gcc3
@@ -125,9 +125,9 @@ INSTALL_PROGRAM = ${INSTALL}
INSTALL_SCRIPT = ${INSTALL}
INSTALL_STRIP_PROGRAM = $(install_sh) -c -s
LD = /usr/bin/ld -m elf_x86_64
LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/usr/lib64 -Wl,-rpath,/usr/lib64 -L/opt/gfa/python-3.5/latest/lib -Wl,-rpath,/opt/gfa/python-3.5/latest/lib
LDFLAGS = -L/usr/local/epics/base/lib/SL6-x86_64 -Wl,-rpath,/usr/local/epics/base/lib/SL6-x86_64 -L/usr/lib64 -Wl,-rpath,/usr/lib64
LIBOBJS =
LIBS = -lpython3.5m -lQtXml -lQtCore
LIBS = -lQtXml -lQtCore
LIBTOOL = $(SHELL) $(top_builddir)/libtool
LIPO =
LN_S = ln -s
@@ -186,7 +186,7 @@ htmldir = ${docdir}
includedir = ${prefix}/include
infodir = ${datarootdir}/info
install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh
libdir = /opt/gfa/cafe/python/python-3.5/pycafe-1.3.0-final-2/lib
libdir = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1/lib
libexecdir = ${exec_prefix}/libexec
localedir = ${datarootdir}/locale
localstatedir = ${prefix}/var
@@ -195,7 +195,7 @@ mandir = ${datarootdir}/man
mkdir_p = /bin/mkdir -p
oldincludedir = /usr/include
pdfdir = ${docdir}
prefix = /opt/gfa/cafe/python/python-3.5/pycafe-1.3.0-final-2
prefix = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1
program_transform_name = s,x,x,
psdir = ${docdir}
sbindir = ${exec_prefix}/sbin

8
include/policies.h
View File

@@ -64,10 +64,11 @@ public:
class ChannelCreatePolicy{
private:
unsigned short priority;
static void callbackHandlerCreate(struct connection_handler_args args);
//special method to find handle thru conduit_set iterator
pCallbackConnection handler;
public:
static void callbackHandlerCreate(struct connection_handler_args args);
pCallbackConnection getHandler(){return handler;};
void setHandler(pCallbackConnection h){handler=h;};
unsigned short getPriority() const {return priority;}
@@ -411,7 +412,7 @@ private:
int status; //output
unsigned int id;
static void callbackHandlerMonitor(struct event_handler_args args);
static void PyCallbackHandlerMonitorData(struct event_handler_args args); //pushes pvd,handle,pvname
static void PyCallbackHandlerMonitor(struct event_handler_args args); //pushes handle
@@ -427,6 +428,9 @@ public:
++idNext;
id = idNext;
};
//Make public
static void callbackHandlerMonitor(struct event_handler_args args);
chtype getDataType() const {return dataType;};
chtype getDbrDataType() const {return dbrDataType;};
CAFENUM::DBR_TYPE getCafeDbrType() const {return cafeDbrType;};

57
include/statusCodes.h
View File

@@ -36,7 +36,7 @@ const unsigned short ICAFE_STATUS_CA_OP = 800;
const unsigned short ICAFE_STATUS_ERROR = 1000;
const unsigned short ICAFE_FILE_ERROR = 1100;
const unsigned short ICAFE_SERVICE_ERROR =1200;
const unsigned short ICAFE_LINUX_ERROR = 5000;
const unsigned short ICAFE_ERRNO_BASE = 5000;
const unsigned short ICAFE_SUCCESS = ECA_NORMAL;
const unsigned short ICAFE_NORMAL = ECA_NORMAL;
@@ -119,11 +119,11 @@ enum CAFE_FILE_ERROR { ECAFE_LOAD_COLLECTION=ICAFE_FILE_ERROR,
enum CAFE_SERVICE_ERROR { ECAFE_BPM_DATA_IS_INVALID=ICAFE_SERVICE_ERROR
};
//Used by zeromq
enum CAFE_LINUX_ERROR { LINUX_EINTR =ICAFE_LINUX_ERROR+4,
LINUX_EAGAIN=ICAFE_LINUX_ERROR+11,
LINUX_EFAULT=ICAFE_LINUX_ERROR+14,
LINUX_ENOTSOCK=ICAFE_LINUX_ERROR+88,
LINUX_EPROTONOSUPPORT=ICAFE_LINUX_ERROR+93
enum CAFE_ERRNO_ERROR { ERRNO_EINTR =ICAFE_ERRNO_BASE+4,
ERRNO_EAGAIN=ICAFE_ERRNO_BASE+11,
ERRNO_EFAULT=ICAFE_ERRNO_BASE+14,
ERRNO_ENOTSOCK=ICAFE_ERRNO_BASE+88,
ERRNO_EPROTONOSUPPORT=ICAFE_ERRNO_BASE+93
};
@@ -420,11 +420,11 @@ public:
* 1100 ECAFE_LOAD_COLLECTION \n
* 1101 ECAFE_LOAD_GROUP \n
* 1200 ECAFE_BPM_DATA_IS_INVALID \n
* 5004 LINUX_EINTR \n
* 5011 LINUX_EGAIN \n
* 5014 LINUX_EFAULT \n
* 5088 LINUX_ENOTSOCK \n
* 5093 LINUX_EPROTONOSUPPORT \n
* 5004 ERRNO_EINTR \n
* 5011 ERRNO_EGAIN \n
* 5014 ERRNO_EFAULT \n
* 5088 ERRNO_ENOTSOCK \n
* 5093 ERRNO_EPROTONOSUPPORT \n
*/
class CAFEStatusInfo {
typedef std::map<int, std::string> mapLongString;
@@ -510,18 +510,17 @@ public:
mapStatusInfo.insert(std::make_pair((int) ECAFE_HANDLE_MISMATCH_SET_AND_MATCH, "Number of set/readback handles do not match"));
mapStatusInfo.insert(std::make_pair((int) ECAFE_INCONSISTENT_CONTAINER_CORRECTED, "Boost container required update after consistency check"));
mapStatusInfo.insert(std::make_pair((int) ECAFE_LOAD_COLLECTION, "CAFE collection could not be loaded from xml configuration file " ));
mapStatusInfo.insert(std::make_pair((int) ECAFE_LOAD_GROUP, "CAFE group could not be loaded from group xml configuration file " ));
mapStatusInfo.insert(std::make_pair((int) ECAFE_BPM_DATA_IS_INVALID, "CAFE BPM Service: Data Validity channel reports BPM data is INVALID " ));
mapStatusInfo.insert(std::make_pair((int) ECAFE_BPM_DATA_IS_INVALID, "CAFE BPM Service: Data Validity channel reports BPM data is INVALID " ));
mapStatusInfo.insert(std::make_pair((int) LINUX_EINTR, "C ERROR CODE IN LINUX: Interrupted system call" ));
mapStatusInfo.insert(std::make_pair((int) LINUX_EAGAIN, "C ERROR CODE IN LINUX: Try again" ));
mapStatusInfo.insert(std::make_pair((int) LINUX_EFAULT, "C ERROR CODE IN LINUX: Bad address" ));
mapStatusInfo.insert(std::make_pair((int) LINUX_ENOTSOCK, "C ERROR CODE IN LINUX: Socket operation on non-socket" ));
mapStatusInfo.insert(std::make_pair((int) LINUX_EPROTONOSUPPORT, "C ERROR CODE IN LINUX: Protocol not supported" ));
mapStatusInfo.insert(std::make_pair((int) ERRNO_EINTR, "C ERRNO CODE: Interrupted system call" ));
mapStatusInfo.insert(std::make_pair((int) ERRNO_EAGAIN, "C ERRNO CODE: Try again" ));
mapStatusInfo.insert(std::make_pair((int) ERRNO_EFAULT, "C ERRNO CODE: Bad address" ));
mapStatusInfo.insert(std::make_pair((int) ERRNO_ENOTSOCK, "C ERRNO CODE: Socket operation on non-socket" ));
mapStatusInfo.insert(std::make_pair((int) ERRNO_EPROTONOSUPPORT, "C ERRNO CODE: Protocol not supported" ));
}
~CAFEStatusInfo() {};
@@ -678,11 +677,11 @@ public:
mapStatusCode.insert(std::make_pair((int) ECAFE_BPM_DATA_IS_INVALID, "CAFE_ERROR: ECAFE_BPM_DATA_IS_INVALID" ));
mapStatusCode.insert(std::make_pair((int) LINUX_EINTR, "CAFE_ERROR: LINUX_EINTR" ));
mapStatusCode.insert(std::make_pair((int) LINUX_EAGAIN, "CAFE_WARN: LINUX_EAGAIN " ));
mapStatusCode.insert(std::make_pair((int) LINUX_EFAULT, "CAFE_ERROR: LINUX_EFAULT" ));
mapStatusCode.insert(std::make_pair((int) LINUX_ENOTSOCK, "CAFE_ERROR: LINUX_ENOTSOCK" ));
mapStatusCode.insert(std::make_pair((int) LINUX_EPROTONOSUPPORT, "CAFE_ERROR: LINUX_EPROTONOSUPPORT" ));
mapStatusCode.insert(std::make_pair((int) ERRNO_EINTR, "CAFE_ERROR: ERRNO_EINTR" ));
mapStatusCode.insert(std::make_pair((int) ERRNO_EAGAIN, "CAFE_WARN: ERRNO_EAGAIN " ));
mapStatusCode.insert(std::make_pair((int) ERRNO_EFAULT, "CAFE_ERROR: ERRNO_EFAULT" ));
mapStatusCode.insert(std::make_pair((int) ERRNO_ENOTSOCK, "CAFE_ERROR: ERRNO_ENOTSOCK" ));
mapStatusCode.insert(std::make_pair((int) ERRNO_EPROTONOSUPPORT, "CAFE_ERROR: ERRNO_EPROTONOSUPPORT" ));
};
@@ -887,11 +886,11 @@ public:
mapStatusSeverity.insert(std::make_pair((int) ECAFE_BPM_DATA_IS_INVALID, "WARN" ));
mapStatusSeverity.insert(std::make_pair((int) LINUX_EINTR, "ERROR" ));
mapStatusSeverity.insert(std::make_pair((int) LINUX_EAGAIN, "WARN" ));
mapStatusSeverity.insert(std::make_pair((int) LINUX_EFAULT, "ERROR"));
mapStatusSeverity.insert(std::make_pair((int) LINUX_ENOTSOCK, "ERROR"));
mapStatusSeverity.insert(std::make_pair((int) LINUX_EPROTONOSUPPORT, "ERROR" ));
mapStatusSeverity.insert(std::make_pair((int) ERRNO_EINTR, "ERROR" ));
mapStatusSeverity.insert(std::make_pair((int) ERRNO_EAGAIN, "WARN" ));
mapStatusSeverity.insert(std::make_pair((int) ERRNO_EFAULT, "ERROR"));
mapStatusSeverity.insert(std::make_pair((int) ERRNO_ENOTSOCK, "ERROR"));
mapStatusSeverity.insert(std::make_pair((int) ERRNO_EPROTONOSUPPORT, "ERROR" ));

11
include/transpose.h
View File

@@ -311,12 +311,6 @@ template <class CTYPE> int Transpose<CTYPE>::put(const unsigned int _handle,
}//if noStrings>0
}//if
//cout << "dbrTypeRequest_DataBuffer " << dbrTypeRequest_DataBuffer << endl;
//cout << "_dbrType " << _dbrType << endl;
//cout << "nelem " << nelem << endl;
switch (dbrTypeRequest_DataBuffer)
{
@@ -450,12 +444,9 @@ template <class CTYPE> int Transpose<CTYPE>::put(const unsigned int _handle,
}
break;
case DBR_DOUBLE: //6
for (unsigned int i=0; i<nelem; ++i) {
*((dbr_float_t *) (PVDataL) + i ) = (dbr_float_t) val[i] ;
}
break;
case DBR_STRING: //0
status=putString(_handle, (dbr_string_t *) val);
@@ -697,7 +688,7 @@ template <class CTYPE> int Transpose<CTYPE>::put(const unsigned int _handle,
return ECAFE_INVALID_HANDLE;
}
cout << "status " << status << endl;
return status;

273
include/zhelpers.h
View File

@@ -1,51 +1,24 @@
/* =====================================================================
zhelpers.h
Helper header file for example applications.
=====================================================================
*/
#ifndef ZHELPERS_H
#define ZHELPERS_H
#ifndef __ZHELPERS_H_INCLUDED__
#define __ZHELPERS_H_INCLUDED__
#if HAVE_ZEROMQ
// Include a bunch of headers that we will need in the examples
#include <zmq.h>
/*
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#if (defined (WIN32))
# include <time.h>
#else
# include <sys/time.h>
#endif
*/
#include <assert.h>
#include <signal.h>
// Version checking, and patch up missing constants to match 2.1
#if ZMQ_VERSION_MAJOR == 2
# error "Please upgrade to ZeroMQ/3.2 for these examples"
#endif
// Provide random number from 0..(num-1)
#if (defined (WIN32))
# define randof(num) (int) ((float) (num) * rand () / (RAND_MAX + 1.0))
#else
# define randof(num) (int) ((float) (num) * random () / (RAND_MAX + 1.0))
#endif
#if HAVE_JSON
#include <json/json.h>
#include <json/json.h>
#endif
#include <cafeService.h>
@@ -57,36 +30,6 @@ string hashOriginal="";
unsigned short hashOriginalFlag=0;
bool fillBSPV=false;
vector<std::string> bsPV;
// Receive 0MQ string from socket and convert into C string
// Caller must free returned string. Returns NULL if the context
// is being terminated.
static char *
s_recv (void *socket) {
char buffer [4096];
int size = zmq_recv (socket, buffer, 4096, 0); //ZMQ_DONTWAIT);
if (size == -1)
return NULL;
if (size > 4096)
size = 4096;
buffer [size] = 0;
return strdup (buffer);
}
// Convert C string to 0MQ string and send to socket
static int
s_send (void *socket, char *string) {
int size = zmq_send (socket, string, strlen (string), 0);
return size;
}
// Sends string as 0MQ string, as multipart non-terminal
static int
s_sendmore (void *socket, char *string) {
int size = zmq_send (socket, string, strlen (string), ZMQ_SNDMORE);
return size;
}
// Receives all message parts from socket, prints neatly
@@ -97,7 +40,7 @@ s_dump (DBPMKeeper & dbpm)
if (inDumpFlag==1) {
cout << "zeroMQ socket is busy " << endl;
cout << "waiting got zmq timeout " << endl;
cout << "waiting for zmq timeout " << endl;
}
puts ("//START----------------------------------------//");
@@ -124,20 +67,21 @@ s_dump (DBPMKeeper & dbpm)
cout << "df = " << inDumpFlag << endl;
while (inDumpFlag==1) {
while (inDumpFlag==1) {
cout << "df/ = " << inDumpFlag << endl;
cout << " sleeping " << endl;
sleep(1);
cout << " sleeping " << endl;
//sleep(1);
}
int subMessage=0;
int nSequentialHeader=0;
while (1) {
inDumpFlag=1;
// puts ("//WHILE LOOP ----------------------------------------//");
//cout << "subMessage " << subMessage << endl;
//puts ("//WHILE LOOP ----------------------------------------//");
//cout << "subMessage " << subMessage << endl;
// Process all parts of the message
zmq_msg_t message;
zmq_msg_init (&message);
@@ -149,32 +93,52 @@ s_dump (DBPMKeeper & dbpm)
cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
//Resource unavailable means that there is nothing to read now
zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
//cout << "message mulipart --> more == " << more << endl;
zmq_msg_close (&message);
dbpm.status=ICAFE_LINUX_ERROR+zmq_errno() ;
//if (!more) {
// dbpm.status=ERRNO_EAGAIN; //ICAFE_ERRNO_BASE +zmq_errno() ;
// cout << "EARLY BREAK subMessage total: " << subMessage << endl;
// puts ("//------------------------------------END-------------------------------------//");
// break; // Last message
// }
dbpm.status=ICAFE_ERRNO_BASE+zmq_errno() ;
break;
}
else if (size == 0) {
//cout << " Data of Zero SIZE for submessage " << subMessage << endl;
////cout << " Data of Zero SIZE for submessage " << subMessage << endl;
++nZeroSize;
//zmq_msg_close (&message);
//dbpm.status=ECAFE_NODATA;
//break;
//Comes in pairs; one for val one for timestamp
if (nZeroSize%2==1) {
++bsPVIdx;
// cout << " pv with zero size: " << bsPV[bsPVIdx] << endl;
++bsPVIdx;
if (bsPVIdx >0) {
cout << bsPV[bsPVIdx] << endl;
}
}
++subMessage;
continue;
//continue;
}
else {
@@ -190,9 +154,16 @@ s_dump (DBPMKeeper & dbpm)
|| (unsigned char) data [char_nbr] > 127)
is_text = 0;
// printf (" SIZE [%03d] ", size);
//TExt is two header files
//non-text size=8 is X1, Y1, Q1
//non-text size=2 is -VALID
//non-text size=16 is timestamp
/*
printf (" SIZE [%03d] ", size);
if (is_text) {
cout << " TEXT +++++++++++ " << endl;
}
@@ -230,11 +201,11 @@ s_dump (DBPMKeeper & dbpm)
if (is_text) {
parsingSuccessful=reader.parse(data, parsedFromString);
if (parsingSuccessful) {
Json::StyledWriter styledWriter;
//Json::StyledWriter styledWriter;
//cout << "STYLED: --------------------------------" << endl;
//cout << styledWriter.write(parsedFromString) << endl;
//cout << "----------------------------------" << endl;
cout << parsedFromString["htype"] << endl;
//cout << parsedFromString["htype"] << endl;
if (fastWriter.write(parsedFromString["htype"]).find("bsr_m-1.1") != std::string::npos) {
@@ -243,7 +214,7 @@ s_dump (DBPMKeeper & dbpm)
hashIs=parsedFromString["hash"].asString();
if (hashOriginalFlag<2) {
if (hashOriginalFlag==0) {
cout << hashIs << " is different to original/// " << hashOriginal << endl;
hashOriginal=hashIs;
++hashOriginalFlag;
@@ -252,10 +223,14 @@ s_dump (DBPMKeeper & dbpm)
if (hashOriginal.compare(hashIs)!=0) {
cout << hashIs << " is different to original " << hashOriginal << endl;
hashOriginal=hashIs;
++hashOriginalFlag;
fillBSPV=true;
}
cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
dbpm.setPulse_id(parsedFromString["pulse_id"].asUInt64());
//Reset values as a change of hash signifies that data from two pulse ids
//is being sent in one zeromq messages
@@ -283,9 +258,9 @@ s_dump (DBPMKeeper & dbpm)
}
else if (fastWriter.write(parsedFromString["htype"]).find("bsr_d-1.1") != std::string::npos) {
++nSequentialHeader;
//if (fillBSPV) {
if (fillBSPV) {
bsPV.clear();
bsPV.reserve(dbpm.getNPV());
@@ -324,7 +299,7 @@ s_dump (DBPMKeeper & dbpm)
//cout << "NEW FILL: size of bsPV " << bsPV.size() << endl;
fillBSPV=false;
//}
}
}
@@ -338,24 +313,37 @@ s_dump (DBPMKeeper & dbpm)
}
//cout << "----------------------------------" << endl;
cout << "/----------------------------------/" << endl;
}
}
if (nSequentialHeader >5) {
if (nSequentialHeader >3 && is_text==1) {
cout << "WARNING: ZEROMQ SUB-MESSAGE DOES NOT CLOSE " << endl;
cout << "WARNING: FORCING CLOSE AND BREAKING FROM LOOP " << endl;
zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
cout << "WARNING: FORCING ZMQ_MSG_CLOSE " << endl;
cout << "No of sequential headers " << nSequentialHeader << endl;
cout << "is_text " << is_text << endl;
//zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
zmq_msg_close (&message);
cout << "message mulipart --> more == " << more << endl;
//zmq_msg_close (&message);
//cout << "message mulipart --> more == " << more << endl;
dbpm.status=LINUX_EAGAIN; //ICAFE_LINUX_ERROR +zmq_errno() ;
//break;
//nSequentialHeader=0;
//cannot break; results in seqmentation fault
//if (!more) {
// dbpm.status=ERRNO_EAGAIN; //ICAFE_ERRNO_BASE +zmq_errno() ;
// cout << "EARLY BREAK subMessage total: " << subMessage << endl;
// puts ("//------------------------------------END-------------------------------------//");
// break; // Last message
//}
}
union foo
@@ -408,7 +396,9 @@ s_dump (DBPMKeeper & dbpm)
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set(v);
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].setBSStatus(ICAFE_NORMAL);
//cout << " readback of value that was set = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].d << endl;
}
@@ -465,6 +455,9 @@ s_dump (DBPMKeeper & dbpm)
}
//cout << "value DBPM = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].str << endl;
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].setBSStatus(ICAFE_NORMAL);
}
@@ -497,23 +490,27 @@ s_dump (DBPMKeeper & dbpm)
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].ts.nsec=b;
}
//cout << "subMessage above: " << subMessage << endl;
++subMessage;
++subMessage;
} //ifelse
} //ifelse
zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
zmq_msg_close (&message);
//cout << "value of more " << more << endl;
if (!more) {
dbpm.status=ICAFE_NORMAL;
cout << "subMessage total: " << subMessage << endl;
cout << " of which 0 size: " << nZeroSize << endl;
cout << " Percentage good: " << (subMessage-nZeroSize-2)*100/(subMessage-2);
puts ("//------------------------------------END-------------------------------------//");
break; // Last message part
@@ -522,6 +519,16 @@ s_dump (DBPMKeeper & dbpm)
inDumpFlag=0;
if (subMessage>2) {
dbpm.status=ICAFE_NORMAL;
cout << "subMessage total: " << subMessage << endl;
cout << " of which 0 size: " << nZeroSize << endl;
cout << " Percentage good: " << (subMessage-nZeroSize-2)*100/(subMessage-2);
puts ("//------------------------------------END-------------------------------------//");
}
cout << "end of loop " << endl;
return;
}
@@ -763,68 +770,6 @@ s_dump (void *socket)
}
// Set simple random printable identity on socket
//
static void
s_set_id (void *socket)
{
char identity [10];
sprintf (identity, "%04X-%04X", randof (0x10000), randof (0x10000));
zmq_setsockopt (socket, ZMQ_IDENTITY, identity, strlen (identity));
}
/*
// Sleep for a number of milliseconds
static void
s_sleep (int msecs)
{
#if (defined (WIN32))
Sleep (msecs);
#else
struct timespec t;
t.tv_sec = msecs / 1000;
t.tv_nsec = (msecs % 1000) * 1000000;
nanosleep (&t, NULL);
#endif
}
*/
// Return current system clock as milliseconds
static int64_t
s_clock (void)
{
#if (defined (WIN32))
SYSTEMTIME st;
GetSystemTime (&st);
return (int64_t) st.wSecond * 1000 + st.wMilliseconds;
#else
struct timeval tv;
gettimeofday (&tv, NULL);
return (int64_t) (tv.tv_sec * 1000 + tv.tv_usec / 1000);
#endif
}
// Print formatted string to stdout, prefixed by date/time and
// terminated with a newline.
/*
static void
s_console (const char *format, ...)
{
time_t curtime = time (NULL);
struct tm *loctime = localtime (&curtime);
char *formatted = (char*)malloc (20);
strftime (formatted, 20, "%y-%m-%d %H:%M:%S ", loctime);
printf ("%s", formatted);
free (formatted);
va_list argptr;
va_start (argptr, format);
vprintf (format, argptr);
va_end (argptr);
printf ("\n");
}
*/
#endif // __ZHELPERS_H_INCLUDED__
#endif
#endif // ZHELPERS_H

830
include/zhelpers.h- Normal file
View File

@@ -0,0 +1,830 @@
/* =====================================================================
zhelpers.h
Helper header file for example applications.
=====================================================================
*/
#ifndef __ZHELPERS_H_INCLUDED__
#define __ZHELPERS_H_INCLUDED__
#if HAVE_ZEROMQ
// Include a bunch of headers that we will need in the examples
#include <zmq.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#if (defined (WIN32))
# include <time.h>
#else
# include <sys/time.h>
#endif
#include <assert.h>
#include <signal.h>
// Version checking, and patch up missing constants to match 2.1
#if ZMQ_VERSION_MAJOR == 2
# error "Please upgrade to ZeroMQ/3.2 for these examples"
#endif
// Provide random number from 0..(num-1)
#if (defined (WIN32))
# define randof(num) (int) ((float) (num) * rand () / (RAND_MAX + 1.0))
#else
# define randof(num) (int) ((float) (num) * random () / (RAND_MAX + 1.0))
#endif
#if HAVE_JSON
#include <json/json.h>
#endif
#include <cafeService.h>
unsigned short inDumpFlag=2;
string hashIs="";
string hashOriginal="";
unsigned short hashOriginalFlag=0;
bool fillBSPV=false;
vector<std::string> bsPV;
// Receive 0MQ string from socket and convert into C string
// Caller must free returned string. Returns NULL if the context
// is being terminated.
static char *
s_recv (void *socket) {
char buffer [4096];
int size = zmq_recv (socket, buffer, 4096, 0); //ZMQ_DONTWAIT);
if (size == -1)
return NULL;
if (size > 4096)
size = 4096;
buffer [size] = 0;
return strdup (buffer);
}
// Convert C string to 0MQ string and send to socket
static int
s_send (void *socket, char *string) {
int size = zmq_send (socket, string, strlen (string), 0);
return size;
}
// Sends string as 0MQ string, as multipart non-terminal
static int
s_sendmore (void *socket, char *string) {
int size = zmq_send (socket, string, strlen (string), ZMQ_SNDMORE);
return size;
}
// Receives all message parts from socket, prints neatly
//
static void
s_dump (DBPMKeeper & dbpm)
{
if (inDumpFlag==1) {
cout << "zeroMQ socket is busy " << endl;
cout << "waiting got zmq timeout " << endl;
}
puts ("//START----------------------------------------//");
void * socket = dbpm.subscriber;
#if HAVE_JSON
Json::Value parsedFromString;
Json::Reader reader;
bool parsingSuccessful;
Json::FastWriter fastWriter;
#endif
int64_t more; // Multipart detection
more = 0;
size_t more_size = sizeof (more);
int bsPVIdx=-1;
dbpm.status=ICAFE_NORMAL;
int nZeroSize=0;
cout << "df = " << inDumpFlag << endl;
while (inDumpFlag==1) {
cout << "df/ = " << inDumpFlag << endl;
cout << " sleeping " << endl;
sleep(1);
}
int subMessage=0;
int nSequentialHeader=0;
while (1) {
inDumpFlag=1;
// puts ("//WHILE LOOP ----------------------------------------//");
//cout << "subMessage " << subMessage << endl;
// Process all parts of the message
zmq_msg_t message;
zmq_msg_init (&message);
size_t size = zmq_msg_recv (&message, socket, 0);
//puts ("//MESSAGE RECEIVED ----------------------------------------//");
if (size == -1) {
cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
//Resource unavailable means that there is nothing to read now
zmq_msg_close (&message);
dbpm.status=ICAFE_LINUX_ERROR+zmq_errno() ;
break;
}
else if (size == 0) {
//cout << " Data of Zero SIZE for submessage " << subMessage << endl;
++nZeroSize;
//zmq_msg_close (&message);
//dbpm.status=ECAFE_NODATA;
//break;
//Comes in pairs; one for val one for timestamp
if (nZeroSize%2==1) {
++bsPVIdx;
// cout << " pv with zero size: " << bsPV[bsPVIdx] << endl;
}
++subMessage;
continue;
}
else {
// Dump the message as text or binary
char *data = (char*)zmq_msg_data (&message);
int is_text = 1;
int char_nbr;
//char cmd[5000]="";
for (char_nbr = 0; char_nbr < size; char_nbr++)
if ((unsigned char) data [char_nbr] < 32
|| (unsigned char) data [char_nbr] > 127)
is_text = 0;
// printf (" SIZE [%03d] ", size);
/*
if (is_text) {
cout << " TEXT +++++++++++ " << endl;
}
else {
cout << " NOT TEXT +++++++++++ " << endl;
}
for (char_nbr = 0; char_nbr < size; char_nbr++) {
if (is_text) {
printf ("%c", data [char_nbr]);
//snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%c", data [char_nbr]);
}
else {
printf ("%02X", (unsigned char) data [char_nbr]);
//printf ("%d", (unsigned char) data [char_nbr]);
//snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%d", (unsigned char)data [char_nbr]);
//if (data[0] == '\x7') {
// cout << " little endian " << endl;
//}
//else {
// cout << "big endian " << endl;
//}
}
}//for
printf ("\n");
*/
if (is_text) {
parsingSuccessful=reader.parse(data, parsedFromString);
if (parsingSuccessful) {
Json::StyledWriter styledWriter;
//cout << "STYLED: --------------------------------" << endl;
//cout << styledWriter.write(parsedFromString) << endl;
//cout << "----------------------------------" << endl;
cout << parsedFromString["htype"] << endl;
if (fastWriter.write(parsedFromString["htype"]).find("bsr_m-1.1") != std::string::npos) {
++nSequentialHeader;
hashIs=parsedFromString["hash"].asString();
if (hashOriginalFlag<2) {
cout << hashIs << " is different to original/// " << hashOriginal << endl;
hashOriginal=hashIs;
++hashOriginalFlag;
fillBSPV=true;
}
if (hashOriginal.compare(hashIs)!=0) {
cout << hashIs << " is different to original " << hashOriginal << endl;
fillBSPV=true;
}
cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
//Reset values as a change of hash signifies that data from two pulse ids
//is being sent in one zeromq messages
subMessage=0;
bsPVIdx=-1;
dbpm.status=ICAFE_NORMAL;
nZeroSize=0;
/*
cout << "(1)++++++++++++++++++++++++++++++++++++++++MAIN++++++++++++++++++++++++++++++++++++++++++" << endl;
cout << "hash " << parsedFromString["hash"] << endl;
cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
cout << "g ts " << parsedFromString["global_timestamp"] << endl;
cout << "comp " << parsedFromString["dh_compression"] << endl;
cout << "sec " << parsedFromString["global_timestamp"]["sec"].asUInt() << endl;
cout << "nsec " << parsedFromString["global_timestamp"]["ns"].asUInt() << endl;
*/
}
else if (fastWriter.write(parsedFromString["htype"]).find("bsr_d-1.1") != std::string::npos) {
//if (fillBSPV) {
bsPV.clear();
bsPV.reserve(dbpm.getNPV());
/*
if (dbpm.getNPV() != parsedFromString["channels"].size() ) {
cout << "No of CONFIGURED BPMS: " << dbpm.getNPV()
<< " is diffent to that being channeled " << parsedFromString["channels"].size() << endl;
bsPV.reserve( max( (size_t) parsedFromString["channels"].size(),dbpm.getNPV()) );
}
*/
//cout << "chan " << parsedFromString["channels"] << endl;
cout << "No of channels " << parsedFromString["channels"].size() << endl;
cout << "(2)++++++++++++++++++++++++++++++++++++++++HEADER++++++++++++++++++++++++++++++++++++++++++" << endl;
for (Json::Value::ArrayIndex i=0; i < parsedFromString["channels"].size(); ++ i) {
//cout << "name " << parsedFromString["channels"][i]["name"].asString() << endl;
//cout << "enco " << parsedFromString["channels"][i]["encoding"] << endl;
//cout << "type " << parsedFromString["channels"][i]["type"] << endl;
bsPV.push_back( (parsedFromString["channels"][i]["name"]).asString());
}
/*
cout << "LIST OF PVS " << endl;
for (size_t i=0; i< bsPV.size(); ++i ) {
cout << i << " // " << bsPV[i].c_str() << " " << endl;
}
cout << endl;
*/
//cout << "NEW FILL: size of bsPV " << bsPV.size() << endl;
fillBSPV=false;
//}
}
else {
cout << "HEADER IS SOMETHING ELSE: " << endl;
cout << parsedFromString["htype"] << endl;
exit(1);
}
//cout << "----------------------------------" << endl;
}
}
if (nSequentialHeader >5) {
cout << "WARNING: ZEROMQ SUB-MESSAGE DOES NOT CLOSE " << endl;
cout << "WARNING: FORCING CLOSE AND BREAKING FROM LOOP " << endl;
zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
zmq_msg_close (&message);
cout << "message mulipart --> more == " << more << endl;
dbpm.status=LINUX_EAGAIN; //ICAFE_LINUX_ERROR +zmq_errno() ;
//break;
}
union foo
{
char c[sizeof(double)];
double d;
} bar;
//SIZE 16 is timestamp
//SIZE 8 is x,y,Q
//SIZE 2 is valid
if (subMessage > 1430) {
cout << " SIZE " << size << " subMessage " << subMessage << endl;
cout << "size of bsPV " << bsPV.size() << endl;
}
if (subMessage > 0 && subMessage%2 ==0) {
if (size==8) {
// big endian
for (char_nbr = 0; char_nbr < size; char_nbr++) {
bar.c[char_nbr]=data[size-1-char_nbr]; // THis works for big engian
}
// little endian
//for (char_nbr = 0; char_nbr < size; char_nbr++) {
// bar.c[char_nbr]=data[char_nbr];
//}
//cout << "UNION D " << bar.d << endl;
double v; // = (double*) data;
memcpy(&v, bar.c, sizeof(double));
//cout << " double val " << v << endl;
//This is BPM Data - value
++bsPVIdx;
if (dbpm.getPVIdx(bsPV[bsPVIdx]) <0) {
cout << " WARNING--> THIS CHANNEL WAS NOT REQUESTED IN CONFIGURATION FILE " << endl;
cout << " bsPV index = " << bsPVIdx << endl;
cout << " pv from bs = " << bsPV[bsPVIdx] << endl;
cout << " Illegal index Value =" << dbpm.getPVIdx(bsPV[bsPVIdx]) << endl;
cout << " SKIPPING THIS BPM... " << endl;
continue;
}
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set(v);
//cout << " readback of value that was set = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].d << endl;
}
else if (size==2) {
unsigned short iv;
//memcpy(&iv, cmd, size);
//big endian
for (size_t n=0; n < size; n++) {
iv = (iv << 8) + data[n];
}
//little endian
//for (size_t n = size; n >= 0; n--) {
// iv = (iv << 8) + data[n];
//}
//This is BPM Data - VALID/INVALID
//cout << "uint val (1 means valid) " << iv << endl;
/*
std::copy(data, data + 32, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 8, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 4, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 2, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 1, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
*/
++bsPVIdx;
if (dbpm.getPVIdx(bsPV[bsPVIdx]) <0) {
cout << " WARNING--> THIS CHANNEL WAS NOT REQUESTED IN CONFIGURATION FILE " << endl;
cout << " bsPV index = " << bsPVIdx << endl;
cout << " pv from bs = " << bsPV[bsPVIdx] << endl;
cout << " Illegal index Value =" << dbpm.getPVIdx(bsPV[bsPVIdx]) << endl;
cout << " SKIPPING THIS BPM ENUM TYPE " << endl;
continue;
}
if (iv==1) {
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set((std::string) "VALID");
}
else {
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set((std::string) "INVALID");
}
//cout << "value DBPM = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].str << endl;
}
}
else if (subMessage > 1 && subMessage%2 ==1) {
//cout << "timestamp " << endl;
unsigned int a,b;
for (size_t n=0; n < size/2; n++) {
a = (a << 8) + data[n];
}
for (size_t n=size/2; n < size; n++) {
b = (b << 8) + data[n];
}
//cout << "a " << a << " b " << b << endl;
if (dbpm.getPVIdx(bsPV[bsPVIdx]) <0) {
cout << " WARNING--> THIS CHANNEL WAS NOT REQUESTED IN CONFIGURATION FILE " << endl;
cout << " bsPV index = " << bsPVIdx << endl;
cout << " pv from bs = " << bsPV[bsPVIdx] << endl;
cout << " Illegal index Value =" << dbpm.getPVIdx(bsPV[bsPVIdx]) << endl;
cout << " SKIPPING THIS BPM TIMESTAMP " << endl;
continue;
}
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].ts.secPastEpoch=a;
dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].ts.nsec=b;
}
//cout << "subMessage above: " << subMessage << endl;
++subMessage;
} //ifelse
zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
zmq_msg_close (&message);
if (!more) {
cout << "subMessage total: " << subMessage << endl;
puts ("//------------------------------------END-------------------------------------//");
break; // Last message part
}
} //while 1
inDumpFlag=0;
return;
}
// Receives all message parts from socket, prints neatly
//
static void
s_dump (void *socket)
{
puts ("//START----------------------------------------//");
int subMessage=0;
#if HAVE_JSON
Json::Value parsedFromString;
Json::Reader reader;
bool parsingSuccessful;
Json::FastWriter fastWriter;
#endif
while (1) {
// Process all parts of the message
zmq_msg_t message;
zmq_msg_init (&message);
size_t size = zmq_msg_recv (&message, socket, 0);
if (size == -1) {
cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
//Resource unavailable means that there is nothing to read now
zmq_msg_close (&message);
break;
}
else {
// Dump the message as text or binary
char *data = (char*)zmq_msg_data (&message);
int is_text = 1;
int char_nbr;
//char cmd[5000]="";
for (char_nbr = 0; char_nbr < size; char_nbr++)
if ((unsigned char) data [char_nbr] < 32
|| (unsigned char) data [char_nbr] > 127)
is_text = 0;
printf ("[%03d] ", size);
for (char_nbr = 0; char_nbr < size; char_nbr++) {
if (is_text) {
printf ("%c", data [char_nbr]);
//snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%c", data [char_nbr]);
}
else {
printf ("%02X", (unsigned char) data [char_nbr]);
//printf ("%d", (unsigned char) data [char_nbr]);
//snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%d", (unsigned char)data [char_nbr]);
//if (data[0] == '\x7') {
// cout << " little endian " << endl;
//}
//else {
// cout << "big endian " << endl;
//}
}
}//for
printf ("\n");
/*
for (char_nbr = 0; char_nbr < size; char_nbr++) {
if (is_text) {
printf ("%c", data [char_nbr]);
snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%c", data [char_nbr]);
}
else {
printf ("%02X", (unsigned char) data [char_nbr]);
snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%02X", (unsigned char)data [size-1-char_nbr]);
}
}
*/
if (is_text) {
parsingSuccessful=reader.parse(data, parsedFromString);
if (parsingSuccessful) {
Json::StyledWriter styledWriter;
cout << "STYLED: --------------------------------" << endl;
cout << styledWriter.write(parsedFromString) << endl;
cout << "----------------------------------" << endl;
cout << parsedFromString["htype"] << endl;
if (fastWriter.write(parsedFromString["htype"]).find("bsr_m-1.1") != std::string::npos) {
cout << "hash " << parsedFromString["hash"] << endl;
cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
cout << "g ts " << parsedFromString["global_timestamp"] << endl;
cout << "comp " << parsedFromString["dh_compression"] << endl;
cout << "sec " << parsedFromString["global_timestamp"]["sec"].asUInt() << endl;
cout << "nsec " << parsedFromString["global_timestamp"]["ns"].asUInt() << endl;
}
else if (fastWriter.write(parsedFromString["htype"]).find("bsr_d-1.1") != std::string::npos) {
cout << "chan " << parsedFromString["channels"] << endl;
for (Json::Value::ArrayIndex i=0; i < parsedFromString["channels"].size(); ++ i) {
cout << "name " << parsedFromString["channels"][i]["name"] << endl;
cout << "enco " << parsedFromString["channels"][i]["encoding"] << endl;
cout << "type " << parsedFromString["channels"][i]["type"] << endl;
}
}
cout << "----------------------------------" << endl;
}
}
union foo
{
char c[sizeof(double)];
double d;
} bar;
if (subMessage > 0 && subMessage%2 ==0) {
if (size==8) {
// big endian
for (char_nbr = 0; char_nbr < size; char_nbr++) {
bar.c[char_nbr]=data[size-1-char_nbr]; // THis works for big engian
}
// little endian
//for (char_nbr = 0; char_nbr < size; char_nbr++) {
// bar.c[char_nbr]=data[char_nbr];
//}
cout << "UNION D " << bar.d << endl;
double v; // = (double*) data;
memcpy(&v, bar.c, sizeof(double));
cout << "double val " << v << endl;
}
else if (size==2) {
unsigned short i;
//memcpy(&i, cmd, size);
//big endian
for (size_t n=0; n < size; n++) {
i = (i << 8) + data[n];
}
//little endian
//for (size_t n = size; n >= 0; n--) {
// i = (i << 8) + data[n];
//}
cout << "uint val " << i << endl;
/*
std::copy(data, data + 32, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 8, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 4, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 2, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
std::copy(data, data + 1, reinterpret_cast<char *>(&i));
cout << "uint16 val " << i << endl;
*/
}
}
else if (subMessage > 1 && subMessage%2 ==1) {
cout << "timestamp " << endl;
unsigned int a,b;
for (size_t n=0; n < size/2; n++) {
a = (a << 8) + data[n];
}
for (size_t n=size/2; n < size; n++) {
b = (b << 8) + data[n];
}
cout << "a " << a << " b " << b << endl;
}
++subMessage;
} //ifelse
int64_t more; // Multipart detection
more = 0;
size_t more_size = sizeof (more);
zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
zmq_msg_close (&message);
if (!more) {
puts ("//END----------------------------------------//");
break; // Last message part
}
} //while 1
}
// Set simple random printable identity on socket
//
static void
s_set_id (void *socket)
{
char identity [10];
sprintf (identity, "%04X-%04X", randof (0x10000), randof (0x10000));
zmq_setsockopt (socket, ZMQ_IDENTITY, identity, strlen (identity));
}
/*
// Sleep for a number of milliseconds
static void
s_sleep (int msecs)
{
#if (defined (WIN32))
Sleep (msecs);
#else
struct timespec t;
t.tv_sec = msecs / 1000;
t.tv_nsec = (msecs % 1000) * 1000000;
nanosleep (&t, NULL);
#endif
}
*/
// Return current system clock as milliseconds
static int64_t
s_clock (void)
{
#if (defined (WIN32))
SYSTEMTIME st;
GetSystemTime (&st);
return (int64_t) st.wSecond * 1000 + st.wMilliseconds;
#else
struct timeval tv;
gettimeofday (&tv, NULL);
return (int64_t) (tv.tv_sec * 1000 + tv.tv_usec / 1000);
#endif
}
// Print formatted string to stdout, prefixed by date/time and
// terminated with a newline.
/*
static void
s_console (const char *format, ...)
{
time_t curtime = time (NULL);
struct tm *loctime = localtime (&curtime);
char *formatted = (char*)malloc (20);
strftime (formatted, 20, "%y-%m-%d %H:%M:%S ", loctime);
printf ("%s", formatted);
free (formatted);
va_list argptr;
va_start (argptr, format);
vprintf (format, argptr);
va_end (argptr);
printf ("\n");
}
*/
#endif // __ZHELPERS_H_INCLUDED__
#endif