Index: NVDataMgmt.c =================================================================== diff -u -rc1881f60c442c55ec04b54b8ee9000d2ac9dca8d -r76016122c2646fe718a67782f9a818163bf6923f --- NVDataMgmt.c (.../NVDataMgmt.c) (revision c1881f60c442c55ec04b54b8ee9000d2ac9dca8d) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision 76016122c2646fe718a67782f9a818163bf6923f) @@ -98,7 +98,7 @@ #define RECORD_DEFAULT_TIME 0U ///< Record default time (calibration/set). #define RECORD_DEFAULT_GAIN 1.0 ///< Record default gain. -#define RECORD_DEFAULT_OFFSET 0.0 ///< Record defautl offset. +#define RECORD_DEFAULT_OFFSET 0.0 ///< Record default offset. #define RECORD_DEFAULT_CONST 0.0 ///< Record default constant. #define RECORD_DEFAULT_RATIO 1.0 ///< Record default ratio. @@ -266,17 +266,17 @@ DG_LOAD_CELLS_CAL_RECORD_T loadCellsCalRecord; ///< DG load cells. DG_TEMP_SENSORS_CAL_RECORD_T tempSensorsCalRecord; ///< DG temperature sensors. DG_COND_SENSORS_CAL_RECORD_T condSensorsCalRecord; ///< DG conductivity sensors. - DG_CONC_PUMPS_CAL_RECORD_T concentratePumps; ///< DG concentrate pumps. - DG_DRAIN_PUMP_CAL_RECORD_T drainPump; ///< DG drain pump. - DG_RO_PUMP_CAL_RECORD_T roPump; ///< DG RO pump. - DG_DRAIN_LINE_VOLUME_T drainLineVolume; ///< DG drain line volume. - DG_PRE_RO_PURGE_VOLUME_T preROPurgeVolume; ///< DG RO purge volume. - DG_RESERVOIR_VOLUME_RECORD_T reservoirVolumes; ///< DG reservoir volumes. - DG_GENERIC_VOLUME_T genericVolume[ 4 ]; ///< DG generic volume (magic number because the value is unknown). - DG_ACID_CONCENTRATES_T acidConcentrates; ///< DG acid concentrates. - DG_BICARB_CONCENTRATES_T bicarbConcentrates; ///< DG bicarb concentrates. - DG_FILTERS_CAL_RECORD_T filters; ///< DG filters. - DG_FANS_CAL_RECORD_T fans; ///< DG fans. + DG_CONC_PUMPS_CAL_RECORD_T concentratePumpsRecord; ///< DG concentrate pumps. + DG_DRAIN_PUMP_CAL_RECORD_T drainPumpRecord; ///< DG drain pump. + DG_RO_PUMP_CAL_RECORD_T roPumpRecord; ///< DG RO pump. + DG_DRAIN_LINE_VOLUME_T drainLineVolumeRecord; ///< DG drain line volume. + DG_PRE_RO_PURGE_VOLUME_T preROPurgeVolumeRecord; ///< DG RO purge volume. + DG_RESERVOIR_VOLUME_RECORD_T reservoirVolumesRecord; ///< DG reservoir volumes. + DG_GENERIC_VOLUME_RECORD_T genericVolumeRecord; ///< DG generic volume (magic number because the value is unknown). + DG_ACID_CONCENTRATES_RECORD_T acidConcentratesRecord; ///< DG acid concentrates. + DG_BICARB_CONCENTRATES_RECORD_T bicarbConcentratesRecord; ///< DG bicarb concentrates. + DG_FILTERS_CAL_RECORD_T filtersRecord; ///< DG filters. + DG_FANS_CAL_RECORD_T fansRecord; ///< DG fans. DG_ACCELEROMETER_SENSOR_CAL_RECORD_T accelerometerCalRecord; ///< DG accelerometer sensor. } DG_CALIBRATION_GROUPS_T; @@ -418,20 +418,10 @@ static NVDATAMGMT_SELF_TEST_STATE_T nvDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_START; ///< NVDataMgmt self-test state variable. static NVDATAMGMT_EXEC_STATE_T nvDataMgmtExecState = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; ///< NVDataMgmt exec state variable. static SELF_TEST_STATUS_T nvDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; ///< NVDataMgmt self-test result. -static BOOL hasCommandTimedout = FALSE; ///< Boolean flag for timeout of the commands. static U32 currentTime = 0; ///< Current time. static volatile BOOL powerOffIsImminent = FALSE; ///< Power off warning has been signaled. Non-volatile memory operations should be completed ASAP and then ceased. -/* - * Order of POST: - * Start (check EEPROM is enabled correctly) - * Read calibration - * Read manufacturing - * Read service - * Read scheduled runs for DG - * Read Usage Info? (Water consumption, Treatment time) - * Check CRCs (Pass/Fail) - */ +static U32 tempTest; //TODO remove // Private functions static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart ( void ); @@ -482,9 +472,20 @@ // Record check helper functions static BOOL areRecordsValid( void ); static BOOL isLinearRecordValid( LINEAR_CAL_PAYLOAD_T* record, BOOL isRecordNeeded ); +#ifdef _DG_ +static BOOL isDGCalibrationRecordValid( void ); static BOOL isDGConcPumpRecordValid( DG_CONC_PUMPS_CAL_DATA_T* record, BOOL isRecordNeeded ); -static BOOL isSystemRecordValid( void ); -static BOOL isServiceRecordValid( void ); +static BOOL isDGDrainPumpRecordValid( DG_DRAIN_PUMP_CAL_RECORD_T* record, BOOL isRecordNeeded ); +static BOOL isDGROPumpRecordValid( DG_RO_PUMP_CAL_RECORD_T* record, BOOL isRecordNeeded ); +static BOOL isDGDrainLineVolRecordValid( DG_DRAIN_LINE_VOLUME_T* record, BOOL isRecordNeeded ); +static BOOL isDGReservoirVolRecordValid( DG_RESERVOIR_VOLUME_DATA_T* record, BOOL isRecordNeeded ); +static BOOL isDGGenericVolRecordValid( DG_GENERIC_VOLUME_DATA_T* record, BOOL isRecordNeeded ); +static BOOL isDGAcidConcentrateRecordValid( DG_ACID_CONCENTRATE_T* record, BOOL isRecordNeeded ); +static BOOL isDGBicarbConcentrateRecordValid( DG_BICARB_CONCENTRATE_T* record, BOOL isRecordNeeded ); +static BOOL isDGFilterRecordValid( DG_FILTER_CAL_RECORD_T* record, BOOL isRecordNeeded ); +static BOOL isDGFanRecordValid( DG_FAN_CAL_RECORD_T* record, BOOL isRecordNeeded ); +static BOOL isDGAccelerometerSensorRecordValid( DG_ACCELEROMETER_SENSOR_CAL_RECORD_T* record, BOOL isRecordNeeded ); +#endif /*********************************************************************//** * @brief @@ -548,8 +549,7 @@ * @return none *************************************************************************/ void execNVDataMgmt( void ) -{ // TODO - not sure where it should go Dara, but need to look at powerOffIsImminent flag and block - // queuing of any new jobs, maybe even block starting of any new jobs if flag is set +{ switch ( nvDataMgmtExecState ) { case NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST: @@ -1204,7 +1204,7 @@ *************************************************************************/ DG_RO_PUMP_CAL_RECORD_T getDGROPumpRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.roPump; + return dgCalibrationRecord.dgCalibrationGroups.roPumpRecord; } /*********************************************************************//** @@ -1217,7 +1217,7 @@ *************************************************************************/ DG_CONC_PUMPS_CAL_RECORD_T getDGConcetnratePumpsRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.concentratePumps; + return dgCalibrationRecord.dgCalibrationGroups.concentratePumpsRecord; } /*********************************************************************//** @@ -1230,7 +1230,7 @@ *************************************************************************/ DG_DRAIN_PUMP_CAL_RECORD_T getDGDrainPumpRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.drainPump; + return dgCalibrationRecord.dgCalibrationGroups.drainPumpRecord; } /*********************************************************************//** @@ -1243,7 +1243,7 @@ *************************************************************************/ DG_DRAIN_LINE_VOLUME_T getDGDrainLineVolumeRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.drainLineVolume; + return dgCalibrationRecord.dgCalibrationGroups.drainLineVolumeRecord; } /*********************************************************************//** @@ -1256,7 +1256,7 @@ *************************************************************************/ DG_PRE_RO_PURGE_VOLUME_T getDGPreROPurgeVolumeRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.preROPurgeVolume; + return dgCalibrationRecord.dgCalibrationGroups.preROPurgeVolumeRecord; } /*********************************************************************//** @@ -1269,7 +1269,7 @@ *************************************************************************/ DG_RESERVOIR_VOLUME_RECORD_T getDGReservoirVolumeRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.reservoirVolumes; + return dgCalibrationRecord.dgCalibrationGroups.reservoirVolumesRecord; } /*********************************************************************//** @@ -1280,9 +1280,9 @@ * @details Outputs: none * @return DG acid concentrates record *************************************************************************/ -DG_ACID_CONCENTRATES_T getDGAcidConcentratesRecord( void ) +DG_ACID_CONCENTRATES_RECORD_T getDGAcidConcentratesRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.acidConcentrates; + return dgCalibrationRecord.dgCalibrationGroups.acidConcentratesRecord; } /*********************************************************************//** @@ -1293,9 +1293,9 @@ * @details Outputs: none * @return DG bicarb concentrates record *************************************************************************/ -DG_BICARB_CONCENTRATES_T getDGBicarbConcentratesRecord( void ) +DG_BICARB_CONCENTRATES_RECORD_T getDGBicarbConcentratesRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.bicarbConcentrates; + return dgCalibrationRecord.dgCalibrationGroups.bicarbConcentratesRecord; } /*********************************************************************//** @@ -1307,7 +1307,7 @@ *************************************************************************/ DG_FILTERS_CAL_RECORD_T getDGFiltersRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.filters; + return dgCalibrationRecord.dgCalibrationGroups.filtersRecord; } /*********************************************************************//** @@ -1319,7 +1319,7 @@ *************************************************************************/ DG_FANS_CAL_RECORD_T getDGFansRecord( void ) { - return dgCalibrationRecord.dgCalibrationGroups.fans; + return dgCalibrationRecord.dgCalibrationGroups.fansRecord; } /*********************************************************************//** @@ -1877,148 +1877,31 @@ *************************************************************************/ static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) { - U32 i; - LINEAR_CAL_PAYLOAD_T* record; NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; - BOOL isRecordValid = TRUE; +#ifndef DISABLE_CAL_CHECK // Check the integrity of the records as a whole. Check the upper layer CRC BOOL haveRecordsPassed = areRecordsValid(); #ifdef _DG_ - // 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 ]; - // Check in the validity of the calibration data - isRecordValid = isLinearRecordValid( record, TRUE ); - } - - DG_FLOW_SENSORS_CAL_RECORD_T* flow = &dgCalibrationRecord.dgCalibrationGroups.flowSensorsCalRecord; - record = (LINEAR_CAL_PAYLOAD_T*)&flow->flowSensors[ CAL_DATA_RO_PUMP_FLOW_SENSOR ]; - isRecordValid = isLinearRecordValid( record, FALSE ); - - 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 = isLinearRecordValid( record, TRUE ); - } - - 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 = isLinearRecordValid( record, FALSE ); - } - - 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 = isLinearRecordValid( record, FALSE ); - } - - DG_CONC_PUMPS_CAL_RECORD_T* concPump = &dgCalibrationRecord.dgCalibrationGroups.concentratePumps; - for ( i = 0; i < NUM_OF_CAL_DATA_DG_CONC_PUMPS; i++ ) - { - isRecordValid = isDGConcPumpRecordValid( &concPump->concentratePumps[ i ], FALSE ); - } - - DG_DRAIN_PUMP_CAL_RECORD_T* drainPump = &dgCalibrationRecord.dgCalibrationGroups.drainPump; - isRecordValid = isDGDrainPumpRecordValid( drainPump, FALSE ); - - DG_RO_PUMP_CAL_RECORD_T* roPump = &dgCalibrationRecord.dgCalibrationGroups.roPump; - isRecordValid = isDGROPumpRecordValid( roPump, FALSE ); - - DG_DRAIN_LINE_VOLUME_T* drainLineVol = &dgCalibrationRecord.dgCalibrationGroups.drainLineVolume; - isRecordValid = isDGDrainLineVolRecordValid( drainLineVol, FALSE ); - - DG_RESERVOIR_VOLUME_RECORD_T* reservoirVol = &dgCalibrationRecord.dgCalibrationGroups.reservoirVolumes; - for ( i = 0; i < NUM_OF_CAL_DATA_RSRVRS; i++ ) - { - isRecordValid = isDGReservoirVolRecordValid( reservoirVol->reservoir[ i ], FALSE ); - } - - DG_GENERIC_VOLUME_T* genericVol = &dgCalibrationRecord.dgCalibrationGroups.genericVolume; - for ( i = 0; i < 4; i++ ) - { - isRecordValid = isDGGenericVolRecordValid( genericVol[ i ], FALSE ); - } - - DG_ACID_CONCENTRATES_T* acidConc = &dgCalibrationRecord.dgCalibrationGroups.acidConcentrates; - for ( i = 0; i < NUM_OF_CAL_DATA_ACID_CONCENTRATES; i++ ) - { - isRecordValid = isDGAcidConcentrateRecordValid( acidConc[ i ], TRUE ); - } - - DG_BICARB_CONCENTRATES_T* bicarbConc = &dgCalibrationRecord.dgCalibrationGroups.bicarbConcentrates; - for ( i = 0; i < NUM_OF_CAL_DATA_BICARB_CONCENTRATES; i++ ) - { - isRecordValid = isDGBicarbConcentrateRecordValid( bicarbConc, TRUE ); - } - - DG_FILTER_CAL_RECORD_T* roFilter = &dgCalibrationRecord.dgCalibrationGroups.filters.roFilter; - isRecordValid = isDGFilterRecordValid( roFilter, FALSE ); - - DG_FILTER_CAL_RECORD_T* ultraFilter = &dgCalibrationRecord.dgCalibrationGroups.filters.ultraFilter; - isRecordValid = isDGFilterRecordValid( ultraFilter, FALSE ); - - DG_FILTER_CAL_RECORD_T* sedimentFilter = &dgCalibrationRecord.dgCalibrationGroups.filters.sedimentFilter; - isRecordValid = isDGFilterRecordValid( sedimentFilter, FALSE ); - - DG_FILTER_CAL_RECORD_T* carbonFilter = &dgCalibrationRecord.dgCalibrationGroups.filters.carbonFilter; - isRecordValid = isDGFilterRecordValid( carbonFilter, FALSE ); - - DG_FILTER_CAL_RECORD_T* carbonPolishFilter = &dgCalibrationRecord.dgCalibrationGroups.filters.carbonPolishFilter; - isRecordValid = isDGFilterRecordValid( carbonPolishFilter, FALSE ); - - DG_FANS_CAL_RECORD_T* fan1 = &dgCalibrationRecord.dgCalibrationGroups.fans.fan1; - isRecordValid = isDGFanRecordValid( fan1, FALSE ); - - DG_FANS_CAL_RECORD_T* fan2 = &dgCalibrationRecord.dgCalibrationGroups.fans.fan2; - isRecordValid = isDGFanRecordValid( fan2, FALSE ); - - DG_ACCELEROMETER_SENSOR_CAL_RECORD_T* accelerometer = &dgCalibrationRecord.dgCalibrationGroups.accelerometerCalRecord; - isRecordValid = isDGAccelerometerSensorRecordValid( accelerometer, FALSE ); + // Check all the calibration groups + BOOL haveCalGroupsPassed = isDGCalibrationRecordValid(); #endif +#else + BOOL haveCalGroupsPassed = TRUE; + BOOL haveRecordsPassed = TRUE; +#endif - - /*DG_DRAIN_LINE_VOLUME_T drainLineVolume; ///< DG drain line volume. - DG_PRE_RO_PURGE_VOLUME_T preROPurgeVolume; ///< DG RO purge volume. - DG_RESERVOIR_VOLUME_RECORD_T reservoirVolumes; ///< DG reservoir volumes. - DG_GENERIC_VOLUME_T genericVolume[ 4 ]; ///< DG generic volume (magic number because the value is unknown). - DG_ACID_CONCENTRATES_T acidConcentrates; ///< DG acid concentrates. - DG_BICARB_CONCENTRATES_T bicarbConcentrates; ///< DG bicarb concentrates. - DG_FILTERS_CAL_RECORD_T filters; ///< DG filters. - DG_FANS_CAL_RECORD_T fans; ///< DG fans. - DG_ACCELEROMETER_SENSOR_CAL_RECORD_T - - static BOOL isDGDrainPumpRecordValid( DG_DRAIN_PUMP_CAL_RECORD_T* record, BOOL isRecordNeeded ); - static BOOL isDGROPumpRecordValid( DG_RO_PUMP_CAL_RECORD_T* record, BOOL isRecordNeeded ) - static BOOL isDGDrainLineVolRecordValid( DG_DRAIN_LINE_VOLUME_T* record, BOOL isRecordNeeded ); - static BOOL isDGReservoirVolRecordValid( DG_RESERVOIR_VOLUME_RECORD_T* record, BOOL isRecordNeeded ); - static BOOL isDGGenericVolRecordValid( DG_GENERIC_VOLUME_T* record, BOOL isRecordNeeded ); - static BOOL isDGAcidConcentrateRecordValid( DG_ACID_CONCENTRATES_T* record, BOOL isRecordNeeded ); - static BOOL isDGBicarbConcentrateRecordValid( DG_BICARB_CONCENTRATES_T* record, BOOL isRecordNeeded ); - static BOOL isDGFilterRecordValid( DG_FILTERS_CAL_RECORD_T* record, BOOL isRecordNeeded ); - static BOOL isDGFanRecordValid( DG_FANS_CAL_RECORD_T* record, BOOL isRecordNeeded ); - static BOOL isDGAccelerometerSensorRecordValid( DG_ACCELEROMETER_SENSOR_CAL_RECORD_T* record, BOOL isRecordNeeded );*/ - - // If any of the records did not pass, they should be filled // with benign values. After that, schedule a write to sector 0 // to re-write the records with the benign values - if ( FALSE == isRecordValid ) + if ( FALSE == haveCalGroupsPassed ) { enqueueSector0Records(); } // Check if the records' entire CRCs as well as the individual CRCs passed - if ( isRecordValid && haveRecordsPassed ) + if ( haveCalGroupsPassed && haveRecordsPassed ) { nvDataMgmtSelfTestResult = SELF_TEST_STATUS_PASSED; } @@ -2030,42 +1913,6 @@ return state; } - - -static BOOL isDGConcPumpRecordValid( DG_CONC_PUMPS_CAL_DATA_T* record, BOOL isRecordNeeded ) -{ - BOOL status = TRUE; - U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_CONC_PUMPS_CAL_DATA_T) - sizeof(U16) ); - U16 recordCRC = record->crc; - - if ( calcCRC != recordCRC ) - { - // CRC did not pass so set all values to default - record->stepSpeed2FlowRatio = RECORD_DEFAULT_RATIO; - record->calibrationTime = RECORD_DEFAULT_TIME; - record->crc = crc16 ( (U08*)record, sizeof(DG_CONC_PUMPS_CAL_DATA_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 handleExecWaitForPostState waits for POST to be completed. @@ -2095,7 +1942,6 @@ *************************************************************************/ static NVDATAMGMT_EXEC_STATE_T handleExecIdleState ( void ) { - // TODO add the logging features back NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_IDLE; NVDATAMGMT_OPERATION_STATE_T ops; @@ -2105,32 +1951,37 @@ U32 maxBufferLength; BOOL areQueuesNotEmpty = FALSE; - // If the record processing queue is not empty, process the queues - if ( !isRecordQueueEmpty() ) + // If poweroff command has been issued, do not process any new jobs + if ( powerOffIsImminent != TRUE ) { - dequeueRecordJob(); + // If the record processing queue is not empty, process the queues + if ( !isRecordQueueEmpty() ) + { + dequeueRecordJob(); - RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; - PROCESS_RECORD_SPECS_T jobSpecs = RECORDS_SPECS [ job ]; - // Set the record address offset to 0 since a job will just be started - recordAddressOffset = 0; - areQueuesNotEmpty = TRUE; - ops = recordCurrentJob.memoryOperation; - location = recordCurrentJob.memoryLocation; - currentTime = getMSTimerCount(); - startAddress = jobSpecs.startAddress + recordAddressOffset; - bufferAddress = jobSpecs.structAddressPtr + recordAddressOffset; - activeQueue = NVDATAMGMT_PROCESS_RECORDS; + RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; + PROCESS_RECORD_SPECS_T jobSpecs = RECORDS_SPECS [ job ]; + // Set the record address offset to 0 since a job will just be started + recordAddressOffset = 0; + areQueuesNotEmpty = TRUE; + ops = recordCurrentJob.memoryOperation; + location = recordCurrentJob.memoryLocation; + currentTime = getMSTimerCount(); + startAddress = jobSpecs.startAddress + recordAddressOffset; + bufferAddress = jobSpecs.structAddressPtr + recordAddressOffset; + activeQueue = NVDATAMGMT_PROCESS_RECORDS; - // Choose the right buffer size - if ( ops == NVDATAMGMT_WRITE ) - { - maxBufferLength = jobSpecs.maxWriteBufferSize; + // Choose the right buffer size + if ( ops == NVDATAMGMT_WRITE ) + { + maxBufferLength = jobSpecs.maxWriteBufferSize; + } + else if ( ops == NVDATAMGMT_READ ) + { + maxBufferLength = jobSpecs.maxReadBufferSize; + } } - else if ( ops == NVDATAMGMT_READ ) - { - maxBufferLength = jobSpecs.maxReadBufferSize; - } + //TODO add the log queue later. } // Check if a queue job is available @@ -2143,6 +1994,7 @@ } else if ( ops == NVDATAMGMT_WRITE && location == NVDATAMGMT_EEPROM ) { + tempTest = getMSTimerCount(); Fapi_issueProgrammingCommand ( (U32*)startAddress, (U08*)bufferAddress, maxBufferLength, 0x00, 0, Fapi_DataOnly ); state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; } @@ -2214,6 +2066,7 @@ // If the data is valid, and if it is at the end of the write, change to idle if ( jobSpecs.sizeofJob == recordAddressOffset ) { + U32 getValue = calcTimeSince( tempTest ); // TODO remove state = NVDATAMGMT_EXEC_STATE_IDLE; } else @@ -2849,7 +2702,6 @@ if ( didTimeout( currentTime, COMMAND_TIME_OUT ) ) { SET_ALARM_WITH_1_U32_DATA( alarm, *state ); - hasCommandTimedout = TRUE; status = TRUE; } @@ -2916,7 +2768,7 @@ /*********************************************************************//** * @brief - * The isLinearRecordValid function check whether the records are still valid + * The isLinearRecordValid 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 @@ -2962,17 +2814,627 @@ return status; } -static BOOL isSystemRecordValid( void ) +#ifdef _DG_ +/*********************************************************************//** + * @brief + * The isDGCalibrationRecordValid function calls other functions to check + * the validity of DG calibration record. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the DG calibration record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGCalibrationRecordValid( void ) { +#ifdef _DG_ + U32 i; + LINEAR_CAL_PAYLOAD_T* record; + BOOL isRecordValid = 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 ]; + // 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 ); + } + 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 ); + + 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 ); + } + + 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 ); + } + + 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 ); + } + + 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 ); + } + + DG_DRAIN_PUMP_CAL_RECORD_T* drainPump = &dgCalibrationRecord.dgCalibrationGroups.drainPumpRecord; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGDrainPumpRecordValid( drainPump, FALSE ); + + DG_RO_PUMP_CAL_RECORD_T* roPump = &dgCalibrationRecord.dgCalibrationGroups.roPumpRecord; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGROPumpRecordValid( roPump, FALSE ); + + DG_DRAIN_LINE_VOLUME_T* drainLineVol = &dgCalibrationRecord.dgCalibrationGroups.drainLineVolumeRecord; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGDrainLineVolRecordValid( drainLineVol, FALSE ); + + 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 ); + } + + DG_GENERIC_VOLUME_RECORD_T* genericVol = &dgCalibrationRecord.dgCalibrationGroups.genericVolumeRecord; + for ( i = 0; i < 4; i++ ) + { + isRecordValid = isRecordValid == FALSE ? FALSE : isDGGenericVolRecordValid( &genericVol->genericVolume[ i ], FALSE ); + } + + 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 ); + } + + 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 ); + } + + DG_FILTER_CAL_RECORD_T* roFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.roFilter; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( roFilter, FALSE ); + + DG_FILTER_CAL_RECORD_T* ultraFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.ultraFilter; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( ultraFilter, FALSE ); + + DG_FILTER_CAL_RECORD_T* sedimentFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.sedimentFilter; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( sedimentFilter, FALSE ); + + DG_FILTER_CAL_RECORD_T* carbonFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.carbonFilter; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( carbonFilter, FALSE ); + + DG_FILTER_CAL_RECORD_T* carbonPolishFilter = &dgCalibrationRecord.dgCalibrationGroups.filtersRecord.carbonPolishFilter; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGFilterRecordValid( carbonPolishFilter, FALSE ); + + DG_FANS_CAL_RECORD_T* fan = &dgCalibrationRecord.dgCalibrationGroups.fansRecord; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGFanRecordValid( &fan->fan1, FALSE ); + isRecordValid == FALSE ? FALSE : isDGFanRecordValid( &fan->fan2, FALSE ); + + DG_ACCELEROMETER_SENSOR_CAL_RECORD_T* accelerometer = &dgCalibrationRecord.dgCalibrationGroups.accelerometerCalRecord; + isRecordValid = isRecordValid == FALSE ? FALSE : isDGAccelerometerSensorRecordValid( accelerometer, FALSE ); + + return isRecordValid; +#endif } -static BOOL isServiceRecordValid( void ) + +/*********************************************************************//** + * @brief + * The isDGConcPumpRecordValid function checks whether the calibration + * record of concentrate pump is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGConcPumpRecordValid( DG_CONC_PUMPS_CAL_DATA_T* record, BOOL isRecordNeeded ) { + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_CONC_PUMPS_CAL_DATA_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->stepSpeed2FlowRatio = RECORD_DEFAULT_RATIO; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_CONC_PUMPS_CAL_DATA_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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 isDGDrainPumpRecordValid function checks whether the calibration + * record of drain pump is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGDrainPumpRecordValid( DG_DRAIN_PUMP_CAL_RECORD_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_DRAIN_PUMP_CAL_RECORD_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->stepSpeed2FlowRatio = RECORD_DEFAULT_RATIO; + record->voltage2SpeedRatio = RECORD_DEFAULT_RATIO; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_DRAIN_PUMP_CAL_RECORD_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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 isDGROPumpRecordValid function checks whether the calibration + * record of RO pump is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGROPumpRecordValid( DG_RO_PUMP_CAL_RECORD_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_RO_PUMP_CAL_RECORD_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->gain1Ratio = RECORD_DEFAULT_RATIO; + record->gain2Ratio = RECORD_DEFAULT_RATIO; + record->gain3Ratio = RECORD_DEFAULT_RATIO; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_RO_PUMP_CAL_RECORD_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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 isDGDrainLineVolRecordValid function checks whether the calibration + * record of drain line volume is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGDrainLineVolRecordValid( DG_DRAIN_LINE_VOLUME_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_DRAIN_LINE_VOLUME_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->volume = RECORD_DEFAULT_CONST; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_DRAIN_LINE_VOLUME_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 isDGReservoirVolRecordValid function checks whether the calibration + * record of reservoir volume is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGReservoirVolRecordValid( DG_RESERVOIR_VOLUME_DATA_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_RESERVOIR_VOLUME_DATA_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->maxResidualFluid = RECORD_DEFAULT_CONST; + record->normalFillVolume = RECORD_DEFAULT_CONST; + record->rsrvrUnfilledWeight = RECORD_DEFAULT_CONST; + record->rsrvrVolume = RECORD_DEFAULT_CONST; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_RESERVOIR_VOLUME_DATA_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 isDGGenericVolRecordValid function checks whether the calibration + * record of generic volume is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGGenericVolRecordValid( DG_GENERIC_VOLUME_DATA_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_GENERIC_VOLUME_DATA_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->volume = RECORD_DEFAULT_CONST; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_GENERIC_VOLUME_DATA_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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 isDGAcidConcentrateRecordValid function checks whether the calibration + * record of acid concentrate is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGAcidConcentrateRecordValid( DG_ACID_CONCENTRATE_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_ACID_CONCENTRATE_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->startVolume = RECORD_DEFAULT_CONST; + record->reserverdSpace = RECORD_DEFAULT_CONST; + record->acidConcMixRatio = RECORD_DEFAULT_RATIO; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_ACID_CONCENTRATE_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 isDGBicarbConcentrateRecordValid function checks whether the + * calibration record of bicarb concentrate is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGBicarbConcentrateRecordValid( DG_BICARB_CONCENTRATE_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_BICARB_CONCENTRATE_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->startVolume = RECORD_DEFAULT_CONST; + record->reservedSpace = RECORD_DEFAULT_CONST; + record->bicarbConcMixRatio = RECORD_DEFAULT_RATIO; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_BICARB_CONCENTRATE_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 isDGFilterRecordValid function checks whether the calibration + * record of filter is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGFilterRecordValid( DG_FILTER_CAL_RECORD_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_FILTER_CAL_RECORD_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->reservedSpace1 = RECORD_DEFAULT_CONST; + record->reservedSpace2 = RECORD_DEFAULT_CONST; + record->reservedSpace3 = RECORD_DEFAULT_CONST; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_FILTER_CAL_RECORD_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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 isDGFanRecordValid function checks whether the calibration record + * of fan is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGFanRecordValid( DG_FAN_CAL_RECORD_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_FAN_CAL_RECORD_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->reservedSpace1 = RECORD_DEFAULT_CONST; + record->reservedSpace2 = RECORD_DEFAULT_CONST; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_FAN_CAL_RECORD_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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 isDGAccelerometerSensorRecordValid function checks whether the + * calibration record of accelerometer sensor is valid or not. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGAccelerometerSensorRecordValid( DG_ACCELEROMETER_SENSOR_CAL_RECORD_T* record, BOOL isRecordNeeded ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_ACCELEROMETER_SENSOR_CAL_RECORD_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->accelXOffset = RECORD_DEFAULT_OFFSET; + record->accelYOffset = RECORD_DEFAULT_OFFSET; + record->accelZOffset = RECORD_DEFAULT_OFFSET; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof(DG_ACCELEROMETER_SENSOR_CAL_RECORD_T) - sizeof(U16) ); + + // Alarm if the CRC did not pass and the record is needed + if ( TRUE == isRecordNeeded ) + { + 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; +} +#endif + +/*********************************************************************//** + * @brief * The dequeue increments the front index counter and if it is equal to * rear index, it sets it to -1, meaning that the queue is empty. * @details Inputs: queueFrontIndex, queueCount