C++ Instrument Catalog
PT2026TypeConversions.cpp
Go to the documentation of this file.
1 // Standard includes
2 #include <sstream>
3 #include <cfloat>
4 
5 // Personal includes
7 #include "VISAInstrumentBuffer.h"
8 #include "Helpers.h"
9 #include "OSDefines.h"
10 #include "SCPIParsing.h"
11 
12 using namespace MTL::Instrument;
13 
14 namespace MTL {
15  namespace Instrument {
16  namespace PT2026Types {
17 
18  U16 BinaryToU16(const char pBinary[2])
19  {
20  return *reinterpret_cast<const U16*>(pBinary);
21  }
22  I16 BinaryToI16(const char pBinary[2])
23  {
24  return *reinterpret_cast<const I16*>(pBinary);
25  }
26  U32 BinaryToU32(const char pBinary[4])
27  {
28  return *reinterpret_cast<const U32*>(pBinary);
29  }
30  I32 BinaryToI32(const char pBinary[4])
31  {
32  return *reinterpret_cast<const I32*>(pBinary);
33  }
34  F32 BinaryToF32(const char pBinary[4])
35  {
36  return *reinterpret_cast<const F32*>(pBinary);
37  }
38  U64 BinaryToU64(const char pBinary[8])
39  {
40  return *reinterpret_cast<const U64*>(pBinary);
41  }
42  F64 BinaryToF64(const char pBinary[8])
43  {
44  const char Binary64_Out[8] = { pBinary[4], pBinary[5], pBinary[6], pBinary[7], pBinary[0], pBinary[1], pBinary[2], pBinary[3] };
45  return *reinterpret_cast<const F64*>(Binary64_Out);
46  }
47  bool StringToUnits(std::string SUnits, eUnits & rUnits)
48  {
49  if (SUnits == "T") rUnits = kT;
50  else if (SUnits == "MT") rUnits = kmT;
51  else if (SUnits == "GAUS") rUnits = kGauss;
52  else if (SUnits == "KGAU") rUnits = kkGauss;
53  else if (SUnits == "PPM") rUnits = kppm;
54  else if (SUnits == "MAHZP") rUnits = kMHzp;
55  else if (SUnits == "MAHZ") rUnits = kMHz;
56  else return false;
57 
58  return true;
59  }
60  std::string UnitsToString(eUnits Units)
61  {
62  return Units == kT ? "T" :
63  Units == kmT ? "MT" :
64  Units == kGauss ? "GAUS" :
65  Units == kkGauss ? "KGAU" :
66  Units == kppm ? "PPM" :
67  Units == kMHzp ? "MAHZP" :
68  Units == kMHz ? "MAHZ" : "";
69  }
70  bool StringtoExtendedChannel(std::string sExtChan, sExtendedChannel & rExtChan)
71  {
72  // Separate elements
73  std::vector<std::string> l_Tokens;
74  SCPI::SplitString(sExtChan, l_Tokens, ',');
75  if (l_Tokens.size() != 6)
76  return false;
77  // Channel
78  std::vector<std::string> l_ChannelList;
79  SCPI::SplitString(l_Tokens[0], l_ChannelList, '!');
80  if (l_ChannelList.empty())
81  return false;
82  for (auto & ChanIt : l_ChannelList)
83  rExtChan.Channel.push_back(static_cast<unsigned char>(std::stoul(ChanIt)));
84  // Type
85  // TODO: Enable this code for next ARM release
86  /*bool l_TypeRecognized = false;
87  for (int l_Index = 0; !l_TypeRecognized && l_Index < ePeriphObjectType::NbTypes; l_Index++)
88  {
89  if (l_Tokens[1] == PeriphObjectTypeStr[l_Index])
90  {
91  rExtChan.Type = static_cast<ePeriphObjectType>(l_Index);
92  l_TypeRecognized = true;
93  }
94  }
95  if (!l_TypeRecognized)
96  return false;*/
97  // TODO: Remove this code for next ARM release
98  rExtChan.Type = ( l_Tokens[1] == "SinglePulsed" ? kPwProbe :
99  l_Tokens[1] == "Multiplexer" ? kPwMultiplexer :
100  l_Tokens[1] == "SwitchedPulsed" ? kPwCameraHead :
101  l_Tokens[1] == "CameraPulsed" ? kPwCamera :
102  NbTypes);
103  if (rExtChan.Type == NbTypes)
104  return false;
105  // Model
106  rExtChan.Model = std::stoul(l_Tokens[2]);
107  // Serial
108  rExtChan.SerialNumber = std::stoul(l_Tokens[3]);
109  // NoPorts
110  rExtChan.NoPorts = static_cast<U8>(std::stoul(l_Tokens[4]));
111  // CanMeasure
112  if (l_Tokens[5] == "1")
113  rExtChan.CanMeasure = true;
114  else if (l_Tokens[5] == "0")
115  rExtChan.CanMeasure = false;
116  else
117  return false;
118 
119  return true;
120  }
121  bool StringToExtendedChannelList(std::string SExtChanList, CExtendedChannelList & rExtChanList)
122  {
123  for (size_t l_beg = 0, l_end = 0; l_beg < SExtChanList.size() && l_end < SExtChanList.size(); )
124  {
125  l_beg = SExtChanList.find_first_of('(', l_end);
126  l_end = SExtChanList.find_first_of(')', l_beg);
127  if (l_beg != std::string::npos && l_end > l_beg + 2)
128  {
129  sExtendedChannel l_ExtChan;
130  if (StringtoExtendedChannel(SExtChanList.substr(l_beg + 1, l_end - l_beg - 1), l_ExtChan))
131  rExtChanList.push_back(l_ExtChan);
132  else
133  return false;
134  }
135  }
136 
137  return true;
138  }
139 
140  //----------------------------------------------------------------------//
141  // TESTS //
142  //----------------------------------------------------------------------//
144  {
145  try
146  {
147  //----------------------------------------------------------------------//
148  // Binary Numbers //
149  //----------------------------------------------------------------------//
150  unsigned char l_Binary16[2] = { 0x12, 0xF3 };
151  if (BinaryToU16(reinterpret_cast<char *>(l_Binary16)) != 62226)
152  throw "Invalid U16 conversion";
153  if (BinaryToI16(reinterpret_cast<char *>(l_Binary16)) != -3310)
154  throw "Invalid I16 conversion";
155  unsigned char l_Binary32[4] = { 0x12, 0x34, 0x56, 0xF7 };
156  if (BinaryToU32(reinterpret_cast<char *>(l_Binary32)) != 4149621778)
157  throw "Invalid U32 conversion";
158  if (BinaryToI32(reinterpret_cast<char *>(l_Binary32)) != -145345518)
159  throw "Invalid I32 conversion";
160  if (BinaryToF32(reinterpret_cast<char *>(l_Binary32)) >= -4.34456E+33F - FLT_EPSILON && BinaryToF32(reinterpret_cast<char *>(l_Binary32)) <= -4.34456E+33F + FLT_EPSILON)
161  throw "Invalid F32 conversion";
162  unsigned char l_Binary64[8] = { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF1 };
163  if (BinaryToU64(reinterpret_cast<char *>(l_Binary64)) != 17428574979600299026UL)
164  throw "Invalid U64 conversion";
165  if (BinaryToF64(reinterpret_cast<char *>(l_Binary64)) >= 4.69198E+271 - DBL_EPSILON && BinaryToF64(reinterpret_cast<char *>(l_Binary64)) <= 4.69198E+271 + DBL_EPSILON)
166  throw "Invalid F64 conversion";
167  CExtendedChannelList l_ExChL;
168  std::string l_SExChL("(1,Multiplexer,6026,6,4,0),(1!2,SinglePulsed,1226,57,0,1),(1!4,SinglePulsed,1226,0,0,1)");
169  if (!StringToExtendedChannelList(l_SExChL, l_ExChL) || l_ExChL.size() != 3)
170  throw "Invalid CExtendedChannelList conversion";
171  sExtendedChannel l_ExChan = l_ExChL[1];
172  if (l_ExChan.Channel != SCPI::tChannel({ 1,2 }) ||
173  l_ExChan.Type != kPwProbe ||
174  l_ExChan.Model != 1226 ||
175  l_ExChan.SerialNumber != 57 ||
176  l_ExChan.NoPorts != 0 ||
177  l_ExChan.CanMeasure != true)
178  throw "Invalid CExtendedChannelList conversion";
179  }
180  catch (const char * ErrorMsg)
181  {
182  COUT("Error! :" << ErrorMsg << std::endl);
183  return false;
184  }
185  COUT(MTL__FUNCTION_NAME__ << " Success" << std::endl);
186  return true;
187  }
188 
189  } // namespace PT2026Types
190  } // namespace Instrument
191 } // namespace MTL
PT2026TypeConversions.h
MTL::Instrument::PT2026Types::sExtendedChannel::Type
ePeriphObjectType Type
Definition: PT2026Types.h:413
MTL::Instrument::PT2026Types::BinaryToI32
I32 BinaryToI32(const char pBinary[4])
Definition: PT2026TypeConversions.cpp:30
MTL::Instrument::PT2026Types::BinaryToU16
U16 BinaryToU16(const char pBinary[2])
Definition: PT2026TypeConversions.cpp:18
MTL::Instrument::PT2026Types::kT
@ kT
Definition: PT2026Types.h:157
COUT
#define COUT(__X__)
Definition: Helpers.h:29
MTL::Instrument::PT2026Types::eUnits
eUnits
Definition: PT2026Types.h:156
SCPIParsing.h
Utilities to aid in sending SCPI commands and parsing of SCPI reponses.
MTL::Instrument::PT2026Types::kmT
@ kmT
Definition: PT2026Types.h:157
MTL::Instrument::PT2026Types::sExtendedChannel::Channel
SCPI::tChannel Channel
Definition: PT2026Types.h:412
MTL::SCPI::tChannel
std::vector< unsigned char > tChannel
SCPI channel
Definition: SCPIParsing.h:25
MTL::Instrument::PT2026Types::BinaryToI16
I16 BinaryToI16(const char pBinary[2])
Definition: PT2026TypeConversions.cpp:22
MTL::Instrument::PT2026Types::kPwCameraHead
@ kPwCameraHead
Definition: PT2026Types.h:398
MTL::Instrument::PT2026Types::BinaryToU32
U32 BinaryToU32(const char pBinary[4])
Definition: PT2026TypeConversions.cpp:26
MTL::Instrument::PT2026Types::kkGauss
@ kkGauss
Definition: PT2026Types.h:157
MTL::Instrument::PT2026Types::sExtendedChannel::SerialNumber
tSerialNumber SerialNumber
Definition: PT2026Types.h:415
MTL::Instrument::PT2026Types::kMHzp
@ kMHzp
Definition: PT2026Types.h:157
Helpers.h
Collection of utility macros for error messages.
MTL::Instrument::PT2026Types::UnitsToString
std::string UnitsToString(eUnits Units)
Definition: PT2026TypeConversions.cpp:60
MTL::Instrument::PT2026Types::kGauss
@ kGauss
Definition: PT2026Types.h:157
MTL::Instrument::PT2026Types::TestPT2026Types
bool TestPT2026Types()
Definition: PT2026TypeConversions.cpp:143
MTL
Definition: CPT2026PeripheralROM.h:19
MTL::SCPI::SplitString
void SplitString(const std::string &rStr, std::vector< std::string > &rStrings, char Sep)
Split a string into substrings separated by a given character.
Definition: SCPIParsing.h:245
MTL::Instrument
Definition: MFC3045.h:25
MTL::Instrument::PT2026Types::kPwProbe
@ kPwProbe
Definition: PT2026Types.h:396
MTL::Instrument::PT2026Types::sExtendedChannel::Model
tModel Model
Definition: PT2026Types.h:414
MTL::Instrument::PT2026Types::StringToUnits
bool StringToUnits(std::string SUnits, eUnits &rUnits)
Definition: PT2026TypeConversions.cpp:47
MTL::Instrument::PT2026Types::BinaryToF32
F32 BinaryToF32(const char pBinary[4])
Definition: PT2026TypeConversions.cpp:34
MTL::Instrument::PT2026Types::StringToExtendedChannelList
bool StringToExtendedChannelList(std::string SExtChanList, CExtendedChannelList &rExtChanList)
Definition: PT2026TypeConversions.cpp:121
MTL::Instrument::PT2026Types::sExtendedChannel::CanMeasure
bool CanMeasure
Definition: PT2026Types.h:417
MTL::Instrument::PT2026Types::BinaryToF64
F64 BinaryToF64(const char pBinary[8])
Definition: PT2026TypeConversions.cpp:42
MTL::Instrument::PT2026Types::sExtendedChannel
Definition: PT2026Types.h:411
MTL::Instrument::PT2026Types::kppm
@ kppm
Definition: PT2026Types.h:157
MTL::Instrument::PT2026Types::kPwCamera
@ kPwCamera
Definition: PT2026Types.h:397
MTL::Instrument::PT2026Types::sExtendedChannel::NoPorts
U8 NoPorts
Definition: PT2026Types.h:416
MTL::Instrument::PT2026Types::NbTypes
@ NbTypes
Definition: PT2026Types.h:401
MTL::Instrument::PT2026Types::kMHz
@ kMHz
Definition: PT2026Types.h:157
MTL::Instrument::PT2026Types::CExtendedChannelList
Definition: PT2026Types.h:446
OSDefines.h
Platform Dependent Definitions.
VISAInstrumentBuffer.h
MTL::Instrument::PT2026Types::BinaryToU64
U64 BinaryToU64(const char pBinary[8])
Definition: PT2026TypeConversions.cpp:38
MTL::Instrument::PT2026Types::StringtoExtendedChannel
bool StringtoExtendedChannel(std::string sExtChan, sExtendedChannel &rExtChan)
Definition: PT2026TypeConversions.cpp:70
MTL::Instrument::PT2026Types::kPwMultiplexer
@ kPwMultiplexer
Definition: PT2026Types.h:399