Index: NVDataMgmt.c =================================================================== diff -u -r96e4bcdf7e21468eda4f54cd504daf897f7e78b0 -rba2efce4509d89ecc27a5f179774e32ac358b9ce --- NVDataMgmt.c (.../NVDataMgmt.c) (revision 96e4bcdf7e21468eda4f54cd504daf897f7e78b0) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision ba2efce4509d89ecc27a5f179774e32ac358b9ce) @@ -97,6 +97,9 @@ #define RECORD_PADDING_LENGTH(rcrd, buf) (RECORD_BYTE_SIZE(rcrd) % buf == 0 ? 0 : ((U32)(RECORD_BYTE_SIZE(rcrd) / buf) + 1)) * buf #define RECORD_DEFAULT_TIME 0U ///< Record default time (calibration/set). +#define RECORD_FOURTH_ORDER_COEFF 0.0 ///< Record fourth order coefficient. +#define RECORD_THIRD_ORDER_COEFF 0.0 ///< Record third order coefficient. +#define RECORD_SECOND_ORDER_COEFF 0.0 ///< Record second order coefficient. #define RECORD_DEFAULT_GAIN 1.0 ///< Record default gain. #define RECORD_DEFAULT_OFFSET 0.0 ///< Record default offset. #define RECORD_DEFAULT_CONST 0.0 ///< Record default constant. @@ -471,8 +474,8 @@ // Record check helper functions static BOOL areRecordsValid( void ); -static BOOL isLinearRecordValid( LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); -static BOOL isNonlinearRecordValid( NON_LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); +static BOOL isPolynomialRecordValid( POLYNOMIAL_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); + #ifdef _DG_ static BOOL isDGCalibrationRecordValid( void ); static BOOL isDGConcPumpRecordValid( DG_CONC_PUMPS_CAL_DATA_T* record, BOOL isRecordNeeded ); @@ -489,6 +492,7 @@ #endif #ifdef _HD_ static BOOL isHDCalibrationRecordValid( void ); +static BOOL isNonlinearRecordValid( NON_LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); static BOOL isHDValveRecordValid( HD_VALVE_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); static BOOL isHDPumpRecordValid( HD_PUMP_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); static BOOL isHDAccelerometerSensorValid( HD_ACCELEROMETER_SENSOR_CAL_RECORD_T* record, BOOL isRecordNeeded ); @@ -2777,85 +2781,41 @@ /*********************************************************************//** * @brief - * The isLinearRecordValid function checks whether the records are still - * valid by calculating the CRCs and comparing it to the strucutre's CRC. + * The isPolynomialRecordValid function checks whether the records are + * still valid by calculating the CRCs and comparing it to the strucutre's + * CRC. * @details Inputs: none * @details Outputs: none - * @param record: pointer to a linear calibration payload. The actual calibration + * @param record: pointer to a polynomial payload. The actual calibration * data to be checked * @param isRecordNeeded: TRUE is the calibration record is need in the firmware * right now otherwise, FALSE * @return TRUE if the records' data is valid otherwise FALSE *************************************************************************/ -static BOOL isLinearRecordValid( LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ) +static BOOL isPolynomialRecordValid( POLYNOMIAL_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ) { BOOL status = TRUE; - U16 calcCRC = crc16 ( (U08*)record, sizeof(LINEAR_CAL_PAYLOAD_T) - sizeof(U16) ); + U16 calcCRC = crc16 ( (U08*)record, sizeof(POLYNOMIAL_CAL_PAYLOAD_T) - sizeof(U16) ); U16 recordCRC = record->crc; if ( calcCRC != recordCRC ) { // CRC did not pass so set all values to default - record->gain = RECORD_DEFAULT_GAIN; - record->offset = RECORD_DEFAULT_OFFSET; - record->calibrationTime = RECORD_DEFAULT_TIME; + record->fourthOrderCoeff = RECORD_FOURTH_ORDER_COEFF; + record->thirdOrderCoeff = RECORD_THIRD_ORDER_COEFF; + record->secondOrderCoeff = RECORD_SECOND_ORDER_COEFF; + record->gain = RECORD_DEFAULT_GAIN; + record->offset = RECORD_DEFAULT_OFFSET; + record->calibrationTime = RECORD_DEFAULT_TIME; // Recalculate the CRC with the default values - record->crc = crc16 ( (U08*)record, sizeof(LINEAR_CAL_PAYLOAD_T) - sizeof(U16) ); + record->crc = crc16 ( (U08*)record, sizeof(POLYNOMIAL_CAL_PAYLOAD_T) - sizeof(U16) ); - // Alarm if the CRC did not pass - activateAlarmNoData( ALARM_ID_NVDATAMGMT_INDIVIDUAL_RECORD_CRC_INVALID ); - - // Set the to FALSE since the record is not valid - status = FALSE; - } - - // Check if the record is needed. If it is needed, it should have a valid - // calibration time associated with it. - if ( TRUE == isRecordNeeded ) - { - // Check if the calibration time of the record is the default value - if ( record->calibrationTime == RECORD_DEFAULT_TIME ) + if ( isRecordNeeded == TRUE ) { - activateAlarmNoData( ALARM_ID_NVDATAMGMT_INDIVIDUAL_RECORD_TIME_INVALID ); + // Alarm if the CRC did not pass + activateAlarmNoData( ALARM_ID_NVDATAMGMT_INDIVIDUAL_RECORD_CRC_INVALID ); } - } - return status; -} - -/*********************************************************************//** - * @brief - * The isNonlinearRecordValid function checks whether the records are still - * valid by calculating the CRCs and comparing it to the strucutre's CRC. - * @details Inputs: none - * @details Outputs: none - * @param record: pointer to a non-linear calibration payload. The actual - * calibration data to be checked - * @param isRecordNeeded: TRUE is the calibration record is need in the - * firmware right now otherwise, FALSE - * @return TRUE if the records' data is valid otherwise FALSE - *************************************************************************/ -static BOOL isNonlinearRecordValid( NON_LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ) -{ - BOOL status = TRUE; - U16 calcCRC = crc16 ( (U08*)record, sizeof(NON_LINEAR_CAL_PAYLOAD_T) - sizeof(U16) ); - U16 recordCRC = record->crc; - - if ( calcCRC != recordCRC ) - { - // CRC did not pass so set all values to default - record->gain = RECORD_DEFAULT_GAIN; - record->offset = RECORD_DEFAULT_OFFSET; - record->reservedParam1 = RECORD_DEFAULT_CONST; - record->reservedParam2 = RECORD_DEFAULT_CONST; - record->reservedParam3 = RECORD_DEFAULT_CONST; - record->calibrationTime = RECORD_DEFAULT_TIME; - // Recalculate the CRC with the default values - record->crc = crc16 ( (U08*)record, sizeof(NON_LINEAR_CAL_PAYLOAD_T) - sizeof(U16) ); - - // Alarm if the CRC did not pass - activateAlarmNoData( ALARM_ID_NVDATAMGMT_INDIVIDUAL_RECORD_CRC_INVALID ); - // Set the to FALSE since the record is not valid status = FALSE; } @@ -2885,113 +2845,135 @@ *************************************************************************/ static BOOL isDGCalibrationRecordValid( void ) { -#ifdef _DG_ U32 i; - LINEAR_CAL_PAYLOAD_T* record; - BOOL isRecordValid = TRUE; + POLYNOMIAL_CAL_PAYLOAD_T* record; + BOOL isHardwareRecordValid = TRUE; + BOOL isCalRecordValid = TRUE; + // Get the calibration record of the hardware (i.e. pressure sensor) DG_PRES_SENSORS_CAL_RECORD_T* pressure = &dgCalibrationRecord.dgCalibrationGroups.presSensorsCalRecord; // The ones that are an array, are looped through for ( i = 0; i < NUM_OF_CAL_DATA_PRES_SENSORS; i++ ) { // Get calibration payload and assign it to a pointer - record = (LINEAR_CAL_PAYLOAD_T*)&pressure->pressureSensors[ i ]; + record = (POLYNOMIAL_CAL_PAYLOAD_T*)&pressure->pressureSensors[ i ]; // Check in the validity of the calibration data // If the variable is already FALSE, let it be FALSE. Even if one record is not // valid, the values should be set to benign values. This variable is used to decide // whether a write should be scheduled or not so it should not be overwritten with a TRUE // once a record set it to FALSE - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( record, TRUE ); + isHardwareRecordValid = isPolynomialRecordValid( record, TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_FLOW_SENSORS_CAL_RECORD_T* flow = &dgCalibrationRecord.dgCalibrationGroups.flowSensorsCalRecord; - record = (LINEAR_CAL_PAYLOAD_T*)&flow->flowSensors[ CAL_DATA_RO_PUMP_FLOW_SENSOR ]; - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( record, FALSE ); + record = (POLYNOMIAL_CAL_PAYLOAD_T*)&flow->flowSensors[ CAL_DATA_RO_PUMP_FLOW_SENSOR ]; + isHardwareRecordValid = isPolynomialRecordValid( record, TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_LOAD_CELLS_CAL_RECORD_T* load = &dgCalibrationRecord.dgCalibrationGroups.loadCellsCalRecord; for ( i = 0; i < NUM_OF_CAL_DATA_LOAD_CELLS; i++ ) { - record = (LINEAR_CAL_PAYLOAD_T*)&load->loadCells[ i ]; - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( record, TRUE ); + record = (POLYNOMIAL_CAL_PAYLOAD_T*)&load->loadCells[ i ]; + isHardwareRecordValid = isPolynomialRecordValid( record, TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_TEMP_SENSORS_CAL_RECORD_T* temperature = &dgCalibrationRecord.dgCalibrationGroups.tempSensorsCalRecord; for ( i = 0; i < NUM_OF_CAL_DATA_TEMP_SENSORS; i++ ) { - record = (LINEAR_CAL_PAYLOAD_T*)&temperature->tempSensors[ i ]; - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( record, FALSE ); + record = (POLYNOMIAL_CAL_PAYLOAD_T*)&temperature->tempSensors[ i ]; + isHardwareRecordValid = isPolynomialRecordValid( record, TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_COND_SENSORS_CAL_RECORD_T* cond = &dgCalibrationRecord.dgCalibrationGroups.condSensorsCalRecord; for ( i = 0; i < NUM_OF_CAL_DATA_COND_SENSORS; i++ ) { - record = (LINEAR_CAL_PAYLOAD_T*)&cond->condSensors[ i ]; - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( record, FALSE ); + record = (POLYNOMIAL_CAL_PAYLOAD_T*)&cond->condSensors[ i ]; + isHardwareRecordValid = isPolynomialRecordValid( record, TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_CONC_PUMPS_CAL_RECORD_T* concPump = &dgCalibrationRecord.dgCalibrationGroups.concentratePumpsRecord; for ( i = 0; i < NUM_OF_CAL_DATA_DG_CONC_PUMPS; i++ ) { - isRecordValid = isRecordValid == FALSE ? FALSE : isDGConcPumpRecordValid( &concPump->concentratePumps[ i ], FALSE ); + isHardwareRecordValid = isDGConcPumpRecordValid( &concPump->concentratePumps[ i ], FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_DRAIN_PUMP_CAL_RECORD_T* drainPump = &dgCalibrationRecord.dgCalibrationGroups.drainPumpRecord; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGDrainPumpRecordValid( drainPump, FALSE ); + isCalRecordValid = isDGDrainPumpRecordValid( drainPump, FALSE ) != TRUE ? FALSE : isCalRecordValid; + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_RO_PUMP_CAL_RECORD_T* roPump = &dgCalibrationRecord.dgCalibrationGroups.roPumpRecord; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGROPumpRecordValid( roPump, FALSE ); + isHardwareRecordValid = isDGROPumpRecordValid( roPump, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_DRAIN_LINE_VOLUME_T* drainLineVol = &dgCalibrationRecord.dgCalibrationGroups.drainLineVolumeRecord; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGDrainLineVolRecordValid( drainLineVol, FALSE ); + isHardwareRecordValid = isDGDrainLineVolRecordValid( drainLineVol, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_RESERVOIR_VOLUME_RECORD_T* reservoirVol = &dgCalibrationRecord.dgCalibrationGroups.reservoirVolumesRecord; for ( i = 0; i < NUM_OF_CAL_DATA_RSRVRS; i++ ) { - isRecordValid = isRecordValid == FALSE ? FALSE : isDGReservoirVolRecordValid( &reservoirVol->reservoir[ i ], FALSE ); + isHardwareRecordValid = isDGReservoirVolRecordValid( &reservoirVol->reservoir[ i ], FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_GENERIC_VOLUME_RECORD_T* genericVol = &dgCalibrationRecord.dgCalibrationGroups.genericVolumeRecord; for ( i = 0; i < 4; i++ ) { - isRecordValid = isRecordValid == FALSE ? FALSE : isDGGenericVolRecordValid( &genericVol->genericVolume[ i ], FALSE ); + isHardwareRecordValid = isDGGenericVolRecordValid( &genericVol->genericVolume[ i ], FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_ACID_CONCENTRATES_RECORD_T* acidConc = &dgCalibrationRecord.dgCalibrationGroups.acidConcentratesRecord; for ( i = 0; i < NUM_OF_CAL_DATA_ACID_CONCENTRATES; i++ ) { - isRecordValid = isRecordValid == FALSE ? FALSE : isDGAcidConcentrateRecordValid( &acidConc->acidConcentrate[ i ], TRUE ); + isHardwareRecordValid = isDGAcidConcentrateRecordValid( &acidConc->acidConcentrate[ i ], TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_BICARB_CONCENTRATES_RECORD_T* bicarbConc = &dgCalibrationRecord.dgCalibrationGroups.bicarbConcentratesRecord; for ( i = 0; i < NUM_OF_CAL_DATA_BICARB_CONCENTRATES; i++ ) { - isRecordValid = isRecordValid == FALSE ? FALSE : isDGBicarbConcentrateRecordValid( &bicarbConc->bicarbConcentrate[ i ], TRUE ); + isHardwareRecordValid = isDGBicarbConcentrateRecordValid( &bicarbConc->bicarbConcentrate[ i ], TRUE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } DG_FILTER_CAL_RECORD_T* roFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.roFilter; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( roFilter, FALSE ); + isHardwareRecordValid = isDGFilterRecordValid( roFilter, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_FILTER_CAL_RECORD_T* ultraFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.ultraFilter; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( ultraFilter, FALSE ); + isHardwareRecordValid = isDGFilterRecordValid( ultraFilter, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_FILTER_CAL_RECORD_T* sedimentFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.sedimentFilter; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( sedimentFilter, FALSE ); + isHardwareRecordValid = isDGFilterRecordValid( sedimentFilter, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_FILTER_CAL_RECORD_T* carbonFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.carbonFilter; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( carbonFilter, FALSE ); + isHardwareRecordValid = isDGFilterRecordValid( carbonFilter, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_FILTER_CAL_RECORD_T* carbonPolishFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.carbonPolishFilter; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( carbonPolishFilter, FALSE ); + isHardwareRecordValid = isDGFilterRecordValid( carbonPolishFilter, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; DG_FANS_CAL_RECORD_T* fan = &dgCalibrationRecord.dgCalibrationGroups.fansRecord; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGFanRecordValid( &fan->fan1, FALSE ); - isRecordValid == FALSE ? FALSE : isDGFanRecordValid( &fan->fan2, FALSE ); + isHardwareRecordValid = isDGFanRecordValid( &fan->fan1, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; + isHardwareRecordValid = isDGFanRecordValid( &fan->fan2, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; + DG_ACCELEROMETER_SENSOR_CAL_RECORD_T* accelerometer = &dgCalibrationRecord.dgCalibrationGroups.accelerometerCalRecord; - isRecordValid = isRecordValid == FALSE ? FALSE : isDGAccelerometerSensorRecordValid( accelerometer, FALSE ); + isHardwareRecordValid = isDGAccelerometerSensorRecordValid( accelerometer, FALSE ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; - return isRecordValid; -#endif + return isCalRecordValid; } /*********************************************************************//** @@ -3539,6 +3521,57 @@ #ifdef _HD_ /*********************************************************************//** * @brief + * The isNonlinearRecordValid function checks whether the records are still + * valid by calculating the CRCs and comparing it to the strucutre's CRC. + * @details Inputs: none + * @details Outputs: none + * @param record: pointer to a non-linear calibration payload. The actual + * calibration data to be checked + * @param isRecordNeeded: TRUE is the calibration record is need in the + * firmware right now otherwise, FALSE + * @return TRUE if the records' data is valid otherwise FALSE + *************************************************************************/ +static BOOL isNonlinearRecordValid( NON_LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(NON_LINEAR_CAL_PAYLOAD_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->gain = RECORD_DEFAULT_GAIN; + record->offset = RECORD_DEFAULT_OFFSET; + record->reservedParam1 = RECORD_DEFAULT_CONST; + record->reservedParam2 = RECORD_DEFAULT_CONST; + record->reservedParam3 = RECORD_DEFAULT_CONST; + record->calibrationTime = RECORD_DEFAULT_TIME; + // Recalculate the CRC with the default values + record->crc = crc16 ( (U08*)record, sizeof(NON_LINEAR_CAL_PAYLOAD_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass + activateAlarmNoData( ALARM_ID_NVDATAMGMT_INDIVIDUAL_RECORD_CRC_INVALID ); + + // Set the to FALSE since the record is not valid + status = FALSE; + } + + // Check if the record is needed. If it is needed, it should have a valid + // calibration time associated with it. + if ( TRUE == isRecordNeeded ) + { + // Check if the calibration time of the record is the default value + if ( record->calibrationTime == RECORD_DEFAULT_TIME ) + { + activateAlarmNoData( ALARM_ID_NVDATAMGMT_INDIVIDUAL_RECORD_TIME_INVALID ); + } + } + + return status; +} + +/*********************************************************************//** + * @brief * The isHDCalibrationRecordValid function checks whether HD calibration * record is valid or not. * @details Inputs: none @@ -3574,14 +3607,14 @@ // valid, the values should be set to benign values. This variable is used to decide // whether a write should be scheduled or not so it should not be overwritten with a TRUE // once a record set it to FALSE - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( linearRecord, TRUE ); + isRecordValid = isRecordValid == FALSE ? FALSE : isPolynomialRecordValid( linearRecord, TRUE ); } HD_FLOW_SENSORS_CAL_RECORD_T* flow = &hdCalibrationRecord.hdCalibrationGroups.flowSensorsCalRecord; for ( i = 0; i < NUM_OF_CAL_DATA_HD_FLOW_SENSORS; i++ ) { linearRecord = (LINEAR_CAL_PAYLOAD_T*)&flow->hdFlowSensors[ i ]; - isRecordValid = isRecordValid == FALSE ? FALSE : isLinearRecordValid( linearRecord, TRUE ); + isRecordValid = isRecordValid == FALSE ? FALSE : isPolynomialRecordValid( linearRecord, TRUE ); } HD_PRESSURE_SENSORS_CAL_RECORD_T* pressure = &hdCalibrationRecord.hdCalibrationGroups.pressureSensorsCalRecord; Index: NVDataMgmtDGRecords.h =================================================================== diff -u -r76016122c2646fe718a67782f9a818163bf6923f -rba2efce4509d89ecc27a5f179774e32ac358b9ce --- NVDataMgmtDGRecords.h (.../NVDataMgmtDGRecords.h) (revision 76016122c2646fe718a67782f9a818163bf6923f) +++ NVDataMgmtDGRecords.h (.../NVDataMgmtDGRecords.h) (revision ba2efce4509d89ecc27a5f179774e32ac358b9ce) @@ -139,14 +139,17 @@ } SCHEDULED_DG_RUNS_T; #pragma pack(push, 1) -/// Linear calibration structure +/// Polynomial calibration structure typedef struct { + F32 fourthOrderCoeff; ///< Fourth order coefficient. + F32 thirdOrderCoeff; ///< Third order coefficient. + F32 secondOrderCoeff; ///< Second order coefficient. F32 gain; ///< Gain. F32 offset; ///< Offset. U32 calibrationTime; ///< Calibration time. - U16 crc; ///< CRC for the linear calibration payload. -} LINEAR_CAL_PAYLOAD_T; + U16 crc; ///< CRC for the polynomial calibration payload. +} POLYNOMIAL_CAL_PAYLOAD_T; /// DG concentrate pumps one-gain payload typedef struct @@ -184,43 +187,43 @@ /// Pressure sensors calibration structure typedef struct { - LINEAR_CAL_PAYLOAD_T pressureSensors[ NUM_OF_CAL_DATA_PRES_SENSORS ]; ///< Pressure sensors to calibrate. + POLYNOMIAL_CAL_PAYLOAD_T pressureSensors[ NUM_OF_CAL_DATA_PRES_SENSORS ]; ///< Pressure sensors to calibrate. // NOTE: The reserved space is for 6 sensors. This portion of the struct should be eventually be // reduced, so #define was not used for the size of the array - LINEAR_CAL_PAYLOAD_T reservedSpace[ 6 ]; ///< Reserved space for future pressure sensors. + POLYNOMIAL_CAL_PAYLOAD_T reservedSpace[ 6 ]; ///< Reserved space for future pressure sensors. } DG_PRES_SENSORS_CAL_RECORD_T; /// Flow sensors calibration structure typedef struct { - LINEAR_CAL_PAYLOAD_T flowSensors[ NUM_OF_CAL_DATA_FLOW_SENSORS ]; ///< Flow sensors to calibrate. + POLYNOMIAL_CAL_PAYLOAD_T flowSensors[ NUM_OF_CAL_DATA_FLOW_SENSORS ]; ///< Flow sensors to calibrate. // NOTE: The reserved space is for 6 sensors. This portion of the struct should be eventually be // reduced, so #define was not used for the size of the array - LINEAR_CAL_PAYLOAD_T reservedSpace[ 3 ]; ///< Reserved space for future flow sensors. + POLYNOMIAL_CAL_PAYLOAD_T reservedSpace[ 3 ]; ///< Reserved space for future flow sensors. } DG_FLOW_SENSORS_CAL_RECORD_T; /// Load cells calibration structure typedef struct { - LINEAR_CAL_PAYLOAD_T loadCells[ NUM_OF_CAL_DATA_LOAD_CELLS ]; ///< Load cells to calibrate. + POLYNOMIAL_CAL_PAYLOAD_T loadCells[ NUM_OF_CAL_DATA_LOAD_CELLS ]; ///< Load cells to calibrate. } DG_LOAD_CELLS_CAL_RECORD_T; /// Temperature sensors calibration structure typedef struct { - LINEAR_CAL_PAYLOAD_T tempSensors[ NUM_OF_CAL_DATA_TEMP_SENSORS ]; ///< Temperature sensors to calibrate. + POLYNOMIAL_CAL_PAYLOAD_T tempSensors[ NUM_OF_CAL_DATA_TEMP_SENSORS ]; ///< Temperature sensors to calibrate. // NOTE: The reserved space is for 6 sensors. This portion of the struct should be eventually be // reduced, so #define was not used for the size of the array - LINEAR_CAL_PAYLOAD_T reservedSpace[ 5 ]; ///< Reserved space for future temperature sensors. + POLYNOMIAL_CAL_PAYLOAD_T reservedSpace[ 5 ]; ///< Reserved space for future temperature sensors. } DG_TEMP_SENSORS_CAL_RECORD_T; /// Conductivity sensors calibration structure typedef struct { - LINEAR_CAL_PAYLOAD_T condSensors[ NUM_OF_CAL_DATA_COND_SENSORS ]; ///< Conductivity sensors to calibrate. + POLYNOMIAL_CAL_PAYLOAD_T condSensors[ NUM_OF_CAL_DATA_COND_SENSORS ]; ///< Conductivity sensors to calibrate. // NOTE: The reserved space is for 6 sensors. This portion of the struct should be eventually be // reduced, so #define was not used for the size of the array - LINEAR_CAL_PAYLOAD_T reservedSpace[ 2 ]; ///< Reserved space for future conductivity sensors. + POLYNOMIAL_CAL_PAYLOAD_T reservedSpace[ 2 ]; ///< Reserved space for future conductivity sensors. } DG_COND_SENSORS_CAL_RECORD_T; /// Drain line volume calibration structure