850 lines
17 KiB
Rust
850 lines
17 KiB
Rust
use crate::datatypes;
|
|
use super::{Object, ObjectSpecies, RawObject};
|
|
use derive_getters::Getters;
|
|
use derive_builder::Builder;
|
|
use downcast_rs::Downcast
|
|
|
|
pub trait FmTEMP:Downcast{}
|
|
|
|
#[derive(Clone,Debug)]
|
|
pub enum FmTEMPSpecies{
|
|
SpSTANDARD,
|
|
SpDATA,
|
|
SpENGDATA,
|
|
SpPROBEDATA,
|
|
SpHARDWARESTATE,
|
|
SpLOCK,
|
|
SpRAWDATA,
|
|
SpSTATUS,
|
|
SpADSAMPLEDATA,
|
|
SpTOUCHDATA,
|
|
SpTHERMDATA,
|
|
SpCALIBRATION,
|
|
SpMSG_ARGUMENTS,
|
|
SpSELECTOR,
|
|
}
|
|
impl ObjectSpecies for FmTEMPSpecies{}
|
|
|
|
impl FmTEMP for CTempDStd{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CTempDStd{
|
|
stime:chrono::NaiveDateTime,
|
|
status:Status,
|
|
extstatus:ExtStatus,
|
|
source:Source,
|
|
mode:Mode,
|
|
method:Method,
|
|
temperature:float,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Status{
|
|
#[default]
|
|
DATA_NOT_AVAIL,
|
|
DATA_COMPLETE,
|
|
DATA_FAILURE,
|
|
DATA_EXCEPTION,
|
|
DATA_PROCESSING,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum ExtStatus{
|
|
#[default]
|
|
NONE,
|
|
FINAL_POSITION,
|
|
FINAL_OVER_TEMP,
|
|
FINAL_OVER_TEMP_POSITION,
|
|
FINAL_UNDER_TEMP,
|
|
FINAL_UNDER_TEMP_POSITION,
|
|
MONITOR_POSITION,
|
|
MONITOR_OVER_TEMP,
|
|
MONITOR_OVER_TEMP_POSITION,
|
|
MONITOR_UNDER_TEMP,
|
|
MONITOR_UNDER_TEMP_POSITION,
|
|
CRC_FAILURE,
|
|
COMM_FAILURE,
|
|
FINAL_UNADJUSTED,
|
|
BUTTON_RANGE_ERROR,
|
|
AMB_RANGE_ERROR,
|
|
ENTRY_RANGE_ERROR,
|
|
TT_RANGE_ERROR,
|
|
TT_SLOPE_RANGE_ERROR,
|
|
OUTPUT_RANGE_ERROR,
|
|
CAP_STABILITY_ERROR,
|
|
CAP_ENTRY_ERROR,
|
|
PREMATURE_BUTTON_PRESS,
|
|
CALIBRATION,
|
|
UNADJUSTED_NO_OFFSETS,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Source{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
SURETEMP_SW,
|
|
SURETEMP,
|
|
SURETEMP_PLUS,
|
|
BRAUN_PRO4000,
|
|
BRAUN_PRO6000,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Mode{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
ORAL,
|
|
RECTAL,
|
|
PED_AXIL,
|
|
CAL_KEY,
|
|
ADULT_AXIL,
|
|
TYMPANIC,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Method{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
MANUAL,
|
|
DEVICE,
|
|
REMOTE,
|
|
PREDICT,
|
|
MONITOR,
|
|
IR,
|
|
BRAUN_CALC,
|
|
TECHNIQUE_COMPENSATION_CALC,
|
|
}
|
|
|
|
pub impl CTempDStd {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CTempDStd{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDStd) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CTempDData{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CTempDData{
|
|
stime:chrono::NaiveDateTime,
|
|
status:Status,
|
|
extstatus:ExtStatus,
|
|
source:Source,
|
|
mode:Mode,
|
|
method:Method,
|
|
temperature:OBJECT::CNumDFloat,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Status{
|
|
#[default]
|
|
DATA_NOT_AVAIL,
|
|
DATA_COMPLETE,
|
|
DATA_FAILURE,
|
|
DATA_EXCEPTION,
|
|
DATA_PROCESSING,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum ExtStatus{
|
|
#[default]
|
|
NONE,
|
|
FINAL_POSITION,
|
|
FINAL_OVER_TEMP,
|
|
FINAL_OVER_TEMP_POSITION,
|
|
FINAL_UNDER_TEMP,
|
|
FINAL_UNDER_TEMP_POSITION,
|
|
MONITOR_POSITION,
|
|
MONITOR_OVER_TEMP,
|
|
MONITOR_OVER_TEMP_POSITION,
|
|
MONITOR_UNDER_TEMP,
|
|
MONITOR_UNDER_TEMP_POSITION,
|
|
CRC_FAILURE,
|
|
COMM_FAILURE,
|
|
FINAL_UNADJUSTED,
|
|
BUTTON_RANGE_ERROR,
|
|
AMB_RANGE_ERROR,
|
|
ENTRY_RANGE_ERROR,
|
|
TT_RANGE_ERROR,
|
|
TT_SLOPE_RANGE_ERROR,
|
|
OUTPUT_RANGE_ERROR,
|
|
CAP_STABILITY_ERROR,
|
|
CAP_ENTRY_ERROR,
|
|
PREMATURE_BUTTON_PRESS,
|
|
CALIBRATION,
|
|
UNADJUSTED_NO_OFFSETS,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Source{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
SURETEMP_SW,
|
|
SURETEMP,
|
|
SURETEMP_PLUS,
|
|
BRAUN_PRO4000,
|
|
BRAUN_PRO6000,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Mode{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
ORAL,
|
|
RECTAL,
|
|
PED_AXIL,
|
|
CAL_KEY,
|
|
ADULT_AXIL,
|
|
TYMPANIC,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Method{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
MANUAL,
|
|
DEVICE,
|
|
REMOTE,
|
|
PREDICT,
|
|
MONITOR,
|
|
IR,
|
|
BRAUN_CALC,
|
|
TECHNIQUE_COMPENSATION_CALC,
|
|
}
|
|
|
|
pub impl CTempDData {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CTempDData{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDData) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPTempDEng{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPTempDEng{
|
|
temp:float,
|
|
probe_temp:float,
|
|
heater:uint16,
|
|
reserved_1:uint16,
|
|
method:method,
|
|
algo:algo,
|
|
status:status,
|
|
error:error,
|
|
active:uint8,
|
|
probe_type:probe_type,
|
|
resistance:float,
|
|
ambient_temp:float,
|
|
ptb_resistance:float,
|
|
battery:uint16,
|
|
probe_temp_min:float,
|
|
probe_temp_max:float,
|
|
complete:uint8,
|
|
sample:uint32,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum method{
|
|
#[default]
|
|
PREDICT,
|
|
MONITOR,
|
|
CLINICAL,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum algo{
|
|
#[default]
|
|
NONE,
|
|
ORAL_ALG,
|
|
PED_AX_ALG,
|
|
ADULT_AX_ALG,
|
|
RECTAL_ALG,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum status{
|
|
#[default]
|
|
IDLE,
|
|
NOT_READY,
|
|
READY,
|
|
PREDICT,
|
|
PREDICT_DISPLAY,
|
|
PREDICT_POS,
|
|
FINAL,
|
|
FINAL_POS,
|
|
FINAL_OVER_TEMP,
|
|
FINAL_UNDER_TEMP,
|
|
FINAL_OVER_TEMP_POS,
|
|
FINAL_UNDER_TEMP_POS,
|
|
NO_PREDICT,
|
|
ERROR,
|
|
MONITOR,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum error{
|
|
#[default]
|
|
NO_ERROR,
|
|
ERROR_ALG_PROBE_OVER_TEMP,
|
|
ERROR_ALG_EXCESSIVE_HTR_ENERGY,
|
|
ERROR_ALG_OVER_AMB_TEMP,
|
|
ERROR_ALG_UNDER_AMB_TEMP,
|
|
ERROR_ALG_NO_PROBE_TEMP_RISE,
|
|
ERROR_ALG_BAD_PROBE_GAIN,
|
|
ERROR_ALG_BAD_PROBE_RESP_VAL,
|
|
ERROR_HTR_ON_NOT_OFF,
|
|
ERROR_HTR_OFF_NOT_ON,
|
|
ERROR_HTR_VOLT_HIGH_Q,
|
|
ERROR_HTR_VOLT_Q_HIGH_IMP,
|
|
ERROR_HTR_VOLT_LOW,
|
|
ERROR_HTR_FAILSAFE,
|
|
ERROR_AD_PULSE_LONG,
|
|
ERROR_AD_PULSE_SHORT,
|
|
ERROR_AD_RCAL_LONG,
|
|
ERROR_AD_RCAL_SHORT,
|
|
ERROR_AD_PTB_OVER,
|
|
ERROR_AD_PTB_UNDER,
|
|
ERROR_AD_TIMEOUT,
|
|
ERROR_CFG_XFER,
|
|
ERROR_CFG_SET_CRC,
|
|
ERROR_CFG_PROBE_CRC,
|
|
ERROR_CFG_CAL_CRC,
|
|
ERROR_CFG_LOG_CRC,
|
|
ERROR_CFG_NO_PROBE,
|
|
ERROR_CFG_UNIT_PROBE,
|
|
ERROR_CFG_ACK,
|
|
ERROR_CFG_INIT,
|
|
ERROR_BAT_HIGH,
|
|
ERROR_BAT_LOW,
|
|
ERROR_BAD_VIBES,
|
|
ERROR_NO_PROBE_WELL,
|
|
ERROR_POST_FAIL,
|
|
ERROR_INTERNAL_FAULT,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum probe_type{
|
|
#[default]
|
|
NO_PROBE,
|
|
ORAL,
|
|
RECTAL,
|
|
CALKEY,
|
|
}
|
|
|
|
pub impl CSTPTempDEng {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPTempDEng{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPTempDEng) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPDProbe{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPDProbe{
|
|
probetype:probeType,
|
|
partnumber:int8,
|
|
lotcode:uint32,
|
|
lotseqnum:int16,
|
|
probearrayloc:int16,
|
|
testpassfailcode:int16,
|
|
calsignature:int32,
|
|
caldatetime:chrono::NaiveDateTime,
|
|
heatergain:float,
|
|
heatertimedelay:float,
|
|
responses:float,
|
|
thermcalm:float,
|
|
thermcalb:float,
|
|
coefa:float,
|
|
coefb:float,
|
|
coefc:float,
|
|
coefd:float,
|
|
coefe:float,
|
|
probecyclecount:uint32,
|
|
devicecount:uint16,
|
|
lastdevicesn:int8,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum probeType{
|
|
#[default]
|
|
ORAL,
|
|
CALKEY,
|
|
RECTAL,
|
|
NONE,
|
|
}
|
|
|
|
pub impl CSTPDProbe {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPDProbe{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDProbe) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPDHState{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPDHState{
|
|
hardware:hardware,
|
|
state:int16,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum hardware{
|
|
#[default]
|
|
PROBE_WELL_SW,
|
|
PROBE_SW,
|
|
PROBE_CONNECTED_SW,
|
|
}
|
|
|
|
pub impl CSTPDHState {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPDHState{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDHState) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPDLock{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPDLock{
|
|
lock:lock,
|
|
state:int8,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum lock{
|
|
#[default]
|
|
DIGITAL_INPUT_LOCK,
|
|
AD_CHANNEL,
|
|
}
|
|
|
|
pub impl CSTPDLock {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPDLock{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDLock) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPDRData{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPDRData{
|
|
thermistor:uint32,
|
|
ptbresistor:uint32,
|
|
rcalresistor:uint32,
|
|
vref:uint32,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
pub impl CSTPDRData {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPDRData{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDRData) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPDStat{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPDStat{
|
|
state:state,
|
|
error:error,
|
|
hardwarestate:hardwareState,
|
|
finaltemp:float,
|
|
probetemp:float,
|
|
method:method,
|
|
probetype:probeType,
|
|
algorithm:algorithm,
|
|
battery:uint16,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum state{
|
|
#[default]
|
|
IDLE,
|
|
NOT_READY,
|
|
READY,
|
|
PREDICT,
|
|
PREDICT_DISPLAY,
|
|
PREDICT_POS,
|
|
FINAL,
|
|
FINAL_POS,
|
|
FINAL_OVER_TEMP,
|
|
FINAL_UNDER_TEMP,
|
|
FINAL_OVER_TEMP_POS,
|
|
FINAL_UNDER_TEMP_POS,
|
|
NO_PREDICT,
|
|
ERROR,
|
|
MONITOR,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum error{
|
|
#[default]
|
|
NO_ERROR,
|
|
ERROR_ALG_PROBE_OVER_TEMP,
|
|
ERROR_ALG_EXCESSIVE_HTR_ENERGY,
|
|
ERROR_ALG_OVER_AMB_TEMP,
|
|
ERROR_ALG_UNDER_AMB_TEMP,
|
|
ERROR_ALG_NO_PROBE_TEMP_RISE,
|
|
ERROR_ALG_BAD_PROBE_GAIN,
|
|
ERROR_ALG_BAD_PROBE_RESP_VAL,
|
|
ERROR_HTR_ON_NOT_OFF,
|
|
ERROR_HTR_OFF_NOT_ON,
|
|
ERROR_HTR_VOLT_HIGH_Q,
|
|
ERROR_HTR_VOLT_Q_HIGH_IMP,
|
|
ERROR_HTR_VOLT_LOW,
|
|
ERROR_HTR_FAILSAFE,
|
|
ERROR_AD_PULSE_LONG,
|
|
ERROR_AD_PULSE_SHORT,
|
|
ERROR_AD_RCAL_LONG,
|
|
ERROR_AD_RCAL_SHORT,
|
|
ERROR_AD_PTB_OVER,
|
|
ERROR_AD_PTB_UNDER,
|
|
ERROR_AD_TIMEOUT,
|
|
ERROR_CFG_XFER,
|
|
ERROR_CFG_SET_CRC,
|
|
ERROR_CFG_PROBE_CRC,
|
|
ERROR_CFG_CAL_CRC,
|
|
ERROR_CFG_LOG_CRC,
|
|
ERROR_CFG_NO_PROBE,
|
|
ERROR_CFG_UNIT_PROBE,
|
|
ERROR_CFG_ACK,
|
|
ERROR_CFG_INIT,
|
|
ERROR_BAT_HIGH,
|
|
ERROR_BAT_LOW,
|
|
ERROR_BAD_VIBES,
|
|
ERROR_NO_PROBE_WELL,
|
|
ERROR_POST_FAIL,
|
|
ERROR_INTERNAL_FAULT,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum hardwareState{
|
|
#[default]
|
|
probeConnected,
|
|
probePulled,
|
|
probeWellIn,
|
|
savingCal,
|
|
savingSettings,
|
|
takeReadingActive,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum method{
|
|
#[default]
|
|
PREDICT,
|
|
MONITOR,
|
|
CLINICAL,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum probeType{
|
|
#[default]
|
|
NO_PROBE,
|
|
ORAL,
|
|
RECTAL,
|
|
CALKEY,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum algorithm{
|
|
#[default]
|
|
NONE,
|
|
ORAL_ALG,
|
|
PED_AX_ALG,
|
|
ADULT_AX_ALG,
|
|
RECTAL_ALG,
|
|
}
|
|
|
|
pub impl CSTPDStat {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPDStat{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDStat) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPDSample{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPDSample{
|
|
channel:uint8,
|
|
error:uint8,
|
|
sample:uint32,
|
|
data:uint32,
|
|
temperature:float,
|
|
resistance:float,
|
|
last_rcal:uint32,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
pub impl CSTPDSample {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPDSample{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPDSample) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CTempDTouch{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CTempDTouch{
|
|
ele0:uint16,
|
|
ele1:uint16,
|
|
ele2:uint16,
|
|
touchstatus:uint16,
|
|
ele0bv:uint8,
|
|
ele1bv:uint8,
|
|
ele2bv:uint8,
|
|
hardwarestateir:hardwareStateIR,
|
|
samplecount:uint32,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum hardwareStateIR{
|
|
#[default]
|
|
TAKE_READING_ACTIVE,
|
|
PROBE_COVER_ON,
|
|
}
|
|
|
|
pub impl CTempDTouch {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CTempDTouch{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDTouch) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CTempDTherm{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CTempDTherm{
|
|
ambient:float,
|
|
ambient_count:int32,
|
|
thermopile:float,
|
|
thermopile_count:int32,
|
|
samplecount:uint32,
|
|
heaterpwm:int16,
|
|
heaterstate:heaterState,
|
|
heatererror:int16,
|
|
braun_ambient:float,
|
|
tcvalue:float,
|
|
pre_num:uint8,
|
|
post_num:uint8,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum heaterState{
|
|
#[default]
|
|
IDLE,
|
|
HEATER_TEST,
|
|
HEATER_ON,
|
|
READY,
|
|
ERROR,
|
|
}
|
|
|
|
pub impl CTempDTherm {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CTempDTherm{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnDATA }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempDTherm) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CTempCStd{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CTempCStd{
|
|
enabled:boolean,
|
|
installedmodule:InstalledModule,
|
|
displayunits:DisplayUnits,
|
|
mode:Mode,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum InstalledModule{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
SURETEMP_SW,
|
|
SURETEMP,
|
|
SURETEMP_PLUS,
|
|
BRAUN_PRO4000,
|
|
BRAUN_PRO6000,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum DisplayUnits{
|
|
#[default]
|
|
DEG_F,
|
|
DEG_C,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum Mode{
|
|
#[default]
|
|
NONE,
|
|
UNKNOWN,
|
|
ORAL,
|
|
ADULT_AXIL,
|
|
PED_AXIL,
|
|
LAST,
|
|
}
|
|
|
|
pub impl CTempCStd {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CTempCStd{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempCStd) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPCStd{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPCStd{
|
|
clinicalpause:uint16,
|
|
devicetype:deviceType,
|
|
dfltalgorithm:dfltAlgorithm,
|
|
ambientbias:float,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum deviceType{
|
|
#[default]
|
|
PREDICT_DEVICE,
|
|
MONITOR_DEVICE,
|
|
}
|
|
|
|
#[derive(Clone,Copy,Debug,Default)]
|
|
pub enum dfltAlgorithm{
|
|
#[default]
|
|
ORAL,
|
|
PED_AXILLARY,
|
|
ADULT_AXILLARY,
|
|
LAST,
|
|
}
|
|
|
|
pub impl CSTPCStd {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPCStd{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPCStd) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPCCal{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPCCal{
|
|
signature:uint32,
|
|
datetime:chrono::NaiveDateTime,
|
|
modconfig:float,
|
|
yp0:float,
|
|
rp0:float,
|
|
rptbeff:float,
|
|
rcaleff:float,
|
|
vref:float,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
pub impl CSTPCCal {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPCCal{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnCONFIG }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPCCal) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CTempPMsgArg{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CTempPMsgArg{
|
|
ioparametera:uint32,
|
|
ioparameterb:uint32,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
pub impl CTempPMsgArg {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CTempPMsgArg{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CTempPMsgArg) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|
|
impl FmTEMP for CSTPPSelector{}
|
|
#[derive(Getters,Builder,Clone,Debug)]
|
|
pub struct CSTPPSelector{
|
|
value:uint32,
|
|
#[getter(skip)]
|
|
raw_object:RawObject,
|
|
}
|
|
|
|
pub impl CSTPPSelector {
|
|
fn new() -> Self { todo!() }
|
|
}
|
|
impl Object for CSTPPSelector{
|
|
fn get_family(&self) -> datatypes::Family { datatypes::Family::FmTEMP }
|
|
fn get_genus(&self) -> datatypes::Genus { datatypes::Genus::GnPARAMETER }
|
|
fn get_species(&self) -> Box<dyn super::ObjectSpecies> { Box::new(FmTEMPSpecies::CSTPPSelector) }
|
|
fn get_raw_object(&self) -> RawObject { self.raw_object.clone() }
|
|
}
|
|
|