further implementation; cal and non-cal outputs, bulb and indicator props

gigapod · gigapod · commit 6f49d3d49ef7 · 2023-11-12T11:30:53.000-07:00
diff --git a/src/Flux/flxDevAS7265x.cpp b/src/Flux/flxDevAS7265x.cpp
@@ -31,34 +31,41 @@ flxRegisterDevice(flxDevAS7265X);
 //----------------------------------------------------------------------------------------------------------
 /// @brief Constructor
 ///
-flxDevAS7265X::flxDevAS7265X() 
+flxDevAS7265X::flxDevAS7265X() : _indicator{true}
 {
 
     setName(getDeviceName(), "AS7265X Triad Spectroscopy Sensor");
 
+    // Properties
+    flxRegister(readWithLED, "Enable LED", "Measure with LED enabled");
+    flxRegister(enableIndicator, "Enable Indicator", "Indicator LED enabled");
+    flxRegister(outputCal, "Calibrated Output", "Return calibrated values");
+
     // Register output params
-    flxRegister(outCalA, "Calibrated A", "Calibrated channel A");
-    flxRegister(outCalB, "Calibrated B", "Calibrated channel B");
-    flxRegister(outCalC, "Calibrated C", "Calibrated channel C");
-    flxRegister(outCalD, "Calibrated D", "Calibrated channel D");
-    flxRegister(outCalE, "Calibrated E", "Calibrated channel E");
-    flxRegister(outCalF, "Calibrated F", "Calibrated channel F");
+    flxRegister(outputType, "Calibrated", "True if output data is calibrated");
+
+    flxRegister(outA, "Channel A");
+    flxRegister(outB, "Channel B");
+    flxRegister(outC, "Channel C");
+    flxRegister(outD, "Channel D");
+    flxRegister(outE, "Channel E");
+    flxRegister(outF, "Channel F");
 
     // Register output params
-    flxRegister(outCalG, "Calibrated G", "Calibrated channel G");
-    flxRegister(outCalH, "Calibrated H", "Calibrated channel H");
-    flxRegister(outCalI, "Calibrated I", "Calibrated channel I");
-    flxRegister(outCalJ, "Calibrated J", "Calibrated channel J");
-    flxRegister(outCalK, "Calibrated K", "Calibrated channel K");
-    flxRegister(outCalL, "Calibrated L", "Calibrated channel L"); 
+    flxRegister(outG, "Channel G");
+    flxRegister(outH, "Channel H");
+    flxRegister(outI, "Channel I");
+    flxRegister(outJ, "Channel J");
+    flxRegister(outK, "Channel K");
+    flxRegister(outL, "Channel L"); 
 
     // Register output params
-    flxRegister(outCalR, "Calibrated R", "Calibrated channel R");
-    flxRegister(outCalS, "Calibrated S", "Calibrated channel S");
-    flxRegister(outCalT, "Calibrated T", "Calibrated channel T");
-    flxRegister(outCalU, "Calibrated U", "Calibrated channel U");
-    flxRegister(outCalV, "Calibrated V", "Calibrated channel V");
-    flxRegister(outCalW, "Calibrated W", "Calibrated channel W");                     
+    flxRegister(outR, "Channel R");
+    flxRegister(outS, "Channel S");
+    flxRegister(outT, "Channel T");
+    flxRegister(outU, "Channel U");
+    flxRegister(outV, "Channel V");
+    flxRegister(outW, "Channel W");                     
 
 }
 
@@ -91,9 +98,39 @@ bool flxDevAS7265X::onInitialize(TwoWire &wirePort)
 }
 
 
+//---------------------------------------------------------------------------
+// Indicator property
+//---------------------------------------------------------------------------
+bool flxDevAS7265X::get_indicator(void)
+{
+    return _indicator;
+}
+
+
+void flxDevAS7265X::set_indicator(bool isOn)
+{
+    if (_indicator == isOn)
+        return;
+
+    if (isOn)
+        AS7265X::enableIndicator();
+    else 
+        AS7265X::disableIndicator();    
+
+    _indicator = isOn;
+}
+
+//---------------------------------------------------------------------------
+///
+/// @brief Called right before data parameters are read - take measurments called
+///
+
 bool flxDevAS7265X::execute(void)
 {
-    AS7265X::takeMeasurements();
+    if (readWithLED())
+        AS7265X::takeMeasurementsWithBulb();
+    else
+        AS7265X::takeMeasurements();
 
     return true;
 }
@@ -102,83 +139,87 @@ bool flxDevAS7265X::execute(void)
 // Outputs
 //---------------------------------------------------------------------------
 
+bool flxDevAS7265X::read_output_type(void)
+{
+    return outputCal();
+}
 //---------------------------------------------------------------------------
 
-float flxDevAS7265X::read_calA(void)
+float flxDevAS7265X::read_A(void)
 {
-    return AS7265X::getCalibratedA();
+    return outputCal() ? AS7265X::getCalibratedA() : AS7265X::getA();
 }
 
-float flxDevAS7265X::read_calB(void)
+float flxDevAS7265X::read_B(void)
 {
-    return AS7265X::getCalibratedB();
+    return outputCal() ? AS7265X::getCalibratedB() : AS7265X::getB();
 }
 
-float flxDevAS7265X::read_calC(void)
+float flxDevAS7265X::read_C(void)
 {
-    return AS7265X::getCalibratedC();
+    return outputCal() ? AS7265X::getCalibratedC() : AS7265X::getC();
 }
 
-float flxDevAS7265X::read_calD(void)
+float flxDevAS7265X::read_D(void)
 {
-    return AS7265X::getCalibratedD();
+    return outputCal() ? AS7265X::getCalibratedD() : AS7265X::getD();
 }
 
-float flxDevAS7265X::read_calE(void)
+float flxDevAS7265X::read_E(void)
 {
-    return AS7265X::getCalibratedE();
+    return outputCal() ? AS7265X::getCalibratedE() : AS7265X::getE();
 }
 
-float flxDevAS7265X::read_calF(void)
+float flxDevAS7265X::read_F(void)
 {
-    return AS7265X::getCalibratedF();
+    return outputCal() ? AS7265X::getCalibratedF() : AS7265X::getF();
 }
 
-float flxDevAS7265X::read_calG(void)
+float flxDevAS7265X::read_G(void)
 {
-    return AS7265X::getCalibratedG();
+    return outputCal() ? AS7265X::getCalibratedG() : AS7265X::getG();
 }
-float flxDevAS7265X::read_calH(void)
+float flxDevAS7265X::read_H(void)
 {
-    return AS7265X::getCalibratedH();
+    return outputCal() ? AS7265X::getCalibratedH() : AS7265X::getH();
 }
-float flxDevAS7265X::read_calI(void)
+float flxDevAS7265X::read_I(void)
 {
-    return AS7265X::getCalibratedI();
+    return outputCal() ? AS7265X::getCalibratedI() : AS7265X::getI();
 }
-float flxDevAS7265X::read_calJ(void)
+float flxDevAS7265X::read_J(void)
 {
-    return AS7265X::getCalibratedJ();
+    return outputCal() ? AS7265X::getCalibratedJ() : AS7265X::getJ();
 }
-float flxDevAS7265X::read_calK(void)
+float flxDevAS7265X::read_K(void)
 {
-    return AS7265X::getCalibratedK();
+    return outputCal() ? AS7265X::getCalibratedK() : AS7265X::getK();
 }
-float flxDevAS7265X::read_calL(void)
+float flxDevAS7265X::read_L(void)
 {
-    return AS7265X::getCalibratedL();
+    return outputCal() ? AS7265X::getCalibratedL() : AS7265X::getL();
 }
-float flxDevAS7265X::read_calR(void)
+float flxDevAS7265X::read_R(void)
 {
-    return AS7265X::getCalibratedR();
+    return outputCal() ? AS7265X::getCalibratedR() : AS7265X::getR();
 }
-float flxDevAS7265X::read_calS(void)
+float flxDevAS7265X::read_S(void)
 {
-    return AS7265X::getCalibratedS();
+    return outputCal() ? AS7265X::getCalibratedS() : AS7265X::getS();
 }
-float flxDevAS7265X::read_calT(void)
+float flxDevAS7265X::read_T(void)
 {
-    return AS7265X::getCalibratedT();
+    return outputCal() ? AS7265X::getCalibratedT() : AS7265X::getT();
 }
-float flxDevAS7265X::read_calU(void)
+float flxDevAS7265X::read_U(void)
 {
-    return AS7265X::getCalibratedU();
+    return outputCal() ? AS7265X::getCalibratedU() : AS7265X::getU();
 }
-float flxDevAS7265X::read_calV(void)
+float flxDevAS7265X::read_V(void)
 {
-    return AS7265X::getCalibratedV();
+    return outputCal() ? AS7265X::getCalibratedV() : AS7265X::getV();
 }
-float flxDevAS7265X::read_calW(void)
+float flxDevAS7265X::read_W(void)
 {
-    return AS7265X::getCalibratedW();
+    return outputCal() ? AS7265X::getCalibratedW() : AS7265X::getW();
 }
diff --git a/src/Flux/flxDevAS7265x.h b/src/Flux/flxDevAS7265x.h
@@ -51,49 +51,76 @@ class flxDevAS7265X : public flxDeviceI2CType<flxDevAS7265X>, public AS7265X
     bool execute(void);
 
   private:
+
+    // property methods
+
+    bool get_indicator(void);
+    void set_indicator(bool);
+
+    bool _indicator;
+
+
+
+
     // Parameter methods
-    float read_calA();
-    float read_calB();
-    float read_calC();
-    float read_calD();
-    float read_calE();
-    float read_calF();
-
-    float read_calG();
-    float read_calH();
-    float read_calI();
-    float read_calJ();
-    float read_calK();
-    float read_calL();
-
-    float read_calR();
-    float read_calS();
-    float read_calT();
-    float read_calU();
-    float read_calV();
-    float read_calW();
+    bool  read_output_type(void);
+    float read_A(void);
+    float read_B(void);
+    float read_C(void);
+    float read_D(void);
+    float read_E(void);
+    float read_F(void);
+
+    float read_G(void);
+    float read_H(void);
+    float read_I(void);
+    float read_J(void);
+    float read_K(void);
+    float read_L(void);
+
+    float read_R(void);
+    float read_S(void);
+    float read_T(void);
+    float read_U(void);
+    float read_V(void);
+    float read_W(void);
 
   public:
 
-    // Define our output parameters - specify the get functions to call.
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calA> outCalA;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calB> outCalB;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calC> outCalC;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calD> outCalD;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calE> outCalE;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calF> outCalF;      
-
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calG> outCalG;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calH> outCalH;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calI> outCalI;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calJ> outCalJ;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calK> outCalK;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calL> outCalL;
-
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calR> outCalR;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calS> outCalS;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calT> outCalT;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calU> outCalU;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calV> outCalV;
-    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_calW> outCalW;              
+    // Properties
+
+    // Read with LED active?
+
+    flxPropertyBool<flxDevAS7265X> readWithLED = {false};
+
+    flxPropertyRWBool<flxDevAS7265X, &flxDevAS7265X::get_indicator, &flxDevAS7265X::set_indicator> enableIndicator = {true};
+
+    flxPropertyBool<flxDevAS7265X> outputCal = {true};
+
+
+    // Outputs
+    // define parameters for calibrarted outputs
+    flxParameterOutBool<flxDevAS7265X, &flxDevAS7265X::read_output_type> outputType;
+
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_A> outA;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_B> outB;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_C> outC;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_D> outD;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_E> outE;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_F> outF;      
+
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_G> outG;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_H> outH;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_I> outI;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_J> outJ;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_K> outK;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_L> outL;
+
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_R> outR;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_S> outS;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_T> outT;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_U> outU;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_V> outV;
+    flxParameterOutFloat<flxDevAS7265X, &flxDevAS7265X::read_W> outW;      
+
 };

Original file line number	Diff line number	Diff line change
`@@ -31,34 +31,41 @@ flxRegisterDevice(flxDevAS7265X);`
`31`	`31`	`//----------------------------------------------------------------------------------------------------------`
`32`	`32`	`/// @brief Constructor`
`33`	`33`	`///`
`34`		`-flxDevAS7265X::flxDevAS7265X()`
	`34`	`+flxDevAS7265X::flxDevAS7265X() : _indicator{true}`
`35`	`35`	`{`
`36`	`36`
`37`	`37`	`setName(getDeviceName(), "AS7265X Triad Spectroscopy Sensor");`
`38`	`38`
	`39`	`+ // Properties`
	`40`	`+ flxRegister(readWithLED, "Enable LED", "Measure with LED enabled");`
	`41`	`+ flxRegister(enableIndicator, "Enable Indicator", "Indicator LED enabled");`
	`42`	`+ flxRegister(outputCal, "Calibrated Output", "Return calibrated values");`
	`43`	`+`
`39`	`44`	`// Register output params`
`40`		`- flxRegister(outCalA, "Calibrated A", "Calibrated channel A");`
`41`		`- flxRegister(outCalB, "Calibrated B", "Calibrated channel B");`
`42`		`- flxRegister(outCalC, "Calibrated C", "Calibrated channel C");`
`43`		`- flxRegister(outCalD, "Calibrated D", "Calibrated channel D");`
`44`		`- flxRegister(outCalE, "Calibrated E", "Calibrated channel E");`
`45`		`- flxRegister(outCalF, "Calibrated F", "Calibrated channel F");`
	`45`	`+ flxRegister(outputType, "Calibrated", "True if output data is calibrated");`
	`46`	`+`
	`47`	`+ flxRegister(outA, "Channel A");`
	`48`	`+ flxRegister(outB, "Channel B");`
	`49`	`+ flxRegister(outC, "Channel C");`
	`50`	`+ flxRegister(outD, "Channel D");`
	`51`	`+ flxRegister(outE, "Channel E");`
	`52`	`+ flxRegister(outF, "Channel F");`
`46`	`53`
`47`	`54`	`// Register output params`
`48`		`- flxRegister(outCalG, "Calibrated G", "Calibrated channel G");`
`49`		`- flxRegister(outCalH, "Calibrated H", "Calibrated channel H");`
`50`		`- flxRegister(outCalI, "Calibrated I", "Calibrated channel I");`
`51`		`- flxRegister(outCalJ, "Calibrated J", "Calibrated channel J");`
`52`		`- flxRegister(outCalK, "Calibrated K", "Calibrated channel K");`
`53`		`- flxRegister(outCalL, "Calibrated L", "Calibrated channel L");`
	`55`	`+ flxRegister(outG, "Channel G");`
	`56`	`+ flxRegister(outH, "Channel H");`
	`57`	`+ flxRegister(outI, "Channel I");`
	`58`	`+ flxRegister(outJ, "Channel J");`
	`59`	`+ flxRegister(outK, "Channel K");`
	`60`	`+ flxRegister(outL, "Channel L");`
`54`	`61`
`55`	`62`	`// Register output params`
`56`		`- flxRegister(outCalR, "Calibrated R", "Calibrated channel R");`
`57`		`- flxRegister(outCalS, "Calibrated S", "Calibrated channel S");`
`58`		`- flxRegister(outCalT, "Calibrated T", "Calibrated channel T");`
`59`		`- flxRegister(outCalU, "Calibrated U", "Calibrated channel U");`
`60`		`- flxRegister(outCalV, "Calibrated V", "Calibrated channel V");`
`61`		`- flxRegister(outCalW, "Calibrated W", "Calibrated channel W");`
	`63`	`+ flxRegister(outR, "Channel R");`
	`64`	`+ flxRegister(outS, "Channel S");`
	`65`	`+ flxRegister(outT, "Channel T");`
	`66`	`+ flxRegister(outU, "Channel U");`
	`67`	`+ flxRegister(outV, "Channel V");`
	`68`	`+ flxRegister(outW, "Channel W");`
`62`	`69`
`63`	`70`	`}`
`64`	`71`
`@@ -91,9 +98,39 @@ bool flxDevAS7265X::onInitialize(TwoWire &wirePort)`
`91`	`98`	`}`
`92`	`99`
`93`	`100`
	`101`	`+//---------------------------------------------------------------------------`
	`102`	`+// Indicator property`
	`103`	`+//---------------------------------------------------------------------------`
	`104`	`+bool flxDevAS7265X::get_indicator(void)`
	`105`	`+{`
	`106`	`+ return _indicator;`
	`107`	`+}`
	`108`	`+`
	`109`	`+`
	`110`	`+void flxDevAS7265X::set_indicator(bool isOn)`
	`111`	`+{`
	`112`	`+ if (_indicator == isOn)`
	`113`	`+ return;`
	`114`	`+`
	`115`	`+ if (isOn)`
	`116`	`+ AS7265X::enableIndicator();`
	`117`	`+ else`
	`118`	`+ AS7265X::disableIndicator();`
	`119`	`+`
	`120`	`+ _indicator = isOn;`
	`121`	`+}`
	`122`	`+`
	`123`	`+//---------------------------------------------------------------------------`
	`124`	`+///`
	`125`	`+/// @brief Called right before data parameters are read - take measurments called`
	`126`	`+///`
	`127`	`+`
`94`	`128`	`bool flxDevAS7265X::execute(void)`
`95`	`129`	`{`
`96`		`- AS7265X::takeMeasurements();`
	`130`	`+ if (readWithLED())`
	`131`	`+ AS7265X::takeMeasurementsWithBulb();`
	`132`	`+ else`
	`133`	`+ AS7265X::takeMeasurements();`
`97`	`134`
`98`	`135`	`return true;`
`99`	`136`	`}`
`@@ -102,83 +139,87 @@ bool flxDevAS7265X::execute(void)`
`102`	`139`	`// Outputs`
`103`	`140`	`//---------------------------------------------------------------------------`
`104`	`141`
	`142`	`+bool flxDevAS7265X::read_output_type(void)`
	`143`	`+{`
	`144`	`+ return outputCal();`
	`145`	`+}`
`105`	`146`	`//---------------------------------------------------------------------------`
`106`	`147`
`107`		`-float flxDevAS7265X::read_calA(void)`
	`148`	`+float flxDevAS7265X::read_A(void)`
`108`	`149`	`{`
`109`		`- return AS7265X::getCalibratedA();`
	`150`	`+ return outputCal() ? AS7265X::getCalibratedA() : AS7265X::getA();`
`110`	`151`	`}`
`111`	`152`
`112`		`-float flxDevAS7265X::read_calB(void)`
	`153`	`+float flxDevAS7265X::read_B(void)`
`113`	`154`	`{`
`114`		`- return AS7265X::getCalibratedB();`
	`155`	`+ return outputCal() ? AS7265X::getCalibratedB() : AS7265X::getB();`
`115`	`156`	`}`
`116`	`157`
`117`		`-float flxDevAS7265X::read_calC(void)`
	`158`	`+float flxDevAS7265X::read_C(void)`
`118`	`159`	`{`
`119`		`- return AS7265X::getCalibratedC();`
	`160`	`+ return outputCal() ? AS7265X::getCalibratedC() : AS7265X::getC();`
`120`	`161`	`}`
`121`	`162`
`122`		`-float flxDevAS7265X::read_calD(void)`
	`163`	`+float flxDevAS7265X::read_D(void)`
`123`	`164`	`{`
`124`		`- return AS7265X::getCalibratedD();`
	`165`	`+ return outputCal() ? AS7265X::getCalibratedD() : AS7265X::getD();`
`125`	`166`	`}`
`126`	`167`
`127`		`-float flxDevAS7265X::read_calE(void)`
	`168`	`+float flxDevAS7265X::read_E(void)`
`128`	`169`	`{`
`129`		`- return AS7265X::getCalibratedE();`
	`170`	`+ return outputCal() ? AS7265X::getCalibratedE() : AS7265X::getE();`
`130`	`171`	`}`
`131`	`172`
`132`		`-float flxDevAS7265X::read_calF(void)`
	`173`	`+float flxDevAS7265X::read_F(void)`
`133`	`174`	`{`
`134`		`- return AS7265X::getCalibratedF();`
	`175`	`+ return outputCal() ? AS7265X::getCalibratedF() : AS7265X::getF();`
`135`	`176`	`}`
`136`	`177`
`137`		`-float flxDevAS7265X::read_calG(void)`
	`178`	`+float flxDevAS7265X::read_G(void)`
`138`	`179`	`{`
`139`		`- return AS7265X::getCalibratedG();`
	`180`	`+ return outputCal() ? AS7265X::getCalibratedG() : AS7265X::getG();`
`140`	`181`	`}`
`141`		`-float flxDevAS7265X::read_calH(void)`
	`182`	`+float flxDevAS7265X::read_H(void)`
`142`	`183`	`{`
`143`		`- return AS7265X::getCalibratedH();`
	`184`	`+ return outputCal() ? AS7265X::getCalibratedH() : AS7265X::getH();`
`144`	`185`	`}`
`145`		`-float flxDevAS7265X::read_calI(void)`
	`186`	`+float flxDevAS7265X::read_I(void)`
`146`	`187`	`{`
`147`		`- return AS7265X::getCalibratedI();`
	`188`	`+ return outputCal() ? AS7265X::getCalibratedI() : AS7265X::getI();`
`148`	`189`	`}`
`149`		`-float flxDevAS7265X::read_calJ(void)`
	`190`	`+float flxDevAS7265X::read_J(void)`
`150`	`191`	`{`
`151`		`- return AS7265X::getCalibratedJ();`
	`192`	`+ return outputCal() ? AS7265X::getCalibratedJ() : AS7265X::getJ();`
`152`	`193`	`}`
`153`		`-float flxDevAS7265X::read_calK(void)`
	`194`	`+float flxDevAS7265X::read_K(void)`
`154`	`195`	`{`
`155`		`- return AS7265X::getCalibratedK();`
	`196`	`+ return outputCal() ? AS7265X::getCalibratedK() : AS7265X::getK();`
`156`	`197`	`}`
`157`		`-float flxDevAS7265X::read_calL(void)`
	`198`	`+float flxDevAS7265X::read_L(void)`
`158`	`199`	`{`
`159`		`- return AS7265X::getCalibratedL();`
	`200`	`+ return outputCal() ? AS7265X::getCalibratedL() : AS7265X::getL();`
`160`	`201`	`}`
`161`		`-float flxDevAS7265X::read_calR(void)`
	`202`	`+float flxDevAS7265X::read_R(void)`
`162`	`203`	`{`
`163`		`- return AS7265X::getCalibratedR();`
	`204`	`+ return outputCal() ? AS7265X::getCalibratedR() : AS7265X::getR();`
`164`	`205`	`}`
`165`		`-float flxDevAS7265X::read_calS(void)`
	`206`	`+float flxDevAS7265X::read_S(void)`
`166`	`207`	`{`
`167`		`- return AS7265X::getCalibratedS();`
	`208`	`+ return outputCal() ? AS7265X::getCalibratedS() : AS7265X::getS();`
`168`	`209`	`}`
`169`		`-float flxDevAS7265X::read_calT(void)`
	`210`	`+float flxDevAS7265X::read_T(void)`
`170`	`211`	`{`
`171`		`- return AS7265X::getCalibratedT();`
	`212`	`+ return outputCal() ? AS7265X::getCalibratedT() : AS7265X::getT();`
`172`	`213`	`}`
`173`		`-float flxDevAS7265X::read_calU(void)`
	`214`	`+float flxDevAS7265X::read_U(void)`
`174`	`215`	`{`
`175`		`- return AS7265X::getCalibratedU();`
	`216`	`+ return outputCal() ? AS7265X::getCalibratedU() : AS7265X::getU();`
`176`	`217`	`}`
`177`		`-float flxDevAS7265X::read_calV(void)`
	`218`	`+float flxDevAS7265X::read_V(void)`
`178`	`219`	`{`
`179`		`- return AS7265X::getCalibratedV();`
	`220`	`+ return outputCal() ? AS7265X::getCalibratedV() : AS7265X::getV();`
`180`	`221`	`}`
`181`		`-float flxDevAS7265X::read_calW(void)`
	`222`	`+float flxDevAS7265X::read_W(void)`
`182`	`223`	`{`
`183`		`- return AS7265X::getCalibratedW();`
	`224`	`+ return outputCal() ? AS7265X::getCalibratedW() : AS7265X::getW();`
`184`	`225`	`}`