THM1176InstrumentDriver 1.1
C++ API for Metrolab THM1176
Loading...
Searching...
No Matches
THM1176Types.cpp
Go to the documentation of this file.
1// Copyright (c) 2025 Metrolab Technology S.A., Geneva, Switzerland (www.metrolab.com)
2// See the included file LICENSE.txt for the licensing conditions.
3
7
8#include <iostream>
9#include <iomanip>
10#include <ctime>
11
12#include "Eigen/SVD"
13
14#include "THM1176.h"
15
16using namespace MTL;
17using namespace MTL::Instrument;
18using namespace MTL::Instrument::THM1176Types;
19
20namespace MTL {
21namespace Instrument {
22namespace THM1176Types {
23
24//----------------------------------------------------------------------//
25// Status //
26//----------------------------------------------------------------------//
27std::ostream & operator<<(std::ostream & Stream, const eStatusRegisterSet & RegSet)
28{
29 Stream << ((RegSet == kStatusByte) ? "StatByte" :
30 (RegSet == kStandardEventStatusRegister) ? "StdEvReg" :
31 (RegSet == kStatusQuestionableStatusRegister) ? "QuestReg" :
32 (RegSet == kStatusOperationStatusRegister) ? "OperReg" : "?");
33 return Stream;
34}
35std::ostream & operator<<(std::ostream & Stream, const eStatusRegisterType & RegType)
36{
37 Stream << ((RegType == kStatusEvent) ? "Event" :
38 (RegType == kStatusCondition) ? "Condition" :
39 (RegType == kStatusEnable) ? "Enable" : "?");
40 return Stream;
41}
42std::ostream & operator<<(std::ostream & Stream, const sStatusRegister & RegDef)
43{
44 Stream << "regdef(" << RegDef.Set << " " << RegDef.Type << ")";
45 return Stream;
46}
47std::ostream & operator<<(std::ostream & Stream, const RegisterList & RegList)
48{
49 Stream << "( ";
50 for (auto l_Reg : RegList)
51 Stream << l_Reg << " ";
52 Stream << ")";
53 return Stream;
54}
55std::ostream & operator<<(std::ostream & Stream, const StatusValues & StatusList)
56{
57 Stream << "( ";
58 for (auto l_Value : StatusList)
59 Stream << l_Value << " ";
60 Stream << ")";
61 return Stream;
62}
63std::ostream & operator<<(std::ostream & Stream, const uStatusByte & StatusByte)
64{
65 Stream << "(EAV=" << StatusByte.StatusByte.EAV <<
66 " QSB=" << StatusByte.StatusByte.QSB <<
67 " MAV=" << StatusByte.StatusByte.MAV <<
68 " ESB=" << StatusByte.StatusByte.ESB <<
69 " RQS=" << StatusByte.StatusByte.RQS <<
70 " OSB=" << StatusByte.StatusByte.OSB << ")";
71 return Stream;
72}
73std::ostream & operator<<(std::ostream & Stream, const uStandardEvent & StdEventReg)
74{
75 Stream << "(OperationComplete=" << StdEventReg.StandardEvent.OperationComplete <<
76 " QueryError=" << StdEventReg.StandardEvent.QueryError <<
77 " DeviceDependentError=" << StdEventReg.StandardEvent.DeviceDependentError <<
78 " ExecutionError=" << StdEventReg.StandardEvent.ExecutionError <<
79 " CommandError=" << StdEventReg.StandardEvent.CommandError <<
80 " PowerOn=" << StdEventReg.StandardEvent.PowerOn << ")";
81 return Stream;
82}
83std::ostream & operator<<(std::ostream & Stream, const uOPERation & OperReg)
84{
85 Stream << "(CALibrating=" << OperReg.OPERation.CALibrating <<
86 " RANGing=" << OperReg.OPERation.RANGing <<
87 " MEASuring=" << OperReg.OPERation.MEASuring <<
88 " WaitingForTRIGger=" << OperReg.OPERation.WaitingForTRIGger << ")";
89 return Stream;
90}
91std::ostream & operator<<(std::ostream & Stream, const uQUEStionable & QuestReg)
92{
93 Stream << "(Frequency=" << QuestReg.QUEStionable.Frequency <<
94 " Overrange=" << QuestReg.QUEStionable.Overrange << ")";
95 return Stream;
96}
97
98//----------------------------------------------------------------------//
99// Flux //
100//----------------------------------------------------------------------//
101std::ostream & operator<<(std::ostream & Stream, const CFluxList & FluxList)
102{
103 Stream << "( ";
104 for (auto l_Flux : FluxList)
105 Stream << l_Flux << " ";
106 Stream << ")";
107 return Stream;
108}
109
110//----------------------------------------------------------------------//
111// Units //
112//----------------------------------------------------------------------//
113std::ostream & operator<<(std::ostream & Stream, const eUnits & Units)
114{
115 Stream << ((Units == kT) ? "T" :
116 (Units == kmT) ? "mT" :
117 (Units == kuT) ? "uT" :
118 (Units == knT) ? "nT" :
119 (Units == kGauss) ? "Gauss" :
120 (Units == kkGauss)? "kGauss" :
121 (Units == kmGauss)? "mGauss" :
122 (Units == kMHzp) ? "MHzp" : "?");
123 return Stream;
124}
125std::ostream & operator<<(std::ostream & Stream, const CUnitsList & UnitsList)
126{
127 Stream << "( ";
128 for (auto l_Units : UnitsList)
129 Stream << l_Units << " ";
130 Stream << ")";
131 return Stream;
132}
133std::ostream & operator<<(std::ostream & Stream, const CDivisorList & DivisorList)
134{
135 Stream << "( ";
136 for (auto l_Divisor : DivisorList)
137 Stream << l_Divisor << " ";
138 Stream << ")";
139 return Stream;
140}
141
142//----------------------------------------------------------------------//
143// Errors //
144//----------------------------------------------------------------------//
145bool sError::operator==(sError other) const
146{
147 return (
148 Code == other.Code &&
149 Description == other.Description &&
150 Context == other.Context
151 );
152}
153bool sError::operator!=(sError other) const
154{
155 return (!operator==(other));
156}
157std::ostream & operator<<(std::ostream & Stream, const sError & Error)
158{
159 Stream << "err(code=" << Error.Code <<
160 " desc=" << Error.Description <<
161 " ctxt=" << Error.Context << ")";
162 return Stream;
163}
164std::ostream & operator<<(std::ostream & Stream, const CErrorList & ErrorList)
165{
166 for (auto l_Error : ErrorList)
167 Stream << l_Error << std::endl;
168 return Stream;
169}
170
171//----------------------------------------------------------------------//
172// Version //
173//----------------------------------------------------------------------//
175{
176 Major = 0;
177 Minor = 0;
178}
180{
181 return (
182 Major == other.Major &&
183 Minor == other.Minor);
184}
186{
187 return (!operator==(other));
188}
189std::ostream & operator<<(std::ostream & Stream, const sVersion & Version)
190{
191 Stream << Version.Major << "." << Version.Minor;
192 return Stream;
193}
194
195//----------------------------------------------------------------------//
196// Identifier //
197//----------------------------------------------------------------------//
199{
200 Manufacturer.clear();
201 Model.clear();
202 SerialNumber = 0;
203 ElectronicsVersion.clear();
204 ProbeVersion.clear();
205 FirmwareVersion.clear();
208}
210{
211 return (
212 Manufacturer == other.Manufacturer &&
213 Model == other.Model &&
214 SerialNumber == other.SerialNumber &&
216 ProbeVersion == other.ProbeVersion &&
218 );
219}
221{
222 return (!operator==(other));
223}
224std::ostream & operator<<(std::ostream & Stream, const sIdentifier & ID)
225{
226 Stream << "id(mfr=" << ID.Manufacturer <<
227 " mdl=" << ID.Model <<
228 " sn=" << ID.SerialNumber <<
229 " elv=" << ID.ElectronicsVersion <<
230 " prv=" << ID.ProbeVersion <<
231 " fwv=" << ID.FirmwareVersion << ")";
232 return Stream;
233}
234
235//----------------------------------------------------------------------//
236// Parameters //
237//----------------------------------------------------------------------//
238std::ostream & operator<<(std::ostream & Stream, const sAveraging<uParm> & AvgParm)
239{
240 Stream << AvgParm.NoPoints;
241 return Stream;
242}
243std::ostream & operator<<(std::ostream & Stream, const sAveraging<sBoundedParm> & AvgParm)
244{
245 Stream << "avg(val=" << AvgParm.NoPoints.Val <<
246 " min=" << AvgParm.NoPoints.Min <<
247 " max=" << AvgParm.NoPoints.Max <<
248 " def=" << AvgParm.NoPoints.Def << ")";
249 return Stream;
250}
251
252std::ostream & operator<<(std::ostream & Stream, const eInputTriggerSource & TrgSrc)
253{
254 Stream << ((TrgSrc == kInputTrigSrcImmediate) ? "imm" :
255 (TrgSrc == kInputTrigSrcTimer) ? "tim" :
256 (TrgSrc == kInputTrigSrcBus) ? "bus" : "?");
257 return Stream;
258}
259std::ostream & operator<<(std::ostream & Stream, const sInputTrigger<uParm> & TrigParm)
260{
261 Stream << "trg(src=" << TrigParm.Source <<
262 " per=" << TrigParm.Period_s <<
263 " cnt=" << TrigParm.Count << ")";
264 return Stream;
265}
266std::ostream & operator<<(std::ostream & Stream, const sInputTrigger<sBoundedParm> & TrigParm)
267{
268 Stream << "trg(src=" << TrigParm.Source <<
269 " per(val=" << TrigParm.Period_s.Val <<
270 " min=" << TrigParm.Period_s.Min <<
271 " max=" << TrigParm.Period_s.Max <<
272 " def=" << TrigParm.Period_s.Def << ")" <<
273 " cnt(val=" << TrigParm.Count.Val <<
274 " min=" << TrigParm.Count.Min <<
275 " max=" << TrigParm.Count.Max <<
276 " def=" << TrigParm.Count.Def << "))";
277 return Stream;
278}
279
280std::ostream & operator<<(std::ostream & Stream, const eCommunicationFormat & CommFormat)
281{
282 Stream << ((CommFormat == kComFormatAscii) ? "ascii" :
283 (CommFormat == kComFormatInteger) ? "int" :
284 (CommFormat == kComFormatPacked2Byte) ? "pack2" :
285 (CommFormat == kComFormatPacked1Byte) ? "pack1" : "?");
286 return Stream;
287}
288
289std::ostream & operator<<(std::ostream & Stream, const sRange<uParm> & RangeParm)
290{
291 Stream << "range(auto=" << RangeParm.Auto <<
292 " rng=" << RangeParm.Range << ")";
293 return Stream;
294}
295std::ostream & operator<<(std::ostream & Stream, const sRange<sBoundedParm> & RangeParm)
296{
297 Stream << "range(auto=" << RangeParm.Auto <<
298 " rng(val=" << RangeParm.Range.Val <<
299 " min=" << RangeParm.Range.Min <<
300 " max=" << RangeParm.Range.Max <<
301 " def=" << RangeParm.Range.Def << "))";
302 return Stream;
303}
304
305//----------------------------------------------------------------------//
306// Files //
307//----------------------------------------------------------------------//
309{
310 Path.clear();
311 Type.clear();
312 Size = 0;
313}
314bool sFile::operator==(sFile other) const
315{
316 return (
317 Path == other.Path &&
318 Type == other.Type &&
319 Size == other.Size
320 );
321}
322bool sFile::operator!=(sFile other) const
323{
324 return (!operator==(other));
325}
326std::ostream & operator<<(std::ostream & Stream, const sFile & FileInfo)
327{
328 Stream << "file(siz=" << FileInfo.Size <<
329 " path=" << FileInfo.Path <<
330 " type=" << FileInfo.Type << ")";
331 return Stream;
332}
333std::ostream & operator<<(std::ostream & Stream, const tFileList & FileList)
334{
335 for (auto l_FileInfo : FileList)
336 Stream << l_FileInfo << std::endl;
337 return Stream;
338}
339
340//----------------------------------------------------------------------//
341// Time stamp //
342//----------------------------------------------------------------------//
343CAbsoluteTimestamp::CAbsoluteTimestamp(std::time_t Seconds, U64 Nanoseconds) :
344 s(Seconds), ns(Nanoseconds)
345{
346 s += ns / NS_PER_SEC;
347 ns = ns % NS_PER_SEC;
348}
350{
351 s = Value.s;
352 ns = Value.ns;
353 return *this;
354}
356{
357 return (s == other.s && ns == other.ns);
358}
360{
361 return (!operator==(other));
362}
363std::time_t CAbsoluteTimestamp::seconds(void) const
364{
365 return s;
366}
368{
369 return ns;
370}
372{
373 s = 0;
374 ns = 0;
375}
376
377//----------------------------------------------------------------------//
378// Timestamp addition / subtraction / insertion //
379//----------------------------------------------------------------------//
381{
382 std::time_t s;
383 U64 ns;
384
385 s = a.seconds() + b.seconds();
386 ns = a.nanoseconds() + b.nanoseconds();
387
388 return CAbsoluteTimestamp(s, ns);
389}
390
392{
393 std::time_t s;
394 U64 ns;
395
396 if (a.nanoseconds() > b.nanoseconds())
397 {
398 ns = a.nanoseconds() - b.nanoseconds();
399 s = (a.seconds() > b.seconds()) ? (a.seconds() - b.seconds()) : 0;
400 }
401 else
402 {
404 s = (a.seconds() > (b.seconds() + 1)) ? (a.seconds() - (b.seconds() + 1)) : 0;
405 }
406
407 return CAbsoluteTimestamp(s, ns);
408}
409
410std::ostream & operator<<(std::ostream & Stream, const CAbsoluteTimestamp & Timestamp)
411{
412 std::time_t l_Seconds = Timestamp.seconds();
413 U64 l_NanoSeconds = Timestamp.nanoseconds();
414 char l_DateTimeString[32];
415 std::strftime(l_DateTimeString, 31, "%FT%T", std::localtime(&l_Seconds));
416 Stream << std::string(l_DateTimeString) << "."
417 << std::setfill('0') << std::setw(9)
418 << l_NanoSeconds
419 << std::setfill(' ') << std::setw(0);
420 return Stream;
421}
422
423//----------------------------------------------------------------------//
424// Time stamp list //
425//----------------------------------------------------------------------//
427{
428 // Make sure we have enough timestamps.
429 if (this->size() < 2)
430 {
431 Period = 0.;
432 return false;
433 }
434
435 // Set up the linear system:
436 // Given n observations (0, T0), (1, T1), ... (n-1, Tn-1):
437 //
438 // [ 1 0 ] [ T0 ]
439 // Xnx2 = [ 1 1 ], b2x1 = [ b0 ], Ynx1 = [ T1 ],
440 // [ ... ] [ b1 ] [ ... ]
441 // [ 1 n-1 ] [ Tn-1 ]
442 //
443 // we will solve the overconstrained problem:
444 // Xnx2 b2x1 = Ynx1
445 // The period is the coefficient b1.
446 //
447 MatrixXd l_X;
448 Vector2d l_b;
449 VectorXd l_Y;
450
451 size_t l_n = this->size();
452 l_X.resize(l_n, 2);
453 l_Y.resize(l_n);
454
455 // Initialize X and Y.
456 U64 l_T0 = this->at(0);
457 for (U32 l_i = 0; l_i < l_n; l_i++)
458 {
459 l_X(l_i, 0) = 1.;
460 l_X(l_i, 1) = l_i;
461 l_Y(l_i) = static_cast<F64> (this->at(l_i) - l_T0);
462 }
463
464 // Solve the the linear least-squares system using the SVD decomposition.
465 // See https://eigen.tuxfamily.org/dox/group__LeastSquares.html.
466 l_b = l_X.jacobiSvd(ComputeThinU | ComputeThinV).solve(l_Y);
467
468 // Return the result.
469 Period = l_b(1);
470 return true;
471}
472
473std::ostream & operator<<(std::ostream & Stream, const CTimestampList & TimestampList)
474{
475 Stream << "( ";
476 for (auto l_TimeStamp : TimestampList)
477 Stream << l_TimeStamp << " ";
478 Stream << ")";
479 return Stream;
480}
481
482//----------------------------------------------------------------------//
483// Measurements //
484//----------------------------------------------------------------------//
486{
487 Bx = By = Bz = Temperature = Timestamp = true;
488 NoMeasurements = 1;
489}
491{
492 return (
493 Bx == other.Bx &&
494 By == other.By &&
495 Bz == other.Bz &&
496 Temperature == other.Temperature &&
497 Timestamp == other.Timestamp &&
499 );
500}
502{
503 return (!operator==(other));
504}
505
507{
508 AveragingParms.clear();
509 TriggerParms.clear();
510 UseCalibration = true;
511 Range = 0.;
512}
514{
515 return (
517 TriggerParms == other.TriggerParms &&
519 Range == other.Range
520 );
521}
523{
524 return (!operator==(other));
525}
526std::ostream & operator<<(std::ostream & Stream, const sArbitraryMeasurements & MeasSpec)
527{
528 Stream << "arb(Bx=" << MeasSpec.Bx <<
529 " By=" << MeasSpec.By <<
530 " Bz=" << MeasSpec.Bz <<
531 " temp=" << MeasSpec.Temperature <<
532 " time=" << MeasSpec.Timestamp <<
533 " count=" << MeasSpec.NoMeasurements << ")";
534 return Stream;
535}
536std::ostream & operator<<(std::ostream & Stream, const sMeasurementConditions & MeasCond)
537{
538 Stream << "meas_cond(avg=" << MeasCond.AveragingParms <<
539 " trig=" << MeasCond.TriggerParms <<
540 " cal=" << MeasCond.UseCalibration <<
541 " range=" << MeasCond.Range << ")";
542 return Stream;
543}
544
545} // namespace THM1176Types
546} // namespace Instrument
547} // namespace MTL
unsigned long long U64
64-bit unsigned integer.
Definition OSDefines.h:32
unsigned int U32
32-bit unsigned integer.
Definition OSDefines.h:31
double F64
64-bit floating-point number.
Definition OSDefines.h:34
Interface definition for C++ API for Metrolab THM1176/TFM1186.
std::time_t seconds(void) const
Fetch the number of seconds.
bool operator!=(CAbsoluteTimestamp other)
Inequality operator.
bool operator==(CAbsoluteTimestamp other)
Equality operator.
CAbsoluteTimestamp(std::time_t Seconds=0, U64 Nanoseconds=0)
Constructor.
void clear(void)
Clear to default values (zeroes)
CAbsoluteTimestamp & operator=(const CAbsoluteTimestamp &Value)
Assignment operator.
U64 nanoseconds(void) const
Fetch the number of nanoseconds.
List of divisors, one per measurement unit.
List of errors returned by the instrument.
List of flux density values.
bool GetEstimatedPeriod(F64 &Period)
Estimate the measurement period from this timestamp list, by means of a least-squares fit.
List of SCPI status registers.
List of values returned for several SCPI status registers.
eStatusRegisterType
Enumeration of SCPI status register types.
@ kStatusEnable
Enable register.
@ kStatusCondition
Condition register.
@ kStatusEvent
Event register.
CAbsoluteTimestamp operator-(CAbsoluteTimestamp a, CAbsoluteTimestamp b)
Timestamp subtraction operator.
std::ostream & operator<<(std::ostream &Stream, const eStatusRegisterSet &RegSet)
Status register set stream output.
eCommunicationFormat
Enumeration of possible formats for returned data.
@ kComFormatInteger
Binary (32-bit integers)
@ kComFormatPacked2Byte
Binary packed: first field value as I32, remainder deltas as I16.
@ kComFormatPacked1Byte
Binary packed: first field value as I32, remainder deltas as I8.
@ kComFormatAscii
Human-legible text.
std::vector< sFile > tFileList
List of directory entries.
CAbsoluteTimestamp operator+(CAbsoluteTimestamp a, CAbsoluteTimestamp b)
Timestamp addition operator.
eInputTriggerSource
Enumeration of possible trigger sources.
@ kInputTrigSrcTimer
Timed trigger: start measurement at regular intervals.
@ kInputTrigSrcImmediate
Immediate trigger: start measurement immediately after previous one completes.
@ kInputTrigSrcBus
Bus trigger: start measurement upon USB trigger message.
eUnits
Enumeration of possible measurement units.
@ kMHzp
Equivalent proton NMR resonant frequency, in Mega-Hertz.
eStatusRegisterSet
Enumeration of SCPI status register sets.
@ kStatusQuestionableStatusRegister
Questionable Status Register.
@ kStandardEventStatusRegister
Standard Event Status Register.
@ kStatusOperationStatusRegister
Operation Status Register.
Definition THM1176.h:73
Specify the measurement data to be returned.
bool Bx
Return the flux density X-component.
bool operator==(sArbitraryMeasurements other) const
Equality operator.
bool Temperature
Return the sensor temperature.
bool operator!=(sArbitraryMeasurements other) const
Inequality operator.
bool By
Return the flux density Y-component.
bool Bz
Return the flux density Z-component.
sArbitraryMeasurements(bool Bx=false, bool By=false, bool Bz=false, bool Temp=false, bool Time=false, U32 NMeas=0)
Constructor.
U32 NoMeasurements
Return this number of measurements.
ParmType< U16 > NoPoints
Number of points in block average.
Error returned by the instrument.
bool operator==(sError other) const
Equality operator.
sError(I32 Code=0, std::string Description="", std::string Context="")
Constructor.
std::string Context
SCPI commands being executed at time of error.
bool operator!=(sError other) const
Inequality operator.
std::string Description
Error description.
Directory entry in the instrument's file system.
void clear()
Clear to default values.
bool operator==(sFile other) const
Equality operator.
bool operator!=(sFile other) const
Inequality operator.
std::string Type
File type ("ASCII" or "BINARY").
sFile(size_t S=0, std::string P="", std::string T="")
Constructor.
size_t Size
File size, in bytes.
Instrument's identification string - parsed version.
struct sVersion FirmwareVersion
Version numbers of firmware.
std::string Manufacturer
Manufacturer name ("Metrolab Technology SA")
struct sVersion ElectronicsVersion
Version numbers of electronics.
bool operator!=(sIdentifier other) const
Inequality operator.
struct sVersion ProbeVersion
Version numbers of probe.
std::string Model
Model name (e.g. "THM1176-MF")
bool operator==(sIdentifier other) const
Equality oeprator.
enum eInstrModel InstrModel
Enumerator of instrument model.
sIdentifier(std::string Mfr="", std::string Mdl="", U32 SN=0, struct sVersion EVsn={ }, struct sVersion PVsn={ }, struct sVersion FVsn={ }, eModelRevision ThmRev=kA, eInstrModel InstrMdl=eInstrModel::kUnknown)
Constructor.
enum eModelRevision ModelRevision
Revision of Model.
ParmType< U16 > Count
Trigger count: take this many measurements before sending results.
eInputTriggerSource Source
Trigger source.
ParmType< F64 > Period_s
Trigger period, for timed trigger.
Summary of the parameters used to make a measurement.
bool operator!=(sMeasurementConditions other) const
Inequality operator.
sMeasurementConditions(sAveraging< uParm > AvgParms={ }, sInputTrigger< uParm > TrigParms={ }, bool UseCal=false, tFlux RangeIn=0.)
Constructor.
sAveraging< uParm > AveragingParms
Averaging parameters.
sInputTrigger< uParm > TriggerParms
Trigger parameters.
bool operator==(sMeasurementConditions other) const
Equality operator.
Measurement range parameter.
bool Auto
Auto-ranging enabled.
ParmType< tFlux > Range
Measurement range, if auto-ranging is not enabled.
Complete identification of a SCPI status register.
eStatusRegisterSet Set
SCPI register set.
eStatusRegisterType Type
SCPI register type.
Major and minor version numbers.
bool operator!=(sVersion other) const
Inequality operator.
void clear(void)
Clear to default (zeroes).
bool operator==(sVersion other) const
Equality operator.
sVersion(U8 Maj=0, U8 Min=0)
Constructor.
U16 MEASuring
Measuring magnetic field strength.
U16 Frequency
Acquisition buffer or the timed trigger has been overrun.
U8 DeviceDependentError
Errors specific to the THM1176, including internal errors.
U8 ExecutionError
Error detected during command execution.
U8 OperationComplete
*OPC has flagged operation complete
U8 EAV
Error Available in Error / Event Queue.
U8 ESB
Standard Event Status Register summary bit.
Union to access the Operation Status Register as integer or bit fields.
struct MTL::Instrument::THM1176Types::uOPERation::sOPERation OPERation
Access the Operation Status Register as bit fields.
Union to access the Questionable Status Register as integer or bit fields.
struct MTL::Instrument::THM1176Types::uQUEStionable::sQUEStionable QUEStionable
Access the Questionable Status Register as bit fields.
Union to access the Standard Event Status Register as integer or bit fields.
struct MTL::Instrument::THM1176Types::uStandardEvent::sStandardEvent StandardEvent
Access the Standard Event Status Register as bit fields.
Union to access the Status Byte as integer or bit fields.
struct MTL::Instrument::THM1176Types::uStatusByte::sStatusByte StatusByte
Access the Status Byte as bit fields.