831 lines
22 KiB
C++
831 lines
22 KiB
C++
/* =====================================================================
|
|
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
|