mario/IMCtermite
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #31 from jgoedeke/master

Browse Source 
Add multi component parsing to support XY-datasets
This commit is contained in:
Mario Fink 2025-01-20 20:22:12 +01:00 committed by GitHub
commit be282a8aae
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 429 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

493
lib/imc_channel.hpp
View File

@ -5,6 +5,7 @@
#include "imc_datatype.hpp" #include "imc_datatype.hpp"
#include "imc_conversion.hpp" #include "imc_conversion.hpp"
#include "imc_block.hpp"
#include <sstream> #include <sstream>
#include <math.h> #include <math.h>
#include <chrono> #include <chrono>
@ -20,34 +21,62 @@
namespace imc namespace imc
{ {
struct component_env
{
std::string uuid_;
// required channel components for CG channels only
std::string CCuuid_, CPuuid_;
// optional channel components for CG channels only
std::string CDuuid_, NTuuid_;
std::string Cbuuid_, CRuuid_;
// reset all members
void reset()
{
uuid_.clear();
CCuuid_.clear();
CPuuid_.clear();
CDuuid_.clear();
Cbuuid_.clear();
CRuuid_.clear();
NTuuid_.clear();
}
};
// collect uuid's of blocks required for full channel reconstruction // collect uuid's of blocks required for full channel reconstruction
struct channel_env struct channel_env
{ {
// define unique identifer for channel_env // define unique identifer for channel_env
std::string uuid_; std::string uuid_;
// collect common affiliate blocks for every channel
std::string NOuuid_, NLuuid_;
// collect affiliate blocks for a single channel // collect affiliate blocks for a single channel
std::string CBuuid_, CGuuid_, CCuuid_, CNuuid_; // channel types
std::string CDuuid_, CTuuid_, Cbuuid_, CPuuid_, CRuuid_, CSuuid_; std::string CBuuid_, CGuuid_, CIuuid_, CTuuid_;
std::string NTuuid_, NOuuid_, NLuuid_; std::string CNuuid_, CDuuid_, NTuuid_;
std::string CSuuid_;
component_env compenv1_;
component_env compenv2_;
// reset all members // reset all members
void reset() void reset()
{ {
uuid_.clear(); uuid_.clear();
CBuuid_.clear();
CGuuid_.clear();
CCuuid_.clear();
CNuuid_.clear();
CDuuid_.clear();
CTuuid_.clear();
Cbuuid_.clear();
CPuuid_.clear();
CRuuid_.clear();
CSuuid_.clear();
NTuuid_.clear();
NOuuid_.clear(); NOuuid_.clear();
NLuuid_.clear(); NLuuid_.clear();
CBuuid_.clear();
CGuuid_.clear();
CIuuid_.clear();
CTuuid_.clear();
CNuuid_.clear();
CDuuid_.clear();
NTuuid_.clear();
CSuuid_.clear();
compenv1_.reset();
compenv2_.reset();
} }
// get info // get info
@ -55,21 +84,23 @@ namespace imc
{ {
std::stringstream ss; std::stringstream ss;
ss<<std::setw(width)<<std::left<<"uuid:"<<uuid_<<"\n" ss<<std::setw(width)<<std::left<<"uuid:"<<uuid_<<"\n"
<<std::setw(width)<<std::left<<"NOuuid:"<<NOuuid_<<"\n"
<<std::setw(width)<<std::left<<"NLuuid:"<<NLuuid_<<"\n"
//
<<std::setw(width)<<std::left<<"CBuuid:"<<CBuuid_<<"\n" <<std::setw(width)<<std::left<<"CBuuid:"<<CBuuid_<<"\n"
<<std::setw(width)<<std::left<<"CGuuid:"<<CGuuid_<<"\n" <<std::setw(width)<<std::left<<"CGuuid:"<<CGuuid_<<"\n"
<<std::setw(width)<<std::left<<"CCuuid:"<<CCuuid_<<"\n" <<std::setw(width)<<std::left<<"CIuuid:"<<CIuuid_<<"\n"
<<std::setw(width)<<std::left<<"CTuuid:"<<CTuuid_<<"\n"
<<std::setw(width)<<std::left<<"CNuuid:"<<CNuuid_<<"\n" <<std::setw(width)<<std::left<<"CNuuid:"<<CNuuid_<<"\n"
// //
<<std::setw(width)<<std::left<<"CDuuid:"<<CDuuid_<<"\n" <<std::setw(width)<<std::left<<"CCuuid:"<<compenv1_.CCuuid_<<"\n"
<<std::setw(width)<<std::left<<"CTuuid:"<<CTuuid_<<"\n" <<std::setw(width)<<std::left<<"CPuuid:"<<compenv1_.CPuuid_<<"\n"
<<std::setw(width)<<std::left<<"Cbuuid:"<<Cbuuid_<<"\n"
<<std::setw(width)<<std::left<<"CPuuid:"<<CPuuid_<<"\n"
<<std::setw(width)<<std::left<<"CRuuid:"<<CRuuid_<<"\n"
<<std::setw(width)<<std::left<<"CSuuid:"<<CSuuid_<<"\n"
// //
<<std::setw(width)<<std::left<<"NTuuid:"<<NTuuid_<<"\n" <<std::setw(width)<<std::left<<"CDuuid:"<<compenv1_.CDuuid_<<"\n"
<<std::setw(width)<<std::left<<"NOuuid:"<<NOuuid_<<"\n" <<std::setw(width)<<std::left<<"Cbuuid:"<<compenv1_.Cbuuid_<<"\n"
<<std::setw(width)<<std::left<<"NLuuid:"<<NLuuid_<<"\n"; <<std::setw(width)<<std::left<<"CRuuid:"<<compenv1_.CRuuid_<<"\n"
<<std::setw(width)<<std::left<<"NTuuid:"<<compenv1_.NTuuid_<<"\n"
<<std::setw(width)<<std::left<<"CSuuid:"<<CSuuid_<<"\n";
return ss.str(); return ss.str();
} }
@ -78,19 +109,20 @@ namespace imc
{ {
std::stringstream ss; std::stringstream ss;
ss<<"{"<<"\"uuid\":\""<<uuid_ ss<<"{"<<"\"uuid\":\""<<uuid_
<<"\",\"CBuuid\":\""<<CBuuid_
<<"\",\"CGuuid\":\""<<CGuuid_
<<"\",\"CCuuid\":\""<<CCuuid_
<<"\",\"CNuuid\":\""<<CNuuid_
<<"\",\"CDuuid\":\""<<CDuuid_
<<"\",\"CTuuid\":\""<<CTuuid_
<<"\",\"Cbuuid\":\""<<Cbuuid_
<<"\",\"CPuuid\":\""<<CPuuid_
<<"\",\"CRuuid\":\""<<CRuuid_
<<"\",\"CSuuid\":\""<<CSuuid_
<<"\",\"NTuuid\":\""<<NTuuid_
<<"\",\"NOuuid\":\""<<NOuuid_ <<"\",\"NOuuid\":\""<<NOuuid_
<<"\",\"NLuuid\":\""<<NLuuid_ <<"\",\"NLuuid\":\""<<NLuuid_
<<"\",\"CBuuid\":\""<<CBuuid_
<<"\",\"CGuuid\":\""<<CGuuid_
<<"\",\"CIuuid\":\""<<CIuuid_
<<"\",\"CTuuid\":\""<<CTuuid_
<<"\",\"CNuuid\":\""<<CNuuid_
<<"\",\"CCuuid\":\""<<compenv1_.CCuuid_
<<"\",\"CPuuid\":\""<<compenv1_.CPuuid_
<<"\",\"CDuuid\":\""<<compenv1_.CDuuid_
<<"\",\"Cbuuid\":\""<<compenv1_.Cbuuid_
<<"\",\"CRuuid\":\""<<compenv1_.CRuuid_
<<"\",\"NTuuid\":\""<<compenv1_.NTuuid_
<<"\",\"CSuuid\":\""<<CSuuid_
<<"\"}"; <<"\"}";
return ss.str(); return ss.str();
} }
@ -229,6 +261,50 @@ namespace imc
}; };
#endif #endif
struct component_group
{
imc::component CC_;
imc::packaging CP_;
imc::abscissa CD_;
imc::buffer Cb_;
imc::range CR_;
imc::channelobj CN_;
imc::triggertime NT_;
component_env compenv_;
// Constructor to parse the associated blocks
component_group(component_env &compenv, std::map<std::string, imc::block>* blocks, std::vector<unsigned char>* buffer)
: compenv_(compenv)
{
if (blocks->count(compenv.CCuuid_) == 1)
{
CC_.parse(buffer, blocks->at(compenv.CCuuid_).get_parameters());
}
if (blocks->count(compenv.CPuuid_) == 1)
{
CP_.parse(buffer, blocks->at(compenv.CPuuid_).get_parameters());
}
if (blocks->count(compenv.CDuuid_) == 1)
{
CD_.parse(buffer, blocks->at(compenv.CDuuid_).get_parameters());
}
if (blocks->count(compenv.Cbuuid_) == 1)
{
Cb_.parse(buffer, blocks->at(compenv.Cbuuid_).get_parameters());
}
if (blocks->count(compenv.CRuuid_) == 1)
{
CR_.parse(buffer, blocks->at(compenv.CRuuid_).get_parameters());
}
if (blocks->count(compenv.NTuuid_) == 1)
{
NT_.parse(buffer, blocks->at(compenv.NTuuid_).get_parameters());
}
}
};
// channel // channel
struct channel struct channel
{ {
@ -237,8 +313,15 @@ namespace imc
std::map<std::string,imc::block>* blocks_; std::map<std::string,imc::block>* blocks_;
std::vector<unsigned char>* buffer_; std::vector<unsigned char>* buffer_;
imc::origin_data NO_;
imc::text CT_;
imc::groupobj CB_;
imc::datafield CG_;
// collect meta-data of channels according to env, // collect meta-data of channels according to env,
// just everything valueable in here // just everything valueable in here
// TODO: is this necessary?
std::string uuid_; std::string uuid_;
std::string name_, comment_; std::string name_, comment_;
std::string origin_, origin_comment_, text_; std::string origin_, origin_comment_, text_;
@ -247,21 +330,23 @@ namespace imc
std::string language_code_, codepage_; std::string language_code_, codepage_;
std::string yname_, yunit_; std::string yname_, yunit_;
std::string xname_, xunit_; std::string xname_, xunit_;
double xstepwidth_, xoffset_; double xstepwidth_, xstart_;
int xprec_; int xprec_;
int dimension_;
// buffer and data // buffer and data
int signbits_, num_bytes_; int xsignbits_, xnum_bytes_;
int ysignbits_, ynum_bytes_;
// unsigned long int byte_offset_; // unsigned long int byte_offset_;
unsigned long int buffer_offset_, buffer_size_; unsigned long int xbuffer_offset_, ybuffer_offset_;
unsigned long int xbuffer_size_, ybuffer_size_;
long int addtime_; long int addtime_;
int datatp_; imc::numtype xdatatp_, ydatatp_;
imc::datatype dattyp_; std::vector<imc::datatype> xdata_, ydata_;
std::vector<imc::datatype> ydata_;
std::vector<double> xdata_;
// range, factor and offset // range, factor and offset
double factor_, offset_; double xfactor_, yfactor_;
double xoffset_, yoffset_;
// group reference the channel belongs to // group reference the channel belongs to
int group_index_; int group_index_;
@ -271,130 +356,92 @@ namespace imc
channel(channel_env &chnenv, std::map<std::string,imc::block>* blocks, channel(channel_env &chnenv, std::map<std::string,imc::block>* blocks,
std::vector<unsigned char>* buffer): std::vector<unsigned char>* buffer):
chnenv_(chnenv), blocks_(blocks), buffer_(buffer), chnenv_(chnenv), blocks_(blocks), buffer_(buffer),
factor_(1.), offset_(0.), xfactor_(1.), yfactor_(1.), xoffset_(0.), yoffset_(0.),
group_index_(-1) group_index_(-1)
{ {
// declare list of block parameters
std::vector<imc::parameter> prms;
// use uuid from CN block // use uuid from CN block
uuid_ = chnenv_.CNuuid_; uuid_ = chnenv_.CNuuid_;
// extract associated CB data // extract associated CB data
if ( blocks_->count(chnenv_.CBuuid_) == 1 ) if ( blocks_->count(chnenv_.CBuuid_) == 1 )
{ {
prms = blocks_->at(chnenv_.CBuuid_).get_parameters(); CB_.parse(buffer_, blocks_->at(chnenv_.CBuuid_).get_parameters());
group_index_ = std::stoi(blocks_->at(chnenv_.CBuuid_).get_parameter(prms[2]));
group_name_ = blocks_->at(chnenv_.CBuuid_).get_parameter(prms[4]);
group_comment_ = blocks_->at(chnenv_.CBuuid_).get_parameter(prms[6]);
} }
// extract associated CT data // extract associated CT data
if ( blocks_->count(chnenv_.CTuuid_) == 1 ) if ( blocks_->count(chnenv_.CTuuid_) == 1 )
{ {
prms = blocks_->at(chnenv_.CTuuid_).get_parameters(); CT_.parse(buffer_, blocks_->at(chnenv_.CTuuid_).get_parameters());
text_ = blocks_->at(chnenv_.CTuuid_).get_parameter(prms[4]) + std::string(" - ") text_ = CT_.name_ + std::string(" - ")
+ blocks_->at(chnenv_.CTuuid_).get_parameter(prms[6]) + std::string(" - ") + CT_.text_ + std::string(" - ")
+ blocks_->at(chnenv_.CTuuid_).get_parameter(prms[8]); + CT_.comment_;
} }
// extract associated CD data if ( !chnenv_.compenv1_.uuid_.empty() && chnenv_.compenv2_.uuid_.empty() )
if ( blocks_->count(chnenv_.CDuuid_) == 1 )
{ {
prms = blocks_->at(chnenv_.CDuuid_).get_parameters(); // normal dataset (single component)
xstepwidth_ = std::stod(blocks_->at(chnenv_.CDuuid_).get_parameter(prms[2])); // set common NT and CD keys if no others are specified
xunit_ = blocks_->at(chnenv_.CDuuid_).get_parameter(prms[5]); if (chnenv_.compenv1_.NTuuid_.empty()) chnenv_.compenv1_.NTuuid_ = chnenv_.NTuuid_;
// TODO if (chnenv_.compenv1_.CDuuid_.empty()) chnenv_.compenv1_.CDuuid_ = chnenv_.CDuuid_;
// xname_ = std::string("time");
// find appropriate precision for "xdata_" by means of "xstepwidth_" // comp_group1 contains y-data, x-data is based on xstepwidth_, xstart_ and the length of y-data
xprec_ = (xstepwidth_ > 0 ) ? (int)ceil(fabs(log10(xstepwidth_))) : 10; component_group comp_group1(chnenv_.compenv1_, blocks_, buffer_);
} dimension_ = 1;
// extract associated CP data
if ( blocks_->count(chnenv_.CPuuid_) == 1 )
{
prms = blocks_->at(chnenv_.CPuuid_).get_parameters();
num_bytes_ = std::stoi(blocks_->at(chnenv_.CPuuid_).get_parameter(prms[3]));
datatp_ = std::stoi(blocks_->at(chnenv_.CPuuid_).get_parameter(prms[4]));
signbits_ = std::stoi(blocks_->at(chnenv_.CPuuid_).get_parameter(prms[5]));
// byte_offset_ = std::stoul(blocks_->at(chnenv_.CPuuid_).get_parameter(prms[7]));
}
// extract associated Cb data
if ( blocks_->count(chnenv_.Cbuuid_) == 1 )
{
prms = blocks_->at(chnenv_.Cbuuid_).get_parameters();
buffer_offset_ = std::stoul(blocks_->at(chnenv_.Cbuuid_).get_parameter(prms[6]));
buffer_size_ = std::stoul(blocks_->at(chnenv_.Cbuuid_).get_parameter(prms[7]));
xoffset_ = std::stod(blocks_->at(chnenv_.Cbuuid_).get_parameter(prms[11]));
addtime_ = (long int)std::stod(blocks_->at(chnenv_.Cbuuid_).get_parameter(prms[12]));
}
// extract associated CR data
if ( blocks_->count(chnenv_.CRuuid_) == 1 )
{
prms = blocks_->at(chnenv_.CRuuid_).get_parameters();
factor_ = std::stod(blocks_->at(chnenv_.CRuuid_).get_parameter(prms[3]));
offset_ = std::stod(blocks_->at(chnenv_.CRuuid_).get_parameter(prms[4]));
yunit_ = blocks_->at(chnenv_.CRuuid_).get_parameter(prms[7]);
}
// extract associated CN data
if ( blocks_->count(chnenv_.CNuuid_) == 1 )
{
prms = blocks_->at(chnenv_.CNuuid_).get_parameters();
name_ = blocks_->at(chnenv_.CNuuid_).get_parameter(prms[6]);
yname_ = name_;
comment_ = blocks_->at(chnenv_.CNuuid_).get_parameter(prms[8]);
// group_index_ = std::stoi(blocks_->at(chnenv_.CNuuid_).get_parameter(prms[2]));
}
// extract associated NO data
if ( blocks_->count(chnenv_.NOuuid_) == 1 )
{
prms = blocks_->at(chnenv_.NOuuid_).get_parameters();
origin_ = blocks_->at(chnenv_.NOuuid_).get_parameter(prms[4]);
origin_comment_ = blocks_->at(chnenv_.NOuuid_).get_parameter(prms[6]);
}
// extract associated NL data
// codepage:
// - http://www.iana.org/assignments/character-sets/character-sets.xhtml
// - https://de.wikipedia.org/wiki/Zeichensatztabelle
// language-code:
// - https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-lcid/a9eac961-e77d-41a6-90a5-ce1a8b0cdb9c?redirectedfrom=MSDN
if ( blocks_->count(chnenv_.NLuuid_) == 1 )
{
prms = blocks_->at(chnenv_.NLuuid_).get_parameters();
codepage_ = blocks_->at(chnenv_.NLuuid_).get_parameter(prms[2]);
language_code_ = blocks_->at(chnenv_.NLuuid_).get_parameter(prms[3]);
}
// obtain NT data
// - https://en.cppreference.com/w/cpp/chrono/c/tm
// - https://en.cppreference.com/w/cpp/io/manip/put_time
if ( blocks_->count(chnenv_.NTuuid_) == 1 )
{
prms = blocks_->at(chnenv_.NTuuid_).get_parameters();
//std::tm tm{};
std::tm tms = std::tm();
tms.tm_mday = std::stoi(blocks_->at(chnenv_.NTuuid_).get_parameter(prms[2]));
tms.tm_mon = std::stoi(blocks_->at(chnenv_.NTuuid_).get_parameter(prms[3])) - 1;
tms.tm_year = std::stoi(blocks_->at(chnenv_.NTuuid_).get_parameter(prms[4])) - 1900;
tms.tm_hour = std::stoi(blocks_->at(chnenv_.NTuuid_).get_parameter(prms[5]));
tms.tm_min = std::stoi(blocks_->at(chnenv_.NTuuid_).get_parameter(prms[6]));
long double secs = std::stold(blocks_->at(chnenv_.NTuuid_).get_parameter(prms[7]));
double secs_int;
trigger_time_frac_secs_ = modf((double)secs,&secs_int);
tms.tm_sec = (int)secs_int;
//tms.tm_isdst = -1;
xstepwidth_ = comp_group1.CD_.dx_;
xunit_ = comp_group1.CD_.unit_;
ybuffer_offset_ = comp_group1.Cb_.offset_buffer_;
ybuffer_size_ = comp_group1.Cb_.number_bytes_;
xstart_ = comp_group1.Cb_.x0_;
addtime_ = static_cast<long int>(comp_group1.Cb_.add_time_);
yfactor_ = comp_group1.CR_.factor_;
yoffset_ = comp_group1.CR_.offset_;
yunit_ = comp_group1.CR_.unit_;
name_ = comp_group1.CN_.name_;
yname_ = comp_group1.CN_.name_;
comment_ = comp_group1.CN_.comment_;
ynum_bytes_ = comp_group1.CP_.bytes_;
ydatatp_ = comp_group1.CP_.numeric_type_;
ysignbits_ = comp_group1.CP_.signbits_;
// generate std::chrono::system_clock::time_point type // generate std::chrono::system_clock::time_point type
// ( - https://www.gnu.org/software/libc/manual/html_node/Broken_002ddown-Time.html std::time_t ts = timegm(&comp_group1.NT_.tms_); // std::mktime(&tms);
// - https://man7.org/linux/man-pages/man3/tzset.3.html )
std::time_t ts = timegm(&tms); //std::mktime(&tms);
trigger_time_ = std::chrono::system_clock::from_time_t(ts); trigger_time_ = std::chrono::system_clock::from_time_t(ts);
trigger_time_frac_secs_ = comp_group1.NT_.trigger_time_frac_secs_;
}
else if ( !chnenv_.compenv1_.uuid_.empty() && !chnenv_.compenv2_.uuid_.empty() )
{
// XY dataset (two components)
// set common NT and CD keys if no others are specified
if (chnenv_.compenv1_.NTuuid_.empty()) chnenv_.compenv1_.NTuuid_ = chnenv_.NTuuid_;
if (chnenv_.compenv1_.CDuuid_.empty()) chnenv_.compenv1_.CDuuid_ = chnenv_.CDuuid_;
if (chnenv_.compenv2_.NTuuid_.empty()) chnenv_.compenv2_.NTuuid_ = chnenv_.NTuuid_;
if (chnenv_.compenv2_.CDuuid_.empty()) chnenv_.compenv2_.CDuuid_ = chnenv_.CDuuid_;
// comp_group1 contains x-data, comp_group2 contains y-data
component_group comp_group1(chnenv_.compenv1_, blocks_, buffer_);
component_group comp_group2(chnenv_.compenv2_, blocks_, buffer_);
dimension_ = 2;
xbuffer_offset_ = comp_group2.Cb_.offset_buffer_;
xbuffer_size_ = comp_group2.Cb_.number_bytes_;
ybuffer_offset_ = comp_group1.Cb_.offset_buffer_;
ybuffer_size_ = comp_group1.Cb_.number_bytes_;
xfactor_ = comp_group2.CR_.factor_;
xoffset_ = comp_group2.CR_.offset_;
yfactor_ = comp_group1.CR_.factor_;
yoffset_ = comp_group1.CR_.offset_;
xdatatp_ = comp_group2.CP_.numeric_type_;
xsignbits_ = comp_group2.CP_.signbits_;
ydatatp_ = comp_group1.CP_.numeric_type_;
ysignbits_ = comp_group1.CP_.signbits_;
// generate std::chrono::system_clock::time_point type
std::time_t ts = timegm(&comp_group2.NT_.tms_); // std::mktime(&tms);
trigger_time_ = std::chrono::system_clock::from_time_t(ts);
trigger_time_frac_secs_ = comp_group2.NT_.trigger_time_frac_secs_;
}
else
{
// no datafield
} }
// start converting binary buffer to imc::datatype // start converting binary buffer to imc::datatype
@ -419,76 +466,109 @@ namespace imc
// extract (channel dependent) part of buffer // extract (channel dependent) part of buffer
unsigned long int buffstrt = prms[3].begin(); unsigned long int buffstrt = prms[3].begin();
std::vector<unsigned char> CSbuffer( buffer_->begin()+buffstrt+buffer_offset_+1, std::vector<unsigned char> yCSbuffer( buffer_->begin()+buffstrt+ybuffer_offset_+1,
buffer_->begin()+buffstrt+buffer_offset_+buffer_size_+1 ); buffer_->begin()+buffstrt+ybuffer_offset_+ybuffer_size_+1 );
// determine number of values in buffer // determine number of values in buffer
unsigned long int num_values = (unsigned long int)(CSbuffer.size()/(signbits_/8)); unsigned long int ynum_values = (unsigned long int)(yCSbuffer.size()/(ysignbits_/8));
if ( num_values*(signbits_/8) != CSbuffer.size() ) if ( ynum_values*(ysignbits_/8) != yCSbuffer.size() )
{ {
throw std::runtime_error("CSbuffer and significant bits of datatype don't match"); throw std::runtime_error("CSbuffer and significant bits of y datatype don't match");
} }
// adjust size of ydata
ydata_.resize(num_values);
// distinguish numeric datatypes included in "imc_datatype" if (dimension_ == 1)
if ( datatp_ == 1 )
{ {
imc::convert_data_to_type<imc_Ubyte>(CSbuffer,ydata_); // process y-data
process_data(ydata_, ynum_values, ydatatp_, yCSbuffer);
// find appropriate precision for "xdata_" by means of "xstepwidth_"
xprec_ = (xstepwidth_ > 0 ) ? (int)ceil(fabs(log10(xstepwidth_))) : 10;
// fill xdata_
for ( unsigned long int i = 0; i < ynum_values; i++ )
{
xdata_.push_back(xstart_+(double)i*xstepwidth_);
} }
else if ( datatp_ == 2 )
{
imc::convert_data_to_type<imc_Sbyte>(CSbuffer,ydata_);
} }
else if ( datatp_ == 3 ) else if (dimension_ == 2)
{ {
imc::convert_data_to_type<imc_Ushort>(CSbuffer,ydata_); // process x- and y-data
std::vector<unsigned char> xCSbuffer( buffer_->begin()+buffstrt+xbuffer_offset_+1,
buffer_->begin()+buffstrt+xbuffer_offset_+xbuffer_size_+1 );
// determine number of values in buffer
unsigned long int xnum_values = (unsigned long int)(xCSbuffer.size()/(xsignbits_/8));
if ( xnum_values*(xsignbits_/8) != xCSbuffer.size() )
{
throw std::runtime_error("CSbuffer and significant bits of x datatype don't match");
} }
else if ( datatp_ == 4 ) if ( xnum_values != ynum_values )
{ {
imc::convert_data_to_type<imc_Sshort>(CSbuffer,ydata_); throw std::runtime_error("x and y data have different number of values");
} }
else if ( datatp_ == 5 )
{ process_data(xdata_, xnum_values, xdatatp_, xCSbuffer);
imc::convert_data_to_type<imc_Ulongint>(CSbuffer,ydata_); process_data(ydata_, ynum_values, ydatatp_, yCSbuffer);
}
else if ( datatp_ == 6 )
{
imc::convert_data_to_type<imc_Slongint>(CSbuffer,ydata_);
}
else if ( datatp_ == 7 )
{
imc::convert_data_to_type<imc_float>(CSbuffer,ydata_);
}
else if ( datatp_ == 8 )
{
imc::convert_data_to_type<imc_double>(CSbuffer,ydata_);
}
// ...
else if ( datatp_ == 11 )
{
imc::convert_data_to_type<imc_digital>(CSbuffer,ydata_);
} }
else else
{ {
throw std::runtime_error(std::string("unsupported/unknown datatype") + std::to_string(datatp_)); throw std::runtime_error("unsupported dimension");
} }
// fill xdata_ transformData(xdata_, xfactor_, xoffset_);
for ( unsigned long int i = 0; i < num_values; i++ ) transformData(ydata_, yfactor_, yoffset_);
{
xdata_.push_back(xoffset_+(double)i*xstepwidth_);
} }
// employ data transformation // handle data type conversion
if ( factor_ != 1.0 || offset_ != 0.0 ) void process_data(std::vector<imc::datatype>& data_, size_t num_values, numtype datatp_, std::vector<unsigned char>& CSbuffer)
{ {
for ( imc::datatype& el: ydata_ ) // adjust size of data
data_.resize(num_values);
// handle data type conversion
switch (datatp_)
{ {
//std::cout<<"value:"<<el.as_double()<<"\n"; case numtype::unsigned_byte:
double fact = ( factor_ == 0.0 ) ? 1.0 : factor_; imc::convert_data_to_type<imc_Ubyte>(CSbuffer, data_);
el = imc::datatype(el.as_double()*fact + offset_); break;
case numtype::signed_byte:
imc::convert_data_to_type<imc_Sbyte>(CSbuffer, data_);
break;
case numtype::unsigned_short:
imc::convert_data_to_type<imc_Ushort>(CSbuffer, data_);
break;
case numtype::signed_short:
imc::convert_data_to_type<imc_Sshort>(CSbuffer, data_);
break;
case numtype::unsigned_long:
imc::convert_data_to_type<imc_Ulongint>(CSbuffer, data_);
break;
case numtype::signed_long:
imc::convert_data_to_type<imc_Slongint>(CSbuffer, data_);
break;
case numtype::ffloat:
imc::convert_data_to_type<imc_float>(CSbuffer, data_);
break;
case numtype::ddouble:
imc::convert_data_to_type<imc_double>(CSbuffer, data_);
break;
case numtype::two_byte_word_digital:
imc::convert_data_to_type<imc_digital>(CSbuffer, data_);
break;
case numtype::six_byte_unsigned_long:
imc::convert_data_to_type<imc_sixbyte>(CSbuffer, data_);
break;
default:
throw std::runtime_error(std::string("unsupported/unknown datatype ") + std::to_string(datatp_));
}
}
void transformData(std::vector<imc::datatype>& data, double factor, double offset) {
if (factor != 1.0 || offset != 0.0) {
for (imc::datatype& el : data) {
double fact = (factor == 0.0) ? 1.0 : factor;
el = imc::datatype(el.as_double() * fact + offset);
} }
} }
} }
@ -540,21 +620,21 @@ namespace imc
<<std::setw(width)<<std::left<<"codepage:"<<codepage_<<"\n" <<std::setw(width)<<std::left<<"codepage:"<<codepage_<<"\n"
<<std::setw(width)<<std::left<<"yname:"<<yname_<<"\n" <<std::setw(width)<<std::left<<"yname:"<<yname_<<"\n"
<<std::setw(width)<<std::left<<"yunit:"<<yunit_<<"\n" <<std::setw(width)<<std::left<<"yunit:"<<yunit_<<"\n"
<<std::setw(width)<<std::left<<"datatype:"<<datatp_<<"\n" <<std::setw(width)<<std::left<<"datatype:"<<ydatatp_<<"\n"
<<std::setw(width)<<std::left<<"significant bits:"<<signbits_<<"\n" <<std::setw(width)<<std::left<<"significant bits:"<<ysignbits_<<"\n"
<<std::setw(width)<<std::left<<"buffer-offset:"<<buffer_offset_<<"\n" <<std::setw(width)<<std::left<<"buffer-offset:"<<ybuffer_offset_<<"\n"
<<std::setw(width)<<std::left<<"buffer-size:"<<buffer_size_<<"\n" <<std::setw(width)<<std::left<<"buffer-size:"<<ybuffer_size_<<"\n"
<<std::setw(width)<<std::left<<"add-time:"<<addtime_<<"\n" <<std::setw(width)<<std::left<<"add-time:"<<addtime_<<"\n"
<<std::setw(width)<<std::left<<"xname:"<<xname_<<"\n" <<std::setw(width)<<std::left<<"xname:"<<xname_<<"\n"
<<std::setw(width)<<std::left<<"xunit:"<<xunit_<<"\n" <<std::setw(width)<<std::left<<"xunit:"<<xunit_<<"\n"
<<std::setw(width)<<std::left<<"xstepwidth:"<<xstepwidth_<<"\n" <<std::setw(width)<<std::left<<"xstepwidth:"<<xstepwidth_<<"\n"
<<std::setw(width)<<std::left<<"xoffset:"<<xoffset_<<"\n" <<std::setw(width)<<std::left<<"xoffset:"<<xstart_<<"\n"
<<std::setw(width)<<std::left<<"factor:"<<factor_<<"\n" <<std::setw(width)<<std::left<<"factor:"<<yfactor_<<"\n"
<<std::setw(width)<<std::left<<"offset:"<<offset_<<"\n" <<std::setw(width)<<std::left<<"offset:"<<yoffset_<<"\n"
<<std::setw(width)<<std::left<<"group:"<<"("<<group_index_<<","<<group_name_ <<std::setw(width)<<std::left<<"group:"<<"("<<group_index_<<","<<group_name_
<<","<<group_comment_<<")"<<"\n" <<","<<group_comment_<<")"<<"\n"
<<std::setw(width)<<std::left<<"ydata:"<<imc::joinvec<imc::datatype>(ydata_,6,9,true)<<"\n" <<std::setw(width)<<std::left<<"ydata:"<<imc::joinvec<imc::datatype>(ydata_,6,9,true)<<"\n"
<<std::setw(width)<<std::left<<"xdata:"<<imc::joinvec<double>(xdata_,6,xprec_,true)<<"\n"; <<std::setw(width)<<std::left<<"xdata:"<<imc::joinvec<imc::datatype>(xdata_,6,xprec_,true)<<"\n";
// <<std::setw(width)<<std::left<<"aff. blocks:"<<chnenv_.get_json()<<"\n"; // <<std::setw(width)<<std::left<<"aff. blocks:"<<chnenv_.get_json()<<"\n";
return ss.str(); return ss.str();
} }
@ -579,19 +659,20 @@ namespace imc
<<"\",\"codepage\":\""<<codepage_ <<"\",\"codepage\":\""<<codepage_
<<"\",\"yname\":\""<<prepjsonstr(yname_) <<"\",\"yname\":\""<<prepjsonstr(yname_)
<<"\",\"yunit\":\""<<prepjsonstr(yunit_) <<"\",\"yunit\":\""<<prepjsonstr(yunit_)
<<"\",\"significantbits\":\""<<signbits_ <<"\",\"significantbits\":\""<<ysignbits_
<<"\",\"addtime\":\""<<addtime_ <<"\",\"addtime\":\""<<addtime_
<<"\",\"buffer-size\":\""<<ybuffer_size_
<<"\",\"xname\":\""<<prepjsonstr(xname_) <<"\",\"xname\":\""<<prepjsonstr(xname_)
<<"\",\"xunit\":\""<<prepjsonstr(xunit_) <<"\",\"xunit\":\""<<prepjsonstr(xunit_)
<<"\",\"xstepwidth\":\""<<xstepwidth_ <<"\",\"xstepwidth\":\""<<xstepwidth_
<<"\",\"xoffset\":\""<<xoffset_ <<"\",\"xoffset\":\""<<xstart_
<<"\",\"group\":{"<<"\"index\":\""<<group_index_ <<"\",\"group\":{"<<"\"index\":\""<<group_index_
<<"\",\"name\":\""<<group_name_ <<"\",\"name\":\""<<group_name_
<<"\",\"comment\":\""<<group_comment_<<"\""<<"}"; <<"\",\"comment\":\""<<group_comment_<<"\""<<"}";
if ( include_data ) if ( include_data )
{ {
ss<<",\"ydata\":"<<imc::joinvec<imc::datatype>(ydata_,0,9,true) ss<<",\"ydata\":"<<imc::joinvec<imc::datatype>(ydata_,0,9,true)
<<",\"xdata\":"<<imc::joinvec<double>(xdata_,0,xprec_,true); <<",\"xdata\":"<<imc::joinvec<imc::datatype>(xdata_,0,xprec_,true);
} }
// ss<<"\",\"aff. blocks\":\""<<chnenv_.get_json() // ss<<"\",\"aff. blocks\":\""<<chnenv_.get_json()
ss<<"}"; ss<<"}";

50
lib/imc_datatype.hpp
View File

@ -16,12 +16,12 @@ namespace imc
// //
// e.g. ARM Cortex-A72 armv7l gcc version 10.2.0 (Ubuntu 10.2.0-13ubuntu1) // e.g. ARM Cortex-A72 armv7l gcc version 10.2.0 (Ubuntu 10.2.0-13ubuntu1)
// #ifdef __arm__ // #ifdef __arm__
typedef unsigned long int imc_Ulongint; // typedef unsigned long int imc_Ulongint;
typedef signed long int imc_Slongint; // typedef signed long int imc_Slongint;
// e.g. Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz x86_64 gcc version 10.2.0 (Ubuntu 10.2.0-13ubuntu1) // e.g. Intel(R) Core(TM) i7-3520M CPU @ 2.90GHz x86_64 gcc version 10.2.0 (Ubuntu 10.2.0-13ubuntu1)
// #ifdef i386 __i386 __i386__ // #ifdef i386 __i386 __i386__
// typedef unsigned int imc_Ulongint; typedef unsigned int imc_Ulongint;
// typedef signed int imc_Slongint; typedef signed int imc_Slongint;
// //
typedef float imc_float; typedef float imc_float;
typedef double imc_double; typedef double imc_double;
@ -30,7 +30,11 @@ namespace imc
// typedef <whatever that is ->... > "imc Devices Transitional Recording" // typedef <whatever that is ->... > "imc Devices Transitional Recording"
// typedf <sometimestamptype> "Timestamp Ascii" // typedf <sometimestamptype> "Timestamp Ascii"
typedef char16_t imc_digital; typedef char16_t imc_digital;
// typedef < > imc_sixbyte "6byte unsigned long" //
typedef struct {
unsigned char bytes[6];
} imc_sixbyte;
class datatype class datatype
{ {
@ -44,13 +48,14 @@ namespace imc
imc_float sfloat_; // 6 imc_float sfloat_; // 6
imc_double sdouble_; // 7 imc_double sdouble_; // 7
imc_digital sdigital_; // 10 imc_digital sdigital_; // 10
short int dtidx_; // \in \{0,...,7,10\} imc_sixbyte sixbyte_; // 13
short int dtidx_; // \in \{0,...,7,10,13\}
public: public:
datatype(): ubyte_(0), sbyte_(0), datatype(): ubyte_(0), sbyte_(0),
ushort_(0), sshort_(0), ushort_(0), sshort_(0),
ulint_(0), slint_(0), ulint_(0), slint_(0),
sfloat_(0.0), sdouble_(0.0), sfloat_(0.0), sdouble_(0.0),
sdigital_(0), sdigital_(0), sixbyte_({0}),
dtidx_(0) { }; dtidx_(0) { };
// every supported datatype gets its own constructor // every supported datatype gets its own constructor
datatype(imc_Ubyte num): ubyte_(num), dtidx_(0) {}; datatype(imc_Ubyte num): ubyte_(num), dtidx_(0) {};
@ -62,10 +67,13 @@ namespace imc
datatype(imc_float num): sfloat_(num), dtidx_(6) {}; datatype(imc_float num): sfloat_(num), dtidx_(6) {};
datatype(imc_double num): ubyte_(0), sbyte_(0), ushort_(0), sshort_(0), datatype(imc_double num): ubyte_(0), sbyte_(0), ushort_(0), sshort_(0),
ulint_(0), slint_(0), sfloat_(0.0), sdouble_(num), ulint_(0), slint_(0), sfloat_(0.0), sdouble_(num),
sdigital_(0), dtidx_(7) {}; sdigital_(0), sixbyte_({0}), dtidx_(7) {};
datatype(imc_digital num): ubyte_(0), sbyte_(0), ushort_(0), sshort_(0), datatype(imc_digital num): ubyte_(0), sbyte_(0), ushort_(0), sshort_(0),
ulint_(0), slint_(0), sfloat_(0.0), sdouble_(num), ulint_(0), slint_(0), sfloat_(0.0), sdouble_(0.0),
sdigital_(num), dtidx_(10) {}; sdigital_(num), sixbyte_({0}), dtidx_(10) {};
datatype(imc_sixbyte num): ubyte_(0), sbyte_(0), ushort_(0), sshort_(0),
ulint_(0), slint_(0), sfloat_(0.0), sdouble_(0.0),
sdigital_(0), sixbyte_(num), dtidx_(13) {};
// identify type // identify type
short int& dtype() { return dtidx_; } short int& dtype() { return dtidx_; }
@ -82,6 +90,7 @@ namespace imc
this->sfloat_ = num.sfloat_; this->sfloat_ = num.sfloat_;
this->sdouble_ = num.sdouble_; this->sdouble_ = num.sdouble_;
this->sdigital_ = num.sdigital_; this->sdigital_ = num.sdigital_;
this->sixbyte_ = num.sixbyte_;
this->dtidx_ = num.dtidx_; this->dtidx_ = num.dtidx_;
} }
@ -99,6 +108,7 @@ namespace imc
this->sfloat_ = num.sfloat_; this->sfloat_ = num.sfloat_;
this->sdouble_ = num.sdouble_; this->sdouble_ = num.sdouble_;
this->sdigital_ = num.sdigital_; this->sdigital_ = num.sdigital_;
this->sixbyte_ = num.sixbyte_;
this->dtidx_ = num.dtidx_; this->dtidx_ = num.dtidx_;
} }
@ -160,6 +170,12 @@ namespace imc
this->dtidx_ = 10; this->dtidx_ = 10;
return *this; return *this;
} }
datatype& operator=(const imc_sixbyte &num)
{
this->sixbyte_ = num;
this->dtidx_ = 13;
return *this;
}
// obtain number as double // obtain number as double
double as_double() double as_double()
@ -174,6 +190,13 @@ namespace imc
else if ( dtidx_ == 6 ) num = (double)sfloat_; else if ( dtidx_ == 6 ) num = (double)sfloat_;
else if ( dtidx_ == 7 ) num = (double)sdouble_; else if ( dtidx_ == 7 ) num = (double)sdouble_;
else if ( dtidx_ == 10 ) num = static_cast<double>(sdigital_); else if ( dtidx_ == 10 ) num = static_cast<double>(sdigital_);
else if ( dtidx_ == 13 ) {
unsigned long long value = 0;
for (int i = 0; i < 6; ++i) {
value |= static_cast<unsigned long long>(sixbyte_.bytes[i]) << (8 * i);
}
num = static_cast<double>(value);
}
return num; return num;
} }
@ -189,6 +212,13 @@ namespace imc
else if ( num.dtidx_ == 6 ) out<<num.sfloat_; else if ( num.dtidx_ == 6 ) out<<num.sfloat_;
else if ( num.dtidx_ == 7 ) out<<num.sdouble_; else if ( num.dtidx_ == 7 ) out<<num.sdouble_;
else if ( num.dtidx_ == 10 ) out<<static_cast<double>(num.sdigital_); else if ( num.dtidx_ == 10 ) out<<static_cast<double>(num.sdigital_);
else if ( num.dtidx_ == 13 ) {
unsigned long long value = 0;
for (int i = 0; i < 6; ++i) {
value |= static_cast<unsigned long long>(num.sixbyte_.bytes[i]) << (8 * i);
}
out<<static_cast<double>(value);
}
return out; return out;
} }

75
lib/imc_object.hpp
View File

@ -4,6 +4,7 @@
#define IMCOBJECT #define IMCOBJECT
#include <time.h> #include <time.h>
#include <math.h>
#include "imc_key.hpp" #include "imc_key.hpp"
//---------------------------------------------------------------------------// //---------------------------------------------------------------------------//
@ -245,7 +246,7 @@ namespace imc
// construct members by parsing particular parameters from buffer // construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters) void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{ {
if ( parameters.size() < 4 ) throw std::runtime_error("invalid number of parameters in CD2"); if ( parameters.size() < 4 ) throw std::runtime_error("invalid number of parameters in CC");
component_index_ = std::stoi(get_parameter(buffer,&parameters[2])); component_index_ = std::stoi(get_parameter(buffer,&parameters[2]));
analog_digital_ = ( std::stoi(get_parameter(buffer,&parameters[3])) == 2 ); analog_digital_ = ( std::stoi(get_parameter(buffer,&parameters[3])) == 2 );
} }
@ -272,7 +273,9 @@ namespace imc
imc_devices_transitional_recording, imc_devices_transitional_recording,
timestamp_ascii, timestamp_ascii,
two_byte_word_digital, two_byte_word_digital,
six_byte_unsigned_long eight_byte_unsigned_long,
six_byte_unsigned_long,
eight_byte_signed_long
}; };
// packaging information of component (corresponds to key CP) // packaging information of component (corresponds to key CP)
@ -292,8 +295,8 @@ namespace imc
{ {
if ( parameters.size() < 10 ) throw std::runtime_error("invalid number of parameters in CP"); if ( parameters.size() < 10 ) throw std::runtime_error("invalid number of parameters in CP");
buffer_reference_ = std::stoi(get_parameter(buffer,&parameters[2])); buffer_reference_ = std::stoi(get_parameter(buffer,&parameters[2]));
numeric_type_ = (numtype)std::stoi(get_parameter(buffer,&parameters[3])); bytes_ = std::stoi(get_parameter(buffer,&parameters[3]));
bytes_ = std::stoi(get_parameter(buffer,&parameters[4])); numeric_type_ = (numtype)std::stoi(get_parameter(buffer,&parameters[4]));
signbits_ = std::stoi(get_parameter(buffer,&parameters[5])); signbits_ = std::stoi(get_parameter(buffer,&parameters[5]));
mask_ = std::stoi(get_parameter(buffer,&parameters[6])); mask_ = std::stoi(get_parameter(buffer,&parameters[6]));
offset_ = std::stoul(get_parameter(buffer,&parameters[7])); offset_ = std::stoul(get_parameter(buffer,&parameters[7]));
@ -336,7 +339,7 @@ namespace imc
// construct members by parsing particular parameters from buffer // construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters) void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{ {
if ( parameters.size() < 13 ) throw std::runtime_error("invalid number of parameters in CD2"); if ( parameters.size() < 13 ) throw std::runtime_error("invalid number of parameters in Cb");
number_buffers_ = std::stoul(get_parameter(buffer,&parameters[2])); number_buffers_ = std::stoul(get_parameter(buffer,&parameters[2]));
bytes_userinfo_ = std::stoul(get_parameter(buffer,&parameters[3])); bytes_userinfo_ = std::stoul(get_parameter(buffer,&parameters[3]));
buffer_reference_ = std::stoul(get_parameter(buffer,&parameters[4])); buffer_reference_ = std::stoul(get_parameter(buffer,&parameters[4]));
@ -378,7 +381,7 @@ namespace imc
// construct members by parsing particular parameters from buffer // construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters) void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{ {
if ( parameters.size() < 8 ) throw std::runtime_error("invalid number of parameters in CD2"); if ( parameters.size() < 8 ) throw std::runtime_error("invalid number of parameters in CR");
transform_ = (get_parameter(buffer,&parameters[2]) == std::string("1")); transform_ = (get_parameter(buffer,&parameters[2]) == std::string("1"));
factor_ = std::stod(get_parameter(buffer,&parameters[3])); factor_ = std::stod(get_parameter(buffer,&parameters[3]));
offset_ = std::stod(get_parameter(buffer,&parameters[4])); offset_ = std::stod(get_parameter(buffer,&parameters[4]));
@ -410,7 +413,7 @@ namespace imc
// construct members by parsing particular parameters from buffer // construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters) void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{ {
if ( parameters.size() < 9 ) throw std::runtime_error("invalid number of parameters in CD2"); if ( parameters.size() < 9 ) throw std::runtime_error("invalid number of parameters in CN");
group_index_ = std::stoul(get_parameter(buffer,&parameters[2])); group_index_ = std::stoul(get_parameter(buffer,&parameters[2]));
index_bit_ = (get_parameter(buffer,&parameters[4]) == std::string("1")); index_bit_ = (get_parameter(buffer,&parameters[4]) == std::string("1"));
name_ = get_parameter(buffer,&parameters[6]); name_ = get_parameter(buffer,&parameters[6]);
@ -439,7 +442,7 @@ namespace imc
// construct members by parsing particular parameters from buffer // construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters) void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{ {
if ( parameters.size() < 4 ) throw std::runtime_error("invalid number of parameters in CD2"); if ( parameters.size() < 4 ) throw std::runtime_error("invalid number of parameters in CS");
index_ = std::stoul(get_parameter(buffer,&parameters[2])); index_ = std::stoul(get_parameter(buffer,&parameters[2]));
} }
@ -454,6 +457,21 @@ namespace imc
} }
}; };
// language (corresponds to key NL)
struct language
{
std::string codepage_;
std::string language_code_;
// construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{
if (parameters.size() < 4) throw std::runtime_error("invalid number of parameters in NL");
codepage_ = get_parameter(buffer, &parameters[2]);
language_code_ = get_parameter(buffer, &parameters[3]);
}
};
// origin of data (corresponds to key NO) // origin of data (corresponds to key NO)
struct origin_data struct origin_data
{ {
@ -484,45 +502,30 @@ namespace imc
// trigger timestamp (corresponds to key NT1) // trigger timestamp (corresponds to key NT1)
struct triggertime struct triggertime
{ {
int day_, month_, year_; std::tm tms_;
int hour_, minute_; double trigger_time_frac_secs_;
double second_;
std::string timestamp_;
// construct members by parsing particular parameters from buffer // construct members by parsing particular parameters from buffer
void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters) void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter>& parameters)
{ {
if ( parameters.size() < 8 ) throw std::runtime_error("invalid number of parameters in CD2"); if ( parameters.size() < 8 ) throw std::runtime_error("invalid number of parameters in CD2");
day_ = std::stoi( get_parameter(buffer,&parameters[2]) ); tms_ = std::tm();
month_ = std::stoi( get_parameter(buffer,&parameters[3]) ); tms_.tm_mday = std::stoi( get_parameter(buffer,&parameters[2]) );
year_ = std::stoi( get_parameter(buffer,&parameters[4]) ); tms_.tm_mon = std::stoi( get_parameter(buffer,&parameters[3]) ) - 1;
hour_ = std::stoi( get_parameter(buffer,&parameters[5]) ); tms_.tm_year = std::stoi( get_parameter(buffer,&parameters[4]) ) - 1900;
minute_ = std::stoi( get_parameter(buffer,&parameters[6]) ); tms_.tm_hour = std::stoi( get_parameter(buffer,&parameters[5]) );
second_ = std::stod( get_parameter(buffer,&parameters[7]) ); tms_.tm_min = std::stoi( get_parameter(buffer,&parameters[6]) );
long double secs = std::stold( get_parameter(buffer,&parameters[7]) );
//time_t rawtime; double secs_int;
//struct tm ts; trigger_time_frac_secs_ = modf((double)secs,&secs_int);
//time(&rawtime); tms_.tm_sec = (int)secs_int;
//localtime_r(&rawtime,&ts);
//ts.tm_mday = day_;
//ts.tm_mon = month_-1;
//ts.tm_year = year_-1900;
//ts.tm_hour = hour_;
//ts.tm_min = minute_;
//ts.tm_sec = (int)second_;
//asctime_r(&ts,&timestamp_[0]);
timestamp_ = std::to_string(year_) + std::string("-") + std::to_string(month_)
+ std::string("-") + std::to_string(day_)
+ std::string("T") + std::to_string(hour_)
+ std::string(":") + std::to_string(minute_)
+ std::string(":") + std::to_string(second_);
} }
// get info string // get info string
std::string get_info(int width = 20) std::string get_info(int width = 20)
{ {
std::stringstream ss; std::stringstream ss;
ss<<std::setw(width)<<std::left<<"timestamp:"<<timestamp_<<"\n"; ss<<std::setw(width)<<std::left<<"timestamp:"<<std::put_time(&tms_, "%Y-%m-%dT%H:%M:%S")<<"\n";
return ss.str(); return ss.str();
} }
}; };

70
lib/imc_raw.hpp
View File

@ -211,29 +211,61 @@ namespace imc
imc::channel_env chnenv; imc::channel_env chnenv;
chnenv.reset(); chnenv.reset();
imc::component_env *compenv_ptr = nullptr;
// collect affiliate blocks for every channel WITH CHANNEL and AFFILIATE // collect affiliate blocks for every channel WITH CHANNEL and AFFILIATE
// BLOCK CORRESPONDENCE GOVERNED BY BLOCK ORDER IN BUFFER!! // BLOCK CORRESPONDENCE GOVERNED BY BLOCK ORDER IN BUFFER!!
for ( imc::block blk: rawblocks_ ) for ( imc::block blk: rawblocks_ )
{ {
if ( blk.get_key().name_ == "CN" ) chnenv.CNuuid_ = blk.get_uuid(); if ( blk.get_key().name_ == "NO" ) chnenv.NOuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CD" ) chnenv.CDuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CT" ) chnenv.CTuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "Cb" ) chnenv.Cbuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CP" ) chnenv.CPuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CR" ) chnenv.CRuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CS" ) chnenv.CSuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "NT" ) chnenv.NTuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "NO" ) chnenv.NOuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "NL" ) chnenv.NLuuid_ = blk.get_uuid(); else if ( blk.get_key().name_ == "NL" ) chnenv.NLuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CB" ) chnenv.CBuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CG" ) chnenv.CGuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CI" ) chnenv.CIuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CT" ) chnenv.CTuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CN" ) chnenv.CNuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CS" ) chnenv.CSuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CC" )
{
// a new component group is started
// TODO: can we avoid to parse the whole component here?
imc::component component;
component.parse(&buffer_, blk.get_parameters());
if ( component.component_index_ == 1 ) compenv_ptr = &chnenv.compenv1_;
else if ( component.component_index_ == 2 ) compenv_ptr = &chnenv.compenv2_;
else throw std::runtime_error("invalid component index in CC block");
compenv_ptr->CCuuid_ = blk.get_uuid();
compenv_ptr->uuid_ = compenv_ptr->CCuuid_;
}
else if ( blk.get_key().name_ == "CD" )
{
if (compenv_ptr == nullptr) chnenv.CDuuid_ = blk.get_uuid();
else compenv_ptr->CDuuid_ = blk.get_uuid();
}
else if ( blk.get_key().name_ == "NT" )
{
if (compenv_ptr == nullptr) chnenv.NTuuid_ = blk.get_uuid();
else compenv_ptr->NTuuid_ = blk.get_uuid();
}
else if ( blk.get_key().name_ == "Cb" ) compenv_ptr->Cbuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CP" ) compenv_ptr->CPuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CR" ) compenv_ptr->CRuuid_ = blk.get_uuid();
// check for currently associated channel // check for currently associated channel
// TODO: CNuuid is not unique for multichannel data
if ( !chnenv.CNuuid_.empty() ) if ( !chnenv.CNuuid_.empty() )
{ {
// any component/channel is closed by any of {CS, CC, CG, CB} // at the moment only a single channel is supported
if ( blk.get_key().name_ == "CS" || blk.get_key().name_ == "CC" // any channel is closed by any of {CB, CG, CI, CT, CS}
|| blk.get_key().name_ == "CG" || blk.get_key().name_ == "CB" ) if ( blk.get_key().name_ == "CB" || blk.get_key().name_ == "CG"
|| blk.get_key().name_ == "CI" || blk.get_key().name_ == "CT"
|| blk.get_key().name_ == "CS" )
{ {
// provide UUID for channel // provide UUID for channel
// for multi component channels exactly one CN is available
chnenv.uuid_ = chnenv.CNuuid_; chnenv.uuid_ = chnenv.CNuuid_;
// for multichannel data there may be multiple channels referring to // for multichannel data there may be multiple channels referring to
@ -255,8 +287,15 @@ namespace imc
); );
// reset channel uuid // reset channel uuid
chnenv.reset(); chnenv.CNuuid_.clear();
//chnenv.CNuuid_.clear();
chnenv.CBuuid_.clear();
chnenv.CGuuid_.clear();
chnenv.CIuuid_.clear();
chnenv.CTuuid_.clear();
chnenv.CSuuid_.clear();
compenv_ptr = nullptr;
} }
} }
@ -264,7 +303,8 @@ namespace imc
// already belong to NEXT component // already belong to NEXT component
if ( blk.get_key().name_ == "CB" ) chnenv.CBuuid_ = blk.get_uuid(); if ( blk.get_key().name_ == "CB" ) chnenv.CBuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CG" ) chnenv.CGuuid_ = blk.get_uuid(); else if ( blk.get_key().name_ == "CG" ) chnenv.CGuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CC" ) chnenv.CCuuid_ = blk.get_uuid(); else if ( blk.get_key().name_ == "CI" ) chnenv.CIuuid_ = blk.get_uuid();
else if ( blk.get_key().name_ == "CT" ) chnenv.CTuuid_ = blk.get_uuid();
} }
} }

2
python/VERSION
View File

@ -1 +1 @@
2.0.20 2.1.0