Index: NVDataMgmt.c =================================================================== diff -u -r3a57b1955aa7516898e4c2c855978bbf01c8ec62 -r59871c9964559b5137781af9c2eeed6bab18ef73 --- NVDataMgmt.c (.../NVDataMgmt.c) (revision 3a57b1955aa7516898e4c2c855978bbf01c8ec62) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision 59871c9964559b5137781af9c2eeed6bab18ef73) @@ -1,14 +1,14 @@ /************************************************************************** * -* Copyright (c) 2020-2022 Diality Inc. - All Rights Reserved. +* Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file NVDataMgmt.c * * @author (last) Dara Navaei -* @date (last) 14-Jul-2022 +* @date (last) 20-Oct-2023 * * @author (original) Dara Navaei * @date (original) 12-Feb-2020 @@ -76,14 +76,15 @@ #define MAX_NUM_OF_EVENTS_IN_SECTOR1 ((MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 2) * MAX_LOG_DATA_PER_SECTOR) ///< Max number of accumulated logs in sector 1 (512). // Data addresses and length in RTC RAM -#define LOG_RECORD_START_ADDRESS 0x00000000 // 0 ///< Log record start address in RTC RAM (0). -#define HD_USAGE_INFO_START_ADDRESS 0x00000010 // 16 ///< HD usage info start address in RTC RAM (16). -#define DG_USAGE_INFO_START_ADDRESS 0x00000030 // 48 ///< DG usage info start address in RTC RAM (48). +#define LOG_RECORD_START_ADDRESS 0x00000000 /* 0 */ ///< Log record start address in RTC RAM (0). +#define HD_USAGE_INFO_START_ADDRESS 0x00000010 /* 16 */ ///< HD usage info start address in RTC RAM (16). +#define DG_USAGE_INFO_START_ADDRESS 0x00000030 /* 48 */ ///< DG usage info start address in RTC RAM (48). #define DG_SCHEDULED_RUNS_START_ADDRESS (DG_USAGE_INFO_START_ADDRESS + sizeof(DG_SERVICE_GROUP_T)) ///< DG scheduled runs start address in RTC RAM. #define DG_HEATERS_INFO_START_ADDRESS (DG_SCHEDULED_RUNS_START_ADDRESS + sizeof(DG_HEATERS_INFO_GROUP_T))///< DG heaters info start address in RTC RAM. -#define SW_CONFIGS_START_ADDRESS 0x00000100 // 256 ///< Software configurations start address in RTC RAM. +#define SW_CONFIGS_START_ADDRESS 0x00000100 /* 256 */ ///< Software configurations start address in RTC RAM. #define COMMAND_TIME_OUT (1 * MS_PER_SECOND) ///< Timeout for an EEPROM or RTC command in ms. + /// EEPROM functions use the buffer length as the size of U32. So before send the length to any of FAPI functions, it should be divided by 4. #define EEPROM_OPS_SIZE_OF_CONVERTER 4 @@ -105,7 +106,7 @@ // to round up. The result is then multiplied by 16 bytes to get the number of bytes needed and is subtracted from the size of the structure and CRC. #define RECORD_PADDING_LENGTH(rcrd, buf) (RECORD_BYTE_SIZE(rcrd) % buf == 0 ? 0 : \ ((((RECORD_BYTE_SIZE(rcrd) / buf) + 1)) * buf) \ - - RECORD_BYTE_SIZE(rcrd)) /// DG padding length macro. + - RECORD_BYTE_SIZE(rcrd)) ///< DG padding length macro. #define RECORD_DEFAULT_TIME 0U ///< Record default time (calibration/set). #define RECORD_FOURTH_ORDER_COEFF 0.0F ///< Record fourth order coefficient. @@ -138,9 +139,23 @@ #define DEFAULT_ACID_BOTTLE_VOL_ML 3430.0F ///< Record default acid bottle volume in milliliters. #define DEFAULT_ACID_COND_US_PER_CM 11645.05F ///< Record default acid conductivity in uS/cm. #define DEFAULT_ACID_BOTTLE_TEMP_C 23.5F ///< Record default acid bottle temperature in C. -#define DEFAULT_RSRVR_TEMP_TAU_C_PER_MIN -0.512F ///< Reservoir temperature time constant C/min. -#define DEFAULT_UF_TEMP_TAU_C_PER_MIN -4.565F ///< Ultrafilter temperature time constant C/min. +#define DEFAULT_RSRVR_TEMP_TAU_C_PER_MIN -0.25F ///< Reservoir temperature time constant C/min. +#define DEFAULT_UF_TEMP_TAU_C_PER_MIN -1.0F ///< Ultrafilter temperature time constant C/min. #define DEFAULT_UF_VOLUME_ML 700 ///< Ultrafilter volume in milliliters. + +#define DEFAULT_FILL_1251_1_ACID_SNSR_US_PER_CM 11518.05F ///< Fill acid 1251_1 acid sensor conductivity uS/cm. +#define DEFAULT_FILL_1251_1_BIC_SNSR_US_PER_CM 13616.23F ///< Fill acid 1251_1 bicarb sensor conductivity uS/cm. +#define DEFAULT_FILL_2251_0_ACID_SNSR_US_PER_CM 11645.05F ///< Fill acid 2251_0 acid sensor conductivity uS/cm. +#define DEFAULT_FILL_2251_0_BIC_SNSR_US_PER_CM 13734.88F ///< Fill acid 2251_0 bicarb sensor conductivity uS/cm. +#define DEFAULT_FILL_3251_9_ACID_SNSR_US_PER_CM 11773.1F ///< Fill acid 3251_9 acid sensor conductivity uS/cm. +#define DEFAULT_FILL_3251_9_BIC_SNSR_US_PER_CM 13854.49F ///< Fill acid 3251_9 bicarb sensor conductivity uS/cm. + +#define DEFAULT_ACID_TEST_1251_1_US_PER_CM 12118.71F ///< Acid test acid 1251_1 acid conductivity uS/cm. +#define DEFAULT_ACID_TEST_2251_0_US_PER_CM 12252.1F ///< Acid test acid 2251_0 acid conductivity uS/cm. +#define DEFAULT_ACID_TEST_3251_9_US_PER_CM 12386.57F ///< Acid acid 3251_9 acid conductivity uS/cm. + +#define DEFAULT_BIC_TEST_ACID_SNSR_US_PER_CM 0.0F ///< Bicarb test acid sensor conductivity uS/cm. +#define DEFAULT_BIC_TEST_BIC_SNSR_US_PER_CM 3890.0F ///< Bicarb test bicarb sensor conductivity uS/cm. #endif /// NVDataMgmt self-test states enumeration. @@ -431,18 +446,22 @@ static DG_SW_CONFIG_GROUP_T dgSWConfigGroup; ///< DG Software configurations structure(including padding and final CRC). #endif +// TODO this is temporary until it is added to the cal records +static DG_CHEMICALS_FILL_COND_CAL_RECORD_T tempChemsRecordRemove; +// TODO this is temporary until it is added to the cal records + // Process records specifications const PROCESS_RECORD_SPECS_T RECORDS_SPECS[ NUM_OF_NVDATMGMT_RECORDS_JOBS ] = { // Start address Size of the job Max write bytes per job Max read bytes per job Record structure pointer Record CRC pointer Memory location Event calibration record update {CAL_RECORD_NV_MEM_START_ADDRESS, sizeof(DG_CALIBRATION_RECORD_T), MAX_EEPROM_WRITE_BUFFER_BYTES, sizeof(DG_CALIBRATION_RECORD_T), (U08*)&dgCalibrationRecord, (U08*)&dgCalibrationRecord.crc, NVDATAMGMT_EEPROM, DG_EVENT_CAL_RECORD_UPDATE }, // NVDATAMGMT_CALIBRATION_RECORD {SYSTEM_RECORD_NV_MEM_START_ADDRESS, sizeof(DG_SYSTEM_GROUP_T), MAX_EEPROM_WRITE_BUFFER_BYTES, sizeof(DG_SYSTEM_GROUP_T), (U08*)&dgSystemGroup, (U08*)&dgSystemGroup.crc, NVDATAMGMT_EEPROM, DG_EVENT_SYSTEM_RECORD_UPDATE }, // NVDATAMGMT_SYSTEM_RECORD {SERVICE_RECORD_NV_MEM_START_ADDRESS, sizeof(DG_SERVICE_GROUP_T), MAX_EEPROM_WRITE_BUFFER_BYTES, sizeof(DG_SERVICE_GROUP_T), (U08*)&dgServiceGroup, (U08*)&dgServiceGroup.crc, NVDATAMGMT_EEPROM, DG_EVENT_SERVICE_UPDATE }, // NVDATAMGMT_SERVICE_RECORD + {DG_SCHEDULED_RUNS_START_ADDRESS, sizeof(DG_SCHEDULED_RUNS_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgScheduledRunsGroup, (U08*)&dgScheduledRunsGroup.crc, NVDATAMGMT_RTC, DG_EVENT_SCHEDULED_RUNS_UPDATE }, // NVDATAMGMT_SCHEDULER_RECORD + {DG_HEATERS_INFO_START_ADDRESS, sizeof(DG_HEATERS_INFO_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgHeatersInfoGroup, (U08*)&dgHeatersInfoGroup.crc, NVDATAMGMT_RTC, DG_EVENT_HEATERS_INFO_UPDATE }, // NVDATAMGMT_HEATERS_INFO_RECORD + {DG_USAGE_INFO_START_ADDRESS, sizeof(DG_USAGE_INFO_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgUsageInfoGroup, (U08*)&dgUsageInfoGroup.crc, NVDATAMGMT_RTC, DG_EVENT_USAGE_INFO_UPDATE }, // NVDATAMGMT_USAGE_INFO_RECORD #ifndef _RELEASE_ - {SW_CONFIGS_START_ADDRESS, sizeof(DG_SW_CONFIG_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgSWConfigGroup, (U08*)&dgSWConfigGroup.crc, NVDATAMGMT_RTC, DG_EVENT_SW_CONFIG_UPDATE }, // NVDATAMGMT_SW_CONFIG_RECORD + {SW_CONFIGS_START_ADDRESS, sizeof(DG_SW_CONFIG_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgSWConfigGroup, (U08*)&dgSWConfigGroup.crc, NVDATAMGMT_RTC, DG_EVENT_SW_CONFIG_UPDATE } // NVDATAMGMT_SW_CONFIG_RECORD #endif - {DG_SCHEDULED_RUNS_START_ADDRESS, sizeof(DG_SCHEDULED_RUNS_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgScheduledRunsGroup, (U08*)&dgScheduledRunsGroup.crc, NVDATAMGMT_RTC, DG_EVENT_NO_EVENT }, // NVDATAMGMT_SCHEDULER_RECORD - {DG_HEATERS_INFO_START_ADDRESS, sizeof(DG_HEATERS_INFO_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgHeatersInfoGroup, (U08*)&dgHeatersInfoGroup.crc, NVDATAMGMT_RTC, DG_EVENT_NO_EVENT }, // NVDATAMGMT_HEATERS_INFO_RECORD - {DG_USAGE_INFO_START_ADDRESS, sizeof(DG_USAGE_INFO_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&dgUsageInfoGroup, (U08*)&dgUsageInfoGroup.crc, NVDATAMGMT_RTC, DG_EVENT_USAGE_INFO_UPDATE } // NVDATAMGMT_USAGE_INFO_RECORD }; #endif @@ -460,10 +479,10 @@ {CAL_RECORD_NV_MEM_START_ADDRESS, sizeof(HD_CALIBRATION_RECORD_T), MAX_EEPROM_WRITE_BUFFER_BYTES, sizeof(HD_CALIBRATION_RECORD_T), (U08*)&hdCalibrationRecord, (U08*)&hdCalibrationRecord.crc, NVDATAMGMT_EEPROM, HD_EVENT_CAL_RECORD_UPDATE }, // NVDATAMGMT_CALIBRATION_RECORD {SYSTEM_RECORD_NV_MEM_START_ADDRESS, sizeof(HD_SYSTEM_GROUP_T), MAX_EEPROM_WRITE_BUFFER_BYTES, sizeof(HD_SYSTEM_GROUP_T), (U08*)&hdSystemGroup, (U08*)&hdSystemGroup.crc, NVDATAMGMT_EEPROM, HD_EVENT_SYSTEM_RECORD_UPDATE }, // NVDATAMGMT_SYSTEM_RECORD {SERVICE_RECORD_NV_MEM_START_ADDRESS, sizeof(HD_SERVICE_GROUP_T), MAX_EEPROM_WRITE_BUFFER_BYTES, sizeof(HD_SERVICE_GROUP_T), (U08*)&hdServiceGroup, (U08*)&hdServiceGroup.crc, NVDATAMGMT_EEPROM, HD_EVENT_SERVICE_UPDATE }, // NVDATAMGMT_PROCESS_LAST_SERVICE_RECORD + {HD_USAGE_INFO_START_ADDRESS, sizeof(HD_USAGE_INFO_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&hdUsageInfoGroup, (U08*)&hdUsageInfoGroup.crc, NVDATAMGMT_RTC, HD_EVENT_USAGE_INFO_UPDATE }, // NVDATAMGMT_USAGE_INFO #ifndef _RELEASE_ - {SW_CONFIGS_START_ADDRESS, sizeof(HD_SW_CONFIG_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&hdSWConfigGroup, (U08*)&hdSWConfigGroup.crc, NVDATAMGMT_RTC, HD_EVENT_SW_CONFIG_UPDATE }, // NVDATAMGMT_SW_CONFIG_RECORD + {SW_CONFIGS_START_ADDRESS, sizeof(HD_SW_CONFIG_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&hdSWConfigGroup, (U08*)&hdSWConfigGroup.crc, NVDATAMGMT_RTC, HD_EVENT_SW_CONFIG_UPDATE } // NVDATAMGMT_SW_CONFIG_RECORD #endif - {HD_USAGE_INFO_START_ADDRESS, sizeof(HD_USAGE_INFO_GROUP_T), MAX_RTC_RAM_OPS_BUFFER_BYTES, MAX_RTC_RAM_OPS_BUFFER_BYTES, (U08*)&hdUsageInfoGroup, (U08*)&hdUsageInfoGroup.crc, NVDATAMGMT_RTC, HD_EVENT_USAGE_INFO_UPDATE }, // NVDATAMGMT_USAGE_INFO }; #endif @@ -491,7 +510,9 @@ static MEMORY_LOG_OPS_T currentJob; ///< Current job. static LOG_RECORD_T logRecord; ///< Log record variable. static U08 queueRearIndex; ///< Queue rear index. +#ifdef ENABLE_LOCAL_LOGGING static U08 queueFrontIndex; ///< Queue front index. +#endif static U08 queueCount; ///< Queue count. static NVDATAMGMT_SELF_TEST_STATE_T nvDataMgmtSelfTestState; ///< NVDataMgmt self-test state variable. static NVDATAMGMT_EXEC_STATE_T nvDataMgmtExecState; ///< NVDataMgmt exec state variable. @@ -526,15 +547,17 @@ U32 startAddress, U08* data, READ_DATA_T* extAddress, U32 length ); static void enqueue( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, U32 startAddress, U08* data, READ_DATA_T* extAddress, U32 length ); +#ifdef ENABLE_LOCAL_LOGGING static void dequeue( void ); +static BOOL isQueueEmpty( void ); +#endif static U32 prepareWriteLogJobAndGetStartAddress( U08* data ); static U32 prepareReadLogJobAndGetStartAddress( void ); -static BOOL isQueueEmpty( void ); static BOOL isQueueFull( void ); static U32 getAvailableQueueCount( void ); // Helper functions -static BOOL didCommandTimeout( ALARM_ID_T alarm, U08* state ); +static BOOL didCommandTimeout( NVDATAMGMT_EXEC_STATE_T state ); static BOOL eraseDataLogSectors( void ); static void monitorNewCalSignal( void ); @@ -572,6 +595,7 @@ static BOOL isDGFanRecordValid( DG_FAN_CAL_RECORD_T* record ); static BOOL isDGAccelerometerSensorRecordValid( DG_ACCEL_SENSOR_CAL_RECORD_T* record ); static BOOL isDGHeatingCalRecordValid( DG_HEATING_CAL_RECORD_T* record ); +static BOOL isDGFillConductiviesRecordValid( DG_ACID_BICARB_FILL_COND_VALUES_T* record, DG_FILL_COND_OPS_T test, DG_ACID_TYPES_T acidType ); #endif #ifdef _HD_ @@ -608,7 +632,9 @@ nvDataMgmtExecProcessRecordState = NVDATAMGMT_PROCESS_RECORD_STATE_IDLE; nvDataMgmtExecReceiveRecordState = NVDATAMGMT_RECEIVE_RECORD_IDLE; queueRearIndex = QUEUE_START_INDEX; +#ifdef ENABLE_LOCAL_LOGGING queueFrontIndex = QUEUE_START_INDEX; +#endif queueCount = 0; recordUpdateAddress = 0; recordQueueRearIndex = QUEUE_START_INDEX; @@ -951,6 +977,20 @@ /*********************************************************************//** * @brief + * The resetNVDataMgmtPOSTState function resets the NV data management POST + * state and enqueues all the NV records to be read again from the NV memory. + * @details Inputs: none + * @details Outputs: nvDataMgmtSelfTestState, nvDataMgmtSelfTestResult + * @return none + *************************************************************************/ +void resetNVDataMgmtPOSTState( void ) +{ + nvDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; + nvDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_READ_RECORDS; +} + +/*********************************************************************//** + * @brief * The getNVRecord2Driver function copies the requested non-volatile * data into the provided buffer by the caller. The function then checks if * the non-volatile data is valid. If the data is not valid, it raises the @@ -1039,8 +1079,13 @@ nvDataLength = sizeof( hdServiceGroup.hdServiceRecord ); break; + case GET_USAGE_RECORD: + nvDataStartPtr = (U08*)&hdUsageInfoGroup.hdUsageInfo; + nvDataLength = sizeof( hdUsageInfoGroup.hdUsageInfo ); + break; + default: - // TODO software fault + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_NV_RECORD_SELECTED, nvData ) break; #endif @@ -1160,6 +1205,22 @@ isNVDataInvalid |= ( 0 == dgCalibrationRecord.dgCalibrationGroups.filtersRecord.ultraFilter.calibrationTime ? TRUE : FALSE ); break; + case GET_CAL_FILL_CONDUCTIVITIES_RECORD: + nvDataStartPtr = (U08*)&tempChemsRecordRemove.fillCondValues; + nvDataLength = sizeof( tempChemsRecordRemove.fillCondValues ); + /* TODO un-comment when it is added to calibration record + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_1251_1 ][ FILL_COND_NORMAL_OP ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_1251_1 ][ FILL_COND_ACID_TEST ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_1251_1 ][ FILL_COND_BICARB_TEST ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_2251_0 ][ FILL_COND_NORMAL_OP ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_2251_0 ][ FILL_COND_ACID_TEST ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_2251_0 ][ FILL_COND_BICARB_TEST ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_3251_9 ][ FILL_COND_NORMAL_OP ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_3251_9 ][ FILL_COND_ACID_TEST ].calibrationTime ? TRUE : FALSE ); + isNVDataInvalid |= ( 0 == tempChemsRecordRemove.fillCondValues[ ACID_08_3251_9 ][ FILL_COND_BICARB_TEST ].calibrationTime ? TRUE : FALSE ); + */ + break; + case GET_INF_HEATERS_RECORD: nvDataStartPtr = (U08*)&dgHeatersInfoGroup.dgHeatersInfo; nvDataLength = sizeof( dgHeatersInfoGroup.dgHeatersInfo ); @@ -1294,11 +1355,14 @@ dgUsageInfoGroup.crc = crc16( (U08*)&dgUsageInfoGroup, sizeof( DG_USAGE_INFO_GROUP_T ) - sizeof( U16 ) ); #endif + // Service record has been touched so the entire sector 0 of the EEPROM must be rewritten enqueueSector0Records(); enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].dataLoc, NVDATAMGMT_USAGE_INFO_RECORD ); // Both the usage and service records have been updated SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ) SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_SERVICE_RECORD ].nvEvent, 0, 0 ) + + status = TRUE; } return status; @@ -1372,7 +1436,7 @@ usageWriteTries = 0; status = TRUE; - enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, HD_USAGE_INFO_START_ADDRESS, (U08*)&hdUsageInfoGroup, 0, sizeof( HD_USAGE_INFO_GROUP_T ) ); + enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].dataLoc, NVDATAMGMT_USAGE_INFO_RECORD ); SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ) } else if ( ++usageWriteTries > MAX_NUM_OF_WRITE_TRIES ) @@ -1402,7 +1466,7 @@ usageWriteTries = 0; status = TRUE; - enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, HD_USAGE_INFO_START_ADDRESS, (U08*)&hdUsageInfoGroup, 0, sizeof( HD_USAGE_INFO_GROUP_T ) ); + enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].dataLoc, NVDATAMGMT_USAGE_INFO_RECORD ); SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ) } else if ( ++usageWriteTries > MAX_NUM_OF_WRITE_TRIES ) @@ -1436,12 +1500,12 @@ usageWriteTries = 0; status = TRUE; - enqueueRecordJob( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, NVDATAMGMT_USAGE_INFO_RECORD ); + enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].dataLoc, NVDATAMGMT_USAGE_INFO_RECORD ); SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ) } else if ( ++usageWriteTries > MAX_NUM_OF_WRITE_TRIES ) { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_WRITE_GEN_RO_WATER_TO_NV_FAILURE, USAGE_INFO_RO_GEN_WATER ); + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_WRITE_USAGE_INFO_TO_NV_FAILURE, USAGE_INFO_RO_GEN_WATER ); } return status; @@ -1465,65 +1529,57 @@ { switch ( disinfect ) { - case USAGE_INFO_HEAT_DISINFECT: - dgUsageInfoGroup.dgUsageInfo.lastHeatDisDateEpoch = epochTime; + case USAGE_INFO_BASIC_FLUSH: + dgUsageInfoGroup.dgUsageInfo.lastBasicFlushCompleteDateEpoch = epochTime; break; - case USAGE_INFO_CHEMICAL_DISINFECT: - dgUsageInfoGroup.dgUsageInfo.lastChemicalDisDateEpoch = epochTime; + case USAGE_INFO_CHEM_DIS_START: + dgUsageInfoGroup.dgUsageInfo.lastChemDisStartDateEpoch = epochTime; break; + + case USAGE_INFO_CHEM_DIS: + dgUsageInfoGroup.dgUsageInfo.lastChemDisCompleteDateEpoch = epochTime; + break; + + case USAGE_INFO_CHEM_FLUSH: + dgUsageInfoGroup.dgUsageInfo.lastChemDisFlushCompleteDateEpoch = epochTime; + break; + + case USAGE_INFO_HEAT_DIS: + dgUsageInfoGroup.dgUsageInfo.lastHeatDisCompleteDateEpoch = epochTime; + break; + + case USAGE_INFO_FILTER_FLUSH: + dgUsageInfoGroup.dgUsageInfo.lastFilterFlushCompleteDateEpoch = epochTime; + break; + + case USAGE_INFO_HEAT_DIS_ACTIVE_COOL: + dgUsageInfoGroup.dgUsageInfo.lastHeatActiveCoolCompleteDateEpoch = epochTime; + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_USAGE_INFO_SELECTED, disinfect ); + break; } dgUsageInfoGroup.dgUsageInfo.crc = crc16( (U08*)&dgUsageInfoGroup.dgUsageInfo, sizeof( DG_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); dgUsageInfoGroup.crc = crc16( (U08*)&dgUsageInfoGroup, sizeof( DG_USAGE_INFO_GROUP_T ) - sizeof( U16 ) ); usageWriteTries = 0; status = TRUE; - enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, DG_USAGE_INFO_START_ADDRESS, (U08*)&dgUsageInfoGroup, 0, sizeof( DG_USAGE_INFO_GROUP_T ) ); + enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].dataLoc, NVDATAMGMT_USAGE_INFO_RECORD ); SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ) } else if ( ++usageWriteTries > MAX_NUM_OF_WRITE_TRIES ) { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_WRITE_DISINFECT_DATE_TO_NV_FAILURE, disinfect ); + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_WRITE_USAGE_INFO_TO_NV_FAILURE, disinfect ); } return status; } /*********************************************************************//** * @brief - * The setDisinfectStatus sets a queue job to write whether the device is already - * disinfected or not. - * @details Inputs: dgUsageInfoGroup - * @details Outputs: dgUsageInfoGroup - * @param disinfectStatus disinfect status - * @return TRUE if queue is not full - *************************************************************************/ -BOOL setDisinfectStatus( BOOL disinfectStatus ) -{ - BOOL status = FALSE; - - if ( FALSE == isQueueFull() ) - { - dgUsageInfoGroup.dgUsageInfo.isDisinfected = disinfectStatus; - dgUsageInfoGroup.dgUsageInfo.crc = crc16( (U08*)&dgUsageInfoGroup.dgUsageInfo, sizeof( DG_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); - dgUsageInfoGroup.crc = crc16( (U08*)&dgUsageInfoGroup, sizeof( DG_USAGE_INFO_GROUP_T ) - sizeof( U16 ) ); - usageWriteTries = 0; - status = TRUE; - - enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, DG_USAGE_INFO_START_ADDRESS, (U08*)&dgUsageInfoGroup, 0, sizeof( DG_USAGE_INFO_GROUP_T ) ); - SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ) - } - else if ( ++usageWriteTries > MAX_NUM_OF_WRITE_TRIES ) - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_WRITE_DISINFECT_STATUS_TO_NV_FAILURE, USAGE_INFO_DISIFNECT_STATUS ); - } - - return status; -} - -/*********************************************************************//** - * @brief * The setHeatersInfoRecord sets a queue job to write the DG heaters info * back to the RTC RAM. * @details Inputs: none @@ -1597,6 +1653,70 @@ /*********************************************************************//** * @brief + * The testSetNVRecordCRCOverride overrides the non-volatile record CRC override. + * @details Inputs: none + * @details Outputs: none + * @param job the job to override its CRC (i.e. calibration record) + * @param crc the value its CRC to be overridden + * @return TRUE if the job was scheduled successfully otherwise, FALSE + *************************************************************************/ +BOOL testSetNVRecordCRCOverride( U32 job, U16 crc ) +{ + BOOL status = FALSE; + RECORD_JOBS_STATE_T nvJob = (RECORD_JOBS_STATE_T)job; + + switch( nvJob ) + { + case NVDATAMGMT_CALIBRATION_RECORD: +#ifdef _DG_ + dgCalibrationRecord.crc = crc; +#endif +#ifdef _HD_ + hdCalibrationRecord.crc = crc; +#endif + status = enqueueSector0Records(); + break; + + case NVDATAMGMT_SYSTEM_RECORD: +#ifdef _DG_ + dgSystemGroup.dgSystemRecord.crc = crc; +#endif +#ifdef _HD_ + hdSystemGroup.hdsystemRecord.crc = crc; +#endif + status = enqueueSector0Records(); + break; + + case NVDATAMGMT_SERVICE_RECORD: +#ifdef _DG_ + dgServiceGroup.dgServiceRecord.crc = crc; +#endif +#ifdef _HD_ + hdServiceGroup.hdServiceRecord.crc = crc; +#endif + status = enqueueSector0Records(); + break; + + case NVDATAMGMT_USAGE_INFO_RECORD: +#ifdef _DG_ + dgUsageInfoGroup.dgUsageInfo.crc = crc; +#endif +#ifdef _HD_ + hdUsageInfoGroup.hdUsageInfo.crc = crc; +#endif + if ( getAvailableRecordQueueCount() > 0 ) + { + enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].dataLoc, NVDATAMGMT_USAGE_INFO_RECORD ); + status = TRUE; + } + break; + } + + return status; +} + +/*********************************************************************//** + * @brief * The handleSelfTestReadRecords waits for the records to be read * @details Inputs: none * @details Outputs: none @@ -1606,7 +1726,9 @@ { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_RECORDS; - if ( TRUE == isRecordQueueEmpty() ) + // Check if the queues are empty and the exec state machine is in Idle meaning all the records have been read and the state machine + // is back at Idle so even the last job in the queue has been processed + if ( ( TRUE == isRecordQueueEmpty() ) && ( NVDATAMGMT_EXEC_STATE_IDLE == nvDataMgmtExecState ) ) { recordsReadStatus = NVDATAMGMT_RECORDS_READ; state = NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC; @@ -1665,12 +1787,13 @@ SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_SERVICE_RECORD ].nvEvent, 0, 0 ) } +#ifndef _RELEASE_ if ( FALSE == hasSWConfigRecordPassed ) { enqueueRecordJob( NVDATAMGMT_WRITE, RECORDS_SPECS[ NVDATAMGMT_SW_CONFIG_RECORD ].dataLoc, NVDATAMGMT_SW_CONFIG_RECORD ); SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_SW_CONFIG_RECORD ].nvEvent, 0, 0 ) - } +#endif if ( FALSE == hasUsageRecordPassed ) { @@ -1805,12 +1928,12 @@ static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_NVDATA_EEPROM_OPS_FAILURE, (U08*)&state ); + BOOL timeoutStatus = didCommandTimeout( state ); RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; PROCESS_RECORD_SPECS_T jobSpecs = RECORDS_SPECS [ job ]; // Check if the fapi has finished - if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) + if ( Fapi_Status_FsmReady == FAPI_CHECK_FSM_READY_BUSY ) { // Check the integrity of data (the 16 bytes that were written to EEPROM should be read and be checked for each byte) if ( writtenRecordStatus == NVDATAMGMT_RECORD_NOT_CHECKED ) @@ -1872,12 +1995,12 @@ static NVDATAMGMT_EXEC_STATE_T handleExecVerifyEEPROMWriteState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_VERIFY_EEPROM_WRITE; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_NVDATA_EEPROM_OPS_FAILURE, (U08*)&state ); + BOOL timeoutStatus = didCommandTimeout( state ); RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; PROCESS_RECORD_SPECS_T jobSpecs = RECORDS_SPECS [ job ]; // Check if the write job is EEPROM or RTC RAM - if ( recordCurrentJob.memoryLocation == NVDATAMGMT_EEPROM && FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) + if ( recordCurrentJob.memoryLocation == NVDATAMGMT_EEPROM && Fapi_Status_FsmReady == FAPI_CHECK_FSM_READY_BUSY ) { U32 i; @@ -1924,7 +2047,7 @@ static NVDATAMGMT_EXEC_STATE_T handleExecReadFromEEPROMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_EEPROM; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_NVDATA_EEPROM_OPS_FAILURE, (U08*)&state ); + BOOL timeoutStatus = didCommandTimeout( state ); if ( ( Fapi_Status_FsmReady == FAPI_CHECK_FSM_READY_BUSY ) || ( TRUE == timeoutStatus ) ) { @@ -1953,9 +2076,9 @@ static NVDATAMGMT_EXEC_STATE_T handleExecEraseState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_ERASE_EEPROM; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_NVDATA_EEPROM_OPS_FAILURE, (U08*)&state ); + BOOL timeoutStatus = didCommandTimeout( state ); - if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady || timeoutStatus == TRUE ) + if ( Fapi_Status_FsmReady == FAPI_CHECK_FSM_READY_BUSY || timeoutStatus == TRUE ) { state = NVDATAMGMT_EXEC_STATE_IDLE; } @@ -1975,8 +2098,8 @@ static NVDATAMGMT_EXEC_STATE_T handleExecWriteToRAMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_RTC; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_RTC_RAM_OPS_ERROR, (U08*)&state ); - RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; + BOOL timeoutStatus = didCommandTimeout( state ); + RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; PROCESS_RECORD_SPECS_T jobSpecs = RECORDS_SPECS [ job ]; // Check if the RTC RAM has finished @@ -2048,8 +2171,8 @@ static NVDATAMGMT_EXEC_STATE_T handleExecVerifyRTCWriteState( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_VERIFY_RTC_WRITE; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_NVDATA_EEPROM_OPS_FAILURE, (U08*)&state ); - RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; + BOOL timeoutStatus = didCommandTimeout( state ); + RECORD_JOBS_STATE_T job = recordCurrentJob.recordJob; PROCESS_RECORD_SPECS_T jobSpecs = RECORDS_SPECS [ job ]; // Check if the write job is EEPROM or RTC RAM @@ -2102,7 +2225,7 @@ static NVDATAMGMT_EXEC_STATE_T handleExecReadFromRAMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_RTC; - BOOL timeoutStatus = didCommandTimeout ( ALARM_ID_RTC_RAM_OPS_ERROR, (U08*)&state ); + BOOL timeoutStatus = didCommandTimeout( state ); if ( ( ( TRUE == isSemaphoreReleased( SEMAPHORE_RTC ) ) && ( RTC_RAM_STATUS_IDLE == getRTCRAMStatus() ) ) || ( TRUE == timeoutStatus ) ) { @@ -2223,13 +2346,7 @@ #endif break; -#ifdef _DG_ - case NVDATAMGMT_SCHEDULED_RUNS_RECORD: - // Pass the information to the CAN bus - sendDGScheduledRunsRecord( calPublishMessageCount + 1, calPublishTotalMessages, length, startPtr ); - // There are no scheduled runs for HD right now. - break; -#endif +#ifndef _RELEASE_ case NVDATAMGMT_SW_CONFIG_RECORD: #ifdef _DG_ sendDGSWConfigRecord( calPublishMessageCount + 1, calPublishTotalMessages, length, startPtr ); @@ -2238,12 +2355,14 @@ sendHDSWConfigRecord( calPublishMessageCount + 1, calPublishTotalMessages, length, startPtr ); #endif break; +#endif case NVDATAMGMT_USAGE_INFO_RECORD: #ifdef _DG_ sendDGUsageInfoRecord( calPublishMessageCount + 1, calPublishTotalMessages, length, startPtr ); #endif #ifdef _HD_ + sendHDUsageRecord( calPublishMessageCount + 1, calPublishTotalMessages, length, startPtr ); #endif break; @@ -2478,12 +2597,12 @@ } } +#ifdef ENABLE_LOCAL_LOGGING /*********************************************************************//** * @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 - * @details Outputs: queueFrontIndex, queueCount + * The dequeue function removes a job from the job queue if it is not empty. + * @details Inputs: jobQueue[], queueFrontIndex, queueCount + * @details Outputs: jobQueue[], queueFrontIndex, queueCount * @return none *************************************************************************/ static void dequeue ( void ) @@ -2503,7 +2622,9 @@ } _enable_IRQ(); } +#endif +#ifdef ENABLE_LOCAL_LOGGING /*********************************************************************//** * @brief * The isQueueEmpty checks whether the queue is empty and if it is empty, @@ -2523,6 +2644,7 @@ return isEmpty; } +#endif /*********************************************************************//** * @brief @@ -2563,21 +2685,21 @@ * flag to TRUE. * @details Inputs: none * @details Outputs: alarm if command timed out - * @param alarm alarm ID * @param state the state that the command timed out * @return TRUE if a command timed out *************************************************************************/ -static BOOL didCommandTimeout ( ALARM_ID_T alarm, U08* state ) +static BOOL didCommandTimeout ( NVDATAMGMT_EXEC_STATE_T state ) { - /* - * NOTE: The state is a pointer so it can cover both the self-test - * states and exec states - */ BOOL status = FALSE; - if ( didTimeout( currentTime, COMMAND_TIME_OUT ) ) + if ( TRUE == didTimeout( currentTime, COMMAND_TIME_OUT ) ) { - SET_ALARM_WITH_1_U32_DATA( alarm, *state ); +#ifdef _DG_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_NVDATA_MANAGEMENT_OPS_TIMEOUT, state ) +#endif +#ifdef _HD_ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_NVDATA_MANAGEMENT_OPS_TIMEOUT, state ) +#endif status = TRUE; } @@ -2647,7 +2769,7 @@ { benignPolynomialCalRecord( record ); - // Set the to FALSE since the record is not valid + // Set status to FALSE since the record is not valid status = FALSE; } @@ -2733,6 +2855,13 @@ activateAlarmNoData( ALARM_ID_DG_INVALID_SYSTEM_RECORD_CRC ); } + else + { + if ( RECORD_DEFAULT_CHARACTER == dgSystemGroup.dgSystemRecord.topLevelSN[ 0 ] ) + { + activateAlarmNoData( ALARM_ID_DG_INVALID_SERIAL_NUMBER ); + } + } return status; } @@ -2756,7 +2885,7 @@ // CRC did not pass so set all values to default dgServiceGroup.dgServiceRecord.lastServiceEpochDate = 0; dgServiceGroup.dgServiceRecord.serviceIntervalSeconds = RECORD_DEFAULT_SERVICE_INTERVAL_S; - //dgServiceGroup.dgServiceRecord.lastResetTimeEpoch = getRTCTimestamp(); // TODO un-comment with the next calibration table roll out + dgServiceGroup.dgServiceRecord.lastResetTimeEpoch = getRTCTimestamp(); dgServiceGroup.dgServiceRecord.crc = crc16 ( (U08*)&dgServiceGroup.dgServiceRecord, sizeof( DG_SERVICE_RECORD_T ) - sizeof( U16 ) ); dgServiceGroup.crc = crc16 ( (U08*)&dgServiceGroup, sizeof( DG_SERVICE_GROUP_T ) - sizeof( U16 ) ); status = FALSE; @@ -2784,15 +2913,14 @@ if ( calcCRC != recordCRC ) { - dgUsageInfoGroup.dgUsageInfo.isDisinfected = FALSE; - dgUsageInfoGroup.dgUsageInfo.lastChemicalDisDateEpoch = 0; - dgUsageInfoGroup.dgUsageInfo.lastHeatDisDateEpoch = 0; - dgUsageInfoGroup.dgUsageInfo.roWaterGenSinceLastServiceL = 0.0; - dgUsageInfoGroup.dgUsageInfo.roWaterGenTotalL = 0.0; - dgUsageInfoGroup.dgUsageInfo.lastResetTimeEpoch = getRTCTimestamp(); - dgUsageInfoGroup.dgUsageInfo.crc = crc16( (U08*)&dgUsageInfoGroup.dgUsageInfo, sizeof( DG_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); - dgUsageInfoGroup.crc = crc16( (U08*)&dgUsageInfoGroup, sizeof( DG_USAGE_INFO_GROUP_T ) - sizeof( U16 ) ); - status = FALSE; + dgUsageInfoGroup.dgUsageInfo.lastChemDisCompleteDateEpoch = 0; + dgUsageInfoGroup.dgUsageInfo.lastHeatDisCompleteDateEpoch = 0; + dgUsageInfoGroup.dgUsageInfo.roWaterGenSinceLastServiceL = 0.0F; + dgUsageInfoGroup.dgUsageInfo.roWaterGenTotalL = 0.0F; + dgUsageInfoGroup.dgUsageInfo.lastResetTimeEpoch = getRTCTimestamp(); + dgUsageInfoGroup.dgUsageInfo.crc = crc16( (U08*)&dgUsageInfoGroup.dgUsageInfo, sizeof( DG_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); + dgUsageInfoGroup.crc = crc16( (U08*)&dgUsageInfoGroup, sizeof( DG_USAGE_INFO_GROUP_T ) - sizeof( U16 ) ); + status = FALSE; activateAlarmNoData( ALARM_ID_DG_INVALID_USAGE_RECORD_CRC ); } @@ -2889,12 +3017,6 @@ isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } - for ( i = 0; i < COND_SENSORS_RESERVED_SPACE_COUNT; i++ ) - { - // Benign the conductivity sensors reserved spaces - memcpy( (POLYNOMIAL_CAL_PAYLOAD_T*)&cond->reservedSpace[ i ], &tempRecord, sizeof( POLYNOMIAL_CAL_PAYLOAD_T ) ); - } - DG_CONC_PUMPS_CAL_RECORD_T* concPump = &dgCalibrationRecord.dgCalibrationGroups.concentratePumpsRecord; for ( i = 0; i < NUM_OF_CAL_DATA_DG_CONC_PUMPS; i++ ) { @@ -2986,11 +3108,25 @@ if ( ( FALSE == isCalRecordValid ) || ( recordCRC != dgCalibrationRecord.crc ) ) { isCalRecordValid = FALSE; - dgCalibrationRecord.crc = recordCRC; + dgCalibrationRecord.crc = crc16 ( (U08*)&dgCalibrationRecord, sizeof( DG_CALIBRATION_RECORD_T ) - sizeof( U16 ) ); activateAlarmNoData( ALARM_ID_DG_NVDATAMGMT_CAL_GROUP_RECORD_CRC_INVALID ); } + + // TODO add this check to the calibration records + // This record is not part of the calibration record yet + U08 j; + DG_CHEMICALS_FILL_COND_CAL_RECORD_T* acidBicarbTempRecord = &tempChemsRecordRemove; + for ( i = 0; i < NUM_OF_ACID_TYPE; i++ ) + { + for ( j = 0; j < NUM_OF_FILL_COND_TEST; j++ ) + { + isDGFillConductiviesRecordValid( &acidBicarbTempRecord->fillCondValues[ i ][ j ], (DG_FILL_COND_OPS_T)j, (DG_ACID_TYPES_T)i ); + } + } + // TODO add this check to the calibration records. this is temporary + return isCalRecordValid; } @@ -3384,6 +3520,97 @@ return status; } + +/*********************************************************************//** + * @brief + * The isDGFillConductiviesRecordValid function checks whether fill conductivity + * record is valid or not. + * @details Inputs: none + * @details Outputs: none + * @param record: DG_ACID_BICARB_FILL_COND_VALUES_T pointer containing the + * fill conductivities of acid and bicrab + * @param operation which is the type fill operation that is check (e.g. normal ops) + * @param acidType whcih is the type of acid that its values are checked (e.g. 0-1251-1) + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDGFillConductiviesRecordValid( DG_ACID_BICARB_FILL_COND_VALUES_T* record, DG_FILL_COND_OPS_T operation, DG_ACID_TYPES_T acidType ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof(DG_ACID_BICARB_FILL_COND_VALUES_T) - sizeof(U16) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + F32 acidSensorCond = 0.0F; + F32 bicarbSensorCond = 0.0F; + + switch ( operation ) + { + case FILL_COND_NORMAL_OP: + switch ( acidType ) + { + case ACID_08_1251_1: + acidSensorCond = DEFAULT_FILL_1251_1_ACID_SNSR_US_PER_CM; + bicarbSensorCond = DEFAULT_FILL_1251_1_BIC_SNSR_US_PER_CM; + break; + + case ACID_08_2251_0: + acidSensorCond = DEFAULT_FILL_2251_0_ACID_SNSR_US_PER_CM; + bicarbSensorCond = DEFAULT_FILL_2251_0_BIC_SNSR_US_PER_CM; + break; + + case ACID_08_3251_9: + acidSensorCond = DEFAULT_FILL_3251_9_ACID_SNSR_US_PER_CM; + bicarbSensorCond = DEFAULT_FILL_3251_9_BIC_SNSR_US_PER_CM; + break; + + default: + // TODO software fault + break; + } + break; + + case FILL_COND_ACID_TEST: + switch ( acidType ) + { + case ACID_08_1251_1: + acidSensorCond = DEFAULT_ACID_TEST_1251_1_US_PER_CM; + bicarbSensorCond = DEFAULT_ACID_TEST_1251_1_US_PER_CM; + break; + + case ACID_08_2251_0: + acidSensorCond = DEFAULT_ACID_TEST_2251_0_US_PER_CM; + bicarbSensorCond = DEFAULT_ACID_TEST_2251_0_US_PER_CM; + break; + + case ACID_08_3251_9: + acidSensorCond = DEFAULT_ACID_TEST_3251_9_US_PER_CM; + bicarbSensorCond = DEFAULT_ACID_TEST_3251_9_US_PER_CM; + break; + + default: + // TODO software fault + break; + } + break; + + case FILL_COND_BICARB_TEST: + acidSensorCond = DEFAULT_BIC_TEST_ACID_SNSR_US_PER_CM; + bicarbSensorCond = DEFAULT_BIC_TEST_BIC_SNSR_US_PER_CM; + break; + } + + // CRC did not pass so set all values to default + record->acidConduSPerCM = acidSensorCond; + record->bicarbConduSPerCM = bicarbSensorCond; + record->crc = crc16 ( (U08*)record, sizeof(DG_ACID_BICARB_FILL_COND_VALUES_T) - sizeof(U16) ); + + // Set the to FALSE since the record is not valid + status = FALSE; + } + + return status; +} #endif #ifdef _HD_ /*********************************************************************//** @@ -3414,6 +3641,14 @@ activateAlarmNoData( ALARM_ID_HD_INVALID_SYSTEM_RECORD_CRC ); } + else + { + // Check if the first character of the serial number is not empty space. If it is, trigger the alarm + if ( RECORD_DEFAULT_CHARACTER == hdSystemGroup.hdsystemRecord.topLevelSN[ 0 ] ) + { + activateAlarmNoData( ALARM_ID_HD_INVALID_SERIAL_NUMBER ); + } + } return status; } @@ -3437,6 +3672,7 @@ // CRC did not pass so set all values to default hdServiceGroup.hdServiceRecord.lastServiceEpochDate = 0; hdServiceGroup.hdServiceRecord.serviceIntervalSeconds = RECORD_DEFAULT_SERVICE_INTERVAL_S; + hdServiceGroup.hdServiceRecord.lastServiceEpochDate = getRTCTimestamp(); hdServiceGroup.hdServiceRecord.crc = crc16 ( (U08*)&hdServiceGroup.hdServiceRecord, sizeof( HD_SERVICE_RECORD_T ) - sizeof( U16 ) ); hdServiceGroup.crc = crc16 ( (U08*)&hdServiceGroup, sizeof( HD_SERVICE_GROUP_T ) - sizeof( U16 ) ); status = FALSE; @@ -3452,8 +3688,8 @@ * @brief * The isHDUsageRecordValid function checks whether the HD usage information * is valid or not. - * @details Inputs: dgUsageInfoGroup - * @details Outputs: dgUsageInfoGroup + * @details Inputs: hdUsageInfoGroup + * @details Outputs: hdUsageInfoGroup * @return TRUE if the DG usage record is valid otherwise FALSE *************************************************************************/ static BOOL isHDUsageRecordValid( void ) @@ -3713,8 +3949,8 @@ /*********************************************************************//** * @brief * The enqueueRecordJob function enqueues a new record job. - * @details Inputs: queueFrontIndex, queueCount, recordJobQueue - * @details Outputs: queueFrontIndex, queueCount, recordJobQueue + * @details Inputs: recordQueueRearIndex, queueCount, recordJobQueue + * @details Outputs: recordQueueRearIndex, queueCount, recordJobQueue * @param ops: memory operation (i.e write, read) * @param location: memory location which are either EEPROM or RTC RAM * @param job: type of job (i.e write calibration data) @@ -3774,8 +4010,16 @@ U32 tempIndex; PROCESS_RECORD_JOB_T tempJob; BOOL status = FALSE; + +#ifdef _HD_ BOOL checkUIStatus = TRUE; +#endif + // Initialize the structure per CppCheck run + tempJob.memoryLocation = NVDATAMGMT_EEPROM; + tempJob.memoryOperation = NVDATAMGMT_NONE; + tempJob.recordJob = NVDATAMGMT_CALIBRATION_RECORD; + _disable_IRQ(); tempIndex = recordQueueFrontIndex; @@ -3785,22 +4029,28 @@ } _enable_IRQ(); + if ( NVDATAMGMT_RTC == tempJob.memoryLocation ) + { #ifdef _HD_ - checkUIStatus = ( TRUE == uiCommunicated() ? TRUE : FALSE ); + if ( TRUE == uiCommunicated() ) #endif - - if ( ( NVDATAMGMT_RTC == tempJob.memoryLocation ) && ( TRUE == checkUIStatus ) ) - { - if ( ( RTC_RAM_STATE_READY == getRTCRAMState() ) && ( TRUE == getSemaphore( SEMAPHORE_RTC ) ) ) { - status = TRUE; + if ( ( RTC_RAM_STATE_READY == getRTCRAMState() ) && ( TRUE == getSemaphore( SEMAPHORE_RTC ) ) ) + { + status = TRUE; + } } } - else if ( ( NVDATAMGMT_EEPROM == tempJob.memoryLocation ) && ( TRUE == checkUIStatus ) ) + else if ( NVDATAMGMT_EEPROM == tempJob.memoryLocation ) { - if ( Fapi_Status_FsmReady == FAPI_CHECK_FSM_READY_BUSY ) +#ifdef _HD_ + if ( TRUE == uiCommunicated() ) +#endif { - status = TRUE; + if ( Fapi_Status_FsmReady == FAPI_CHECK_FSM_READY_BUSY ) + { + status = TRUE; + } } }