Index: firmware/App/Services/NVRecordsDD.c =================================================================== diff -u -r63c3a65e681810f037718377c6ed5a28c897d0ca -re17e1dc97bf8878056f1f7e4aa861c2448db52bc --- firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision 63c3a65e681810f037718377c6ed5a28c897d0ca) +++ firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision e17e1dc97bf8878056f1f7e4aa861c2448db52bc) @@ -27,59 +27,54 @@ // ********** private definitions ********** -#define RECORD_DEFAULT_TIME 0U ///< Record default time (calibration/set). -#define RECORD_FOURTH_ORDER_COEFF 0.0F ///< Record fourth order coefficient. -#define RECORD_THIRD_ORDER_COEFF 0.0F ///< Record third order coefficient. -#define RECORD_SECOND_ORDER_COEFF 0.0F ///< Record second order coefficient. -#define RECORD_DEFAULT_GAIN 1.0F ///< Record default gain. -#define RECORD_DEFAULT_OFFSET 0.0F ///< Record default offset. -#define RECORD_DEFAULT_CONST 0.0F ///< Record default constant. -#define RECORD_DEFAULT_RATIO 1.0F ///< Record default ratio. -#define RECORD_DEFAULT_SERVICE_INTERVAL_S 15768000U ///< Record default service interval in seconds (6 months). -#define RECORD_DEFAULT_CHARACTER ' ' ///< Record default character. +#define RECORD_DEFAULT_TIME 0U ///< Record default time (calibration/set). +#define RECORD_FOURTH_ORDER_COEFF 0.0F ///< Record fourth order coefficient. +#define RECORD_THIRD_ORDER_COEFF 0.0F ///< Record third order coefficient. +#define RECORD_SECOND_ORDER_COEFF 0.0F ///< Record second order coefficient. +#define RECORD_DEFAULT_GAIN 1.0F ///< Record default gain. +#define RECORD_DEFAULT_OFFSET 0.0F ///< Record default offset. +#define RECORD_DEFAULT_CONST 0.0F ///< Record default constant. +#define RECORD_DEFAULT_RATIO 1.0F ///< Record default ratio. +#define RECORD_DEFAULT_SERVICE_INTERVAL_S 15768000U ///< Record default service interval in seconds (6 months). +#define RECORD_DEFAULT_CHARACTER ' ' ///< Record default character. // DD specific defines -#define DEFAULT_FLUSH_LINES_VOLUME_L 0.01F ///< Water volume to flush when starting re-circulate mode in liters. -#define DEFAULT_BICARB_CONC_MIXING_RATIO ( 4.06812F / FRACTION_TO_PERCENT_FACTOR ) ///< Ratio between RO water and bicarbonate concentrate mixing ratio. -#define DEFAULT_BICARB_BOTTLE_VOL_ML 3780.0F ///< Record default bicarb bottle volume in milliliters. -#define DEFAULT_BICARB_COND_US_PER_CM 13734.88F ///< Record default acid conductivity in uS/cm. -#define DEFAULT_BICARB_BOTTLE_TEMP_C 23.5F ///< Record default acid bottle temperature in C. -#define DEFAULT_ACID_CONC_MIXING_RATIO ( 2.35618F / FRACTION_TO_PERCENT_FACTOR ) ///< Ratio between RO water and acid concentrate mixing ratio. -#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_UF_TEMP_TAU_C_PER_MIN -0.6F ///< Ultrafilter temperature time constant C/min. -#define DEFAULT_UF_VOLUME_ML 700 ///< Ultrafilter volume in milliliters. -#define DEFAULT_BLOOD_LEAK_SET_POINT 20 ///< Blood leak default set point. +#define DEFAULT_D12_PUMP_TARGET_SPEED 0 ///< Default D12 dailysate pump target speed. +#define DEFAULT_BICARB_CONC_MIXING_RATIO ( 4.06812F / FRACTION_TO_PERCENT_FACTOR ) ///< Ratio between RO water and bicarbonate concentrate mixing ratio. +#define DEFAULT_BICARB_BOTTLE_VOL_ML 3780.0F ///< Record default bicarb bottle volume in milliliters. +#define DEFAULT_BICARB_COND_US_PER_CM 13734.88F ///< Record default acid conductivity in uS/cm. +#define DEFAULT_BICARB_BOTTLE_TEMP_C 23.5F ///< Record default acid bottle temperature in C. +#define DEFAULT_ACID_CONC_MIXING_RATIO ( 2.35618F / FRACTION_TO_PERCENT_FACTOR ) ///< Ratio between RO water and acid concentrate mixing ratio. +#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_UF_TEMP_TAU_C_PER_MIN -0.6F ///< Ultrafilter temperature time constant C/min. +#define DEFAULT_UF_VOLUME_ML 700 ///< Ultrafilter volume in milliliters. +#define DEFAULT_BLOOD_LEAK_SET_POINT 20 ///< Blood leak default set point. -#define DEFAULT_FILL_1251_1_ACID_SNSR_US_PER_CM 0.0F ///< 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 0.0F ///< 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 0.0F ///< 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_NUM_OF_DISINFECTION_FREQUENCY 3 ///< Number of Days between each disinfection cycle +#define DEFAULT_NUM_OF_DISINFECTION_CYCLE_TIME 30 ///< Time period of which disinfection is done +#define DEFAULT_MAX_RO_REJECTION_RATIO_PCT 90 ///< Max RO rejection ratio in percent. +#define DEFAULT_MIN_INLET_WATER_COND_ALARM_US_P_CM 200.0F ///< Min inlet water conductivity alarm limit in uS/cm. +#define DEFAULT_MAX_INLET_WATER_COND_ALARM_US_P_CM 50.0F ///< Max inlet water conductivity alarm limit in uS/cm. +#define DEFAULT_ACID_CONCENTRATE_JUG_SIZE 3.43F ///< Acid Concentrate jug size in litres +#define DEFAULT_MIN_ACID_ALARM_US_P_CM 0 ///< Min acid alarm limit in percent. +#define DEFAULT_MIN_BICARB_ALARM_US_P_CM 0 ///< Min bicarb alarm limit in percent. +#define DEFAULT_POST_TREATMENT_DRAIN_OPTION 0 ///< Default Post Treatment Drain Option +#define DEFAULT_POST_TREATMENT_DRY_BICARB_OPTION 0 ///< Default Post Treatment Dry Bicarb Option -#define DEFAULT_ACID_TEST_1251_1_US_PER_CM 13768.28F ///< Acid test acid 1251_1 acid conductivity uS/cm. -#define DEFAULT_ACID_TEST_2251_0_US_PER_CM 13919.05F ///< Acid test acid 2251_0 acid conductivity uS/cm. -#define DEFAULT_ACID_TEST_3251_9_US_PER_CM 14071.04F ///< Acid acid 3251_9 acid conductivity uS/cm. +#define MAX_NUM_OF_WRITE_TRIES 3U ///< Max number of write tries. -#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. +#define RECORD_BYTE_SIZE(r) (sizeof(r) + sizeof(U16)) ///< Record byte size macro. -#define DEFAULT_MAX_RO_REJECTION_RATIO_PCT 90 ///< Max RO rejection ratio in percent. -#define DEFAULT_MIN_INLET_WATER_COND_ALARM_US_P_CM 200.0F ///< Min inlet water conductivity alarm limit in uS/cm. - -#define MAX_NUM_OF_WRITE_TRIES 3U ///< Max number of write tries. - -#define RECORD_BYTE_SIZE(r) (sizeof(r) + sizeof(U16)) ///< Record byte size macro. // Padding length calculation: (DG struct size % bytes to write(16) == 0 ? 0 : ((DG struct size / bytes to write(16)) + 1) * bytes to write(16)) - DG struct size. // NOTE: assuming the macro is calculating the padding length for a non-volatile memory. For NV, 16 bytes is used and buffer and for the RTC RAM 64 bytes is used. // If the size of the structure + a 2-byte crc mod 16 is 0, then the size of the padding is 0 // Otherwise, the (((structure size + crc) / 16) + 1) * 16. In the calculations, a + 1 is added since the division has a decimal so + 1 is used // 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. +#define RECORD_PADDING_LENGTH(rcrd, buf) (RECORD_BYTE_SIZE(rcrd) % buf == 0 ? 0 : \ + ((((RECORD_BYTE_SIZE(rcrd) / buf) + 1)) * buf) \ + - RECORD_BYTE_SIZE(rcrd)) ///< DD padding length macro. #pragma pack(push, 1) @@ -91,11 +86,11 @@ DD_PRES_SENSORS_CAL_RECORD_T presSensorsCalRecord; ///< DD pressure sensors calibration record DD_TEMP_SENSORS_CAL_RECORD_T tempSensorsCalRecord; ///< DD temperature sensors calibration record DD_CONC_PUMPS_CAL_RECORD_T concentratePumpsRecord; ///< DD concentrate pumps calibration record - DD_DIALYSATE_PUMPS_CAL_RECORD_T dialysatePumpsRecord; ///< DD dialysate pumps calibration record + DD_D12_DIALYSATE_PUMP_RECORD_T d12DialysatePumpRecord; ///< DD dialysate pump d12 calibration data. + DD_D48_DIALYSATE_PUMP_RECORD_T d48DialysatePumpRecord; ///< DD dialysate pumps calibration record DD_ACID_CONCENTRATES_RECORD_T acidConcentratesRecord; ///< DD acid concentrates calibration record DD_BICARB_CONCENTRATES_RECORD_T bicarbConcentratesRecord; ///< DD bicarb concentrates calibration record DD_ACCEL_SENSOR_CAL_RECORD_T accelerometerSensorCalRecord; ///< DD accelerometer sensor. - DD_CONCENTRATES_COND_CAL_RECORD_T concentratesCondCalRecord; ///< DD fill acid/bicarb target conductivities calibration record. DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T bloodLeakSensorCalRecord; ///< DD blood leak detector calibration record } DD_CALIBRATION_GROUPS_T; @@ -152,13 +147,13 @@ static DD_USAGE_INFO_GROUP_T ddTempRxUsageGrp; ///< DD usage info structure (including padding and final CRC). // Temporary Process records specifications used only for receiving -static PROCESS_RECORD_SPECS_T tempRxRecords[ NUM_OF_NVDATMGMT_RECORDS_JOBS ] = { +static PROCESS_RECORD_SPECS_T tempRxRecords[ NUM_OF_NVM_RECORD_TYPES ] = { // Start address Size of the job Record structure pointer Record CRC pointer Event calibration record update - {SYSTEM_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SYSTEM_GROUP_T), (U08*)&ddTempRxSystemGrp, (U08*)&ddTempRxSystemGrp.crc, DD_EVENT_SYSTEM_RECORD_UPDATE }, // NVDATAMGMT_SYSTEM_RECORD - {SERVICE_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SERVICE_GROUP_T), (U08*)&ddTempRxServiceGrp, (U08*)&ddTempRxServiceGrp.crc, DD_EVENT_SERVICE_UPDATE }, // NVDATAMGMT_SERVICE_RECORD - {CAL_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_CALIBRATION_RECORD_T), (U08*)&ddTempRxCalRecord, (U08*)&ddTempRxCalRecord.crc, DD_EVENT_CAL_RECORD_UPDATE }, // NVDATAMGMT_CALIBRATION_RECORD - {INSTIT_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_INSTITUTIONAL_GROUP_T), (U08*)&ddTempRxInstitGrp, (U08*)&ddTempRxInstitGrp.crc, DD_EVENT_INSTIT_RECORD_UPDATE }, // NVDATAMGMT_INSTITUTIONAL_RECORD - {USAGE_INFO_START_ADDRESS, sizeof(DD_USAGE_INFO_GROUP_T), (U08*)&ddTempRxUsageGrp, (U08*)&ddTempRxUsageGrp.crc, DD_EVENT_USAGE_INFO_UPDATE }, // NVDATAMGMT_USAGE_INFO_RECORD + {SYSTEM_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SYSTEM_GROUP_T), (U08*)&ddTempRxSystemGrp, (U08*)&ddTempRxSystemGrp.crc, DD_EVENT_SYSTEM_RECORD_UPDATE }, // NVM_SYSTEM_RECORD + {SERVICE_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SERVICE_GROUP_T), (U08*)&ddTempRxServiceGrp, (U08*)&ddTempRxServiceGrp.crc, DD_EVENT_SERVICE_UPDATE }, // NVM_SERVICE_RECORD + {CAL_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_CALIBRATION_RECORD_T), (U08*)&ddTempRxCalRecord, (U08*)&ddTempRxCalRecord.crc, DD_EVENT_CAL_RECORD_UPDATE }, // NVM_CALIBRATION_RECORD + {INSTIT_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_INSTITUTIONAL_GROUP_T), (U08*)&ddTempRxInstitGrp, (U08*)&ddTempRxInstitGrp.crc, DD_EVENT_INSTIT_RECORD_UPDATE }, // NVM_INSTITUTIONAL_RECORD + {USAGE_INFO_START_ADDRESS, sizeof(DD_USAGE_INFO_GROUP_T), (U08*)&ddTempRxUsageGrp, (U08*)&ddTempRxUsageGrp.crc, DD_EVENT_USAGE_INFO_UPDATE }, // NVM_USAGE_INFO_RECORD }; // Main NVM Record variables @@ -169,36 +164,37 @@ static DD_USAGE_INFO_GROUP_T ddUsageInfoGroup; ///< DD usage info structure (including padding and final CRC). // Main Process records specifications -const PROCESS_RECORD_SPECS_T RECORDS_SPECS[ NUM_OF_NVDATMGMT_RECORDS_JOBS ] = { +const PROCESS_RECORD_SPECS_T RECORDS_SPECS[ NUM_OF_NVM_RECORD_TYPES ] = { // Start address Size of the job Record structure pointer Record CRC pointer Event calibration record update - {SYSTEM_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SYSTEM_GROUP_T), (U08*)&ddSystemGroup, (U08*)&ddSystemGroup.crc, DD_EVENT_SYSTEM_RECORD_UPDATE }, // NVDATAMGMT_SYSTEM_RECORD - {SERVICE_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SERVICE_GROUP_T), (U08*)&ddServiceGroup, (U08*)&ddServiceGroup.crc, DD_EVENT_SERVICE_UPDATE }, // NVDATAMGMT_SERVICE_RECORD - {CAL_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_CALIBRATION_RECORD_T), (U08*)&ddCalibrationRecord, (U08*)&ddCalibrationRecord.crc, DD_EVENT_CAL_RECORD_UPDATE }, // NVDATAMGMT_CALIBRATION_RECORD - {INSTIT_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_INSTITUTIONAL_GROUP_T), (U08*)&ddInstitutionalGroup, (U08*)&ddInstitutionalGroup.crc, DD_EVENT_INSTIT_RECORD_UPDATE }, // NVDATAMGMT_INSTITUTIONAL_RECORD - {USAGE_INFO_START_ADDRESS, sizeof(DD_USAGE_INFO_GROUP_T), (U08*)&ddUsageInfoGroup, (U08*)&ddUsageInfoGroup.crc, DD_EVENT_USAGE_INFO_UPDATE }, // NVDATAMGMT_USAGE_INFO_RECORD + {SYSTEM_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SYSTEM_GROUP_T), (U08*)&ddSystemGroup, (U08*)&ddSystemGroup.crc, DD_EVENT_SYSTEM_RECORD_UPDATE }, // NVM_SYSTEM_RECORD + {SERVICE_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_SERVICE_GROUP_T), (U08*)&ddServiceGroup, (U08*)&ddServiceGroup.crc, DD_EVENT_SERVICE_UPDATE }, // NVM_SERVICE_RECORD + {CAL_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_CALIBRATION_RECORD_T), (U08*)&ddCalibrationRecord, (U08*)&ddCalibrationRecord.crc, DD_EVENT_CAL_RECORD_UPDATE }, // NVM_CALIBRATION_RECORD + {INSTIT_RECORD_NV_MEM_START_ADDRESS, sizeof(DD_INSTITUTIONAL_GROUP_T), (U08*)&ddInstitutionalGroup, (U08*)&ddInstitutionalGroup.crc, DD_EVENT_INSTIT_RECORD_UPDATE }, // NVM_INSTITUTIONAL_RECORD + {USAGE_INFO_START_ADDRESS, sizeof(DD_USAGE_INFO_GROUP_T), (U08*)&ddUsageInfoGroup, (U08*)&ddUsageInfoGroup.crc, DD_EVENT_USAGE_INFO_UPDATE }, // NVM_USAGE_INFO_RECORD }; -static NVDATAMGMT_SELF_TEST_STATE_T nvDataMgmtSelfTestState; ///< NVDataMgmt self-test state variable. -static SELF_TEST_STATUS_T nvDataMgmtSelfTestResult; ///< NVDataMgmt self-test result. +static NVM_SELF_TEST_STATE_T nvmSelfTestState; ///< NVM self-test state variable. +static SELF_TEST_STATUS_T nvmSelfTestResult; ///< NVM self-test result. static U32 usageWriteTries; ///< Usage write tries. static BOOL isSelfTestReadRecordsDone; ///< Set to true when all the records are read // ********** private function prototypes ********** // Self test functions -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadRecords( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC( void ); +static NVM_SELF_TEST_STATE_T handleSelfTestReadRecords( void ); +static NVM_SELF_TEST_STATE_T handleSelfTestCheckCRC( void ); // Record check helper functions static BOOL isPolynomialRecordValid( POLYNOMIAL_CAL_PAYLOAD_T* record ); static BOOL isDDSystemRecordValid( void ); static BOOL isDDServiceRecordValid( void ); +static BOOL isDDInstitutionalRecordValid( void ); static BOOL isDDUsageRecordValid( void ); static BOOL isDDCalibrationRecordValid( void ); +static BOOL isDDPumpD12RecordValid( DD_D12_DIALYSATE_PUMP_RECORD_T* record ); static BOOL isDDAcidConcentrateRecordValid( DD_ACID_CONCENTRATE_T* record ); static BOOL isDDBicarbConcentrateRecordValid( DD_BICARB_CONCENTRATE_T* record ); static BOOL isDDAccelerometerSensorRecordValid( DD_ACCEL_SENSOR_CAL_RECORD_T* record ); -static BOOL isDDFillConductiviesRecordValid( DD_ACID_BICARB_FILL_COND_VALUES_T* record, DD_ACID_TYPES_T acidType, DD_FILL_COND_OPS_T operation ); static BOOL isDDBloodLeakSesnorValid( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* record ); /*********************************************************************//** @@ -207,55 +203,55 @@ * state and resets related control variables. It sets the self-test * process to start reading records. * @details \b Inputs: none - * @details \b Outputs: nvDataMgmtSelfTestState, - * nvDataMgmtSelfTestResult, usageWriteTries + * @details \b Outputs: nvmSelfTestState, + * nvmSelfTestResult, usageWriteTries * @return none *************************************************************************/ void initNVRecordsDD( void ) { // Initialize the parameters - nvDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_READ_RECORDS; - nvDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; + nvmSelfTestState = NVM_SELF_TEST_STATE_READ_RECORDS; + nvmSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; usageWriteTries = 0; } /*********************************************************************//** * @brief - * The execNVDataMgmtSelfTest function runs the NV data management + * The execNVMSelfTest function runs the NV data management * self-test state machine. It processes states and updates the result * based on self-test execution. * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT - * @details \b Inputs: nvDataMgmtSelfTestState, - * nvDataMgmtSelfTestResult - * @details \b Outputs: nvDataMgmtSelfTestState, - * nvDataMgmtSelfTestResult - * @return nvDataMgmtSelfTestResult the result of self-test + * @details \b Inputs: nvmSelfTestState, + * nvmSelfTestResult + * @details \b Outputs: nvmSelfTestState, + * nvmSelfTestResult + * @return nvmSelfTestResult the result of self-test *************************************************************************/ -SELF_TEST_STATUS_T execNVDataMgmtSelfTest ( void ) +SELF_TEST_STATUS_T execNVMSelfTest ( void ) { - switch ( nvDataMgmtSelfTestState ) + switch ( nvmSelfTestState ) { - case NVDATAMGMT_SELF_TEST_STATE_READ_RECORDS: - nvDataMgmtSelfTestState = handleSelfTestReadRecords(); + case NVM_SELF_TEST_STATE_READ_RECORDS: + nvmSelfTestState = handleSelfTestReadRecords(); break; - case NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC: - nvDataMgmtSelfTestState = handleSelfTestCheckCRC(); + case NVM_SELF_TEST_STATE_CHECK_CRC: + nvmSelfTestState = handleSelfTestCheckCRC(); break; - case NVDATAMGMT_SELF_TEST_STATE_COMPLETE: + case NVM_SELF_TEST_STATE_COMPLETE: // Done with POST. Do nothing break; default: - SET_ALARM_WITH_2_U32_DATA ( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_SELF_TEST_STATE, ( U32 )nvDataMgmtSelfTestState ); - nvDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; - nvDataMgmtSelfTestResult = SELF_TEST_STATUS_FAILED; + SET_ALARM_WITH_2_U32_DATA ( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_SELF_TEST_STATE, ( U32 )nvmSelfTestState ); + nvmSelfTestState = NVM_SELF_TEST_STATE_COMPLETE; + nvmSelfTestResult = SELF_TEST_STATUS_FAILED; break; } - return nvDataMgmtSelfTestResult; + return nvmSelfTestResult; } /*********************************************************************//** @@ -268,7 +264,7 @@ * @return RECORDS_SPECS[job] corresponding process record specification *************************************************************************/ -PROCESS_RECORD_SPECS_T getProcessRecord( RECORD_JOBS_STATE_T job ) +PROCESS_RECORD_SPECS_T getProcessRecord( NVM_RECORD_TYPE_T job ) { return RECORDS_SPECS[ job ]; } @@ -282,7 +278,7 @@ * @param job Record job identifier used to select the temporary RX record * @return tempRxRecords[job] corresponding temporary RX record *************************************************************************/ -PROCESS_RECORD_SPECS_T getTemporaryRxRecord( RECORD_JOBS_STATE_T job ) +PROCESS_RECORD_SPECS_T getTemporaryRxRecord( NVM_RECORD_TYPE_T job ) { return tempRxRecords[ job ]; } @@ -295,17 +291,17 @@ * @details \b Outputs: none * @return state next self-test state *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadRecords( void ) +static NVM_SELF_TEST_STATE_T handleSelfTestReadRecords( void ) { - NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_RECORDS; + NVM_SELF_TEST_STATE_T state = NVM_SELF_TEST_STATE_READ_RECORDS; // 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 == isSelfTestReadRecordsDone ) { - updateRecordReadStatus( NVDATAMGMT_RECORDS_READ ); - state = NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC; + updateRecordReadStatus( NVM_RECORDS_READ ); + state = NVM_SELF_TEST_STATE_CHECK_CRC; } return state; @@ -317,19 +313,19 @@ * compares them with stored CRC values. If they don't match, it will fail POST. * It updates the self-test result * and schedules rewrite for invalid records. - * @details \b Inputs: nvDataMgmtSelfTestResult - * @details \b Outputs: nvDataMgmtSelfTestResult + * @details \b Inputs: nvmSelfTestResult + * @details \b Outputs: nvmSelfTestResult * @return state next self-test state *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) +static NVM_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) { - NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; + NVM_SELF_TEST_STATE_T state = NVM_SELF_TEST_STATE_COMPLETE; BOOL hasSystemRecordPassed = TRUE; BOOL hasServiceRecordPassed = TRUE; BOOL haveCalGroupsPassed = TRUE; BOOL hasUsageRecordPassed = TRUE; - updateRecordReadStatus( NVDATAMGMT_RECORDS_CRC_CHECKED ); + updateRecordReadStatus( NVM_RECORDS_CRC_CHECKED ); // Check all the calibration groups haveCalGroupsPassed = isDDCalibrationRecordValid(); @@ -344,24 +340,24 @@ hasSystemRecordPassed = isDDSystemRecordValid(); if ( FALSE == hasSystemRecordPassed ) { - enqueueEraseAndWriteSector ( NVDATAMGMT_SYSTEM_RECORD ); - SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_SYSTEM_RECORD ].nvEvent, 0, 0 ); + enqueueEraseAndWriteSector ( NVM_SYSTEM_RECORD ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_SYSTEM_RECORD ].nvEvent, 0, 0 ); } // Validate service and calibration records hasServiceRecordPassed = isDDServiceRecordValid(); haveCalGroupsPassed = isDDCalibrationRecordValid(); if ( ( FALSE == hasServiceRecordPassed ) || ( FALSE == haveCalGroupsPassed ) ) { - enqueueEraseAndWriteSector ( NVDATAMGMT_SERVICE_RECORD ); - SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_SERVICE_RECORD ].nvEvent, 0, 0 ); - SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_CALIBRATION_RECORD ].nvEvent, 0, 0 ); + enqueueEraseAndWriteSector ( NVM_SERVICE_RECORD ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_SERVICE_RECORD ].nvEvent, 0, 0 ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_CALIBRATION_RECORD ].nvEvent, 0, 0 ); } // Validate usage info record if ( FALSE == hasUsageRecordPassed ) { - enqueueEraseAndWriteSector ( NVDATAMGMT_USAGE_INFO_RECORD ); - SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ); + enqueueEraseAndWriteSector ( NVM_USAGE_INFO_RECORD ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_USAGE_INFO_RECORD ].nvEvent, 0, 0 ); } // Check if the records' entire CRCs as well as the individual CRCs passed @@ -370,11 +366,11 @@ { updateRecordStartTimer( getMSTimerCount() ); updateNewNVRecordAvailableFlag( TRUE ); - nvDataMgmtSelfTestResult = SELF_TEST_STATUS_PASSED; + nvmSelfTestResult = SELF_TEST_STATUS_PASSED; } else { - nvDataMgmtSelfTestResult = SELF_TEST_STATUS_FAILED; + nvmSelfTestResult = SELF_TEST_STATUS_FAILED; } return state; @@ -510,6 +506,63 @@ /*********************************************************************//** * @brief + * The isDDInstitutionalRecordValid function checks the validity of the DD + * institutional record. It verifies CRC and updates the record + * with default values if invalid. + * @details \b Alarms: ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC if CRC + * check fails + * @details \b Inputs: ddInstitutionalGroup + * @details \b Outputs: ddInstitutionalGroup + * @return TRUE if the DD Institutional record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDDInstitutionalRecordValid( void ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord, sizeof( DD_INSTITUTIONAL_RECORD_T ) - sizeof( U16 ) ); + U16 recordCRC = ddInstitutionalGroup.ddInstitutionalRecord.crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default +// ddInstitutionalGroup.ddInstitutionalRecord.minDialysateFlowMLPM = getU32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_FLOW, TRUE ); +// ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateFlowMLPM = getU32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_FLOW, FALSE ); +// ddInstitutionalGroup.ddInstitutionalRecord.minDialysateTempC = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, TRUE ); +// ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateTempC = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, FALSE ); +// ddInstitutionalGroup.ddInstitutionalRecord.acidConcentrate = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_ACID_CONCENTRATE, FALSE ); + +// ddInstitutionalGroup.ddInstitutionalRecord.bicarbCartridgeSizeG = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, FALSE ); +// ddInstitutionalGroup.ddInstitutionalRecord.minSodiumMEQL = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, FALSE ); +// ddInstitutionalGroup.ddInstitutionalRecord.maxSodiumMEQL = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, FALSE ); +// ddInstitutionalGroup.ddInstitutionalRecord.minBicarbonateMEQL = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, FALSE ); +// ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbonateMEQL = getF32DefaultTreatmentParamEdge( TREATMENT_PARAM_DIALYSATE_TEMPERATURE, FALSE ); + + ddInstitutionalGroup.ddInstitutionalRecord.minRORejectionRatioPCT = DEFAULT_MAX_RO_REJECTION_RATIO_PCT; + ddInstitutionalGroup.ddInstitutionalRecord.disinfectionFrequency = DEFAULT_NUM_OF_DISINFECTION_FREQUENCY; + ddInstitutionalGroup.ddInstitutionalRecord.disinfectionCycleTime = DEFAULT_NUM_OF_DISINFECTION_CYCLE_TIME; + ddInstitutionalGroup.ddInstitutionalRecord.minInletWaterCondAlarmLimitUSPCM = DEFAULT_MIN_INLET_WATER_COND_ALARM_US_P_CM; + ddInstitutionalGroup.ddInstitutionalRecord.maxInletWaterCondAlarmLimitUSPCM = DEFAULT_MAX_INLET_WATER_COND_ALARM_US_P_CM; + ddInstitutionalGroup.ddInstitutionalRecord.acidConcentrateJugSizeL = DEFAULT_ACID_CONCENTRATE_JUG_SIZE; + ddInstitutionalGroup.ddInstitutionalRecord.minAcidAlarmLimitPCT = DEFAULT_MIN_ACID_ALARM_US_P_CM; + ddInstitutionalGroup.ddInstitutionalRecord.minBicarbAlarmLimitPCT = DEFAULT_MIN_BICARB_ALARM_US_P_CM; + ddInstitutionalGroup.ddInstitutionalRecord.postTreatDrainOption = DEFAULT_POST_TREATMENT_DRAIN_OPTION; + ddInstitutionalGroup.ddInstitutionalRecord.postTreatDryBicarbOption = DEFAULT_POST_TREATMENT_DRY_BICARB_OPTION; + + +// ddInstitutionalGroup.ddInstitutionalRecord.calibrationTime = getRTCTimestamp(); + ddInstitutionalGroup.ddInstitutionalRecord.crc = crc16 ( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord, + sizeof( DD_INSTITUTIONAL_RECORD_T ) - sizeof( U16 ) ); + ddInstitutionalGroup.crc = crc16 ( (U08*)&ddInstitutionalGroup, sizeof( DD_INSTITUTIONAL_GROUP_T ) - sizeof( U16 ) ); + status = FALSE; + + // Institutional record failure is also considered as RTC RAM failure + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC ); + } + + return status; +} + +/*********************************************************************//** + * @brief * The isDDUsageRecordValid function checks the validity of the DD * usage information record. It verifies CRC and updates the record * with default values if invalid. @@ -599,14 +652,15 @@ isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; } - DD_DIALYSATE_PUMPS_CAL_RECORD_T* dialPump = &ddCalibrationRecord.ddCalibrationGroups.dialysatePumpsRecord; - for ( i = 0; i < NUM_OF_DIALYSATE_PUMPS; i++ ) - { - record = &dialPump->dialysatePump[ i ]; - isHardwareRecordValid = isPolynomialRecordValid( record ); - isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; - } + DD_D12_DIALYSATE_PUMP_RECORD_T* d12Pump = &ddCalibrationRecord.ddCalibrationGroups.d12DialysatePumpRecord; + isHardwareRecordValid = isDDPumpD12RecordValid( &d12Pump ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; + DD_D48_DIALYSATE_PUMP_RECORD_T* d48Pump = &ddCalibrationRecord.ddCalibrationGroups.d48DialysatePumpRecord; + record = &d48Pump->d48DialysatePump; + isHardwareRecordValid = isPolynomialRecordValid( record ); + isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; + DD_ACID_CONCENTRATES_RECORD_T* acidConc = &ddCalibrationRecord.ddCalibrationGroups.acidConcentratesRecord; for ( i = 0; i < NUM_OF_CAL_DATA_ACID_CONCENTRATES; i++ ) { @@ -625,17 +679,6 @@ isHardwareRecordValid = isDDAccelerometerSensorRecordValid( accelerometer ); isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; - DD_FILL_COND_OPS_T j; - DD_CONCENTRATES_COND_CAL_RECORD_T* acidBicarbTempRecord = &ddCalibrationRecord.ddCalibrationGroups.concentratesCondCalRecord; - for ( i = 0; i < NUM_OF_ACID_TYPE; i++ ) - { - for ( j = FILL_COND_NORMAL_OP; j < NUM_OF_FILL_COND_TEST; j++ ) - { - isHardwareRecordValid = isDDFillConductiviesRecordValid( &acidBicarbTempRecord->fillCondValues[ i ][ j ], (DD_ACID_TYPES_T)i, (DD_FILL_COND_OPS_T)j ); - isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; - } - } - DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* bloodLeak = &ddCalibrationRecord.ddCalibrationGroups.bloodLeakSensorCalRecord; isHardwareRecordValid = isDDBloodLeakSesnorValid( bloodLeak ); isCalRecordValid = isCalRecordValid == FALSE ? FALSE : isHardwareRecordValid; @@ -655,6 +698,34 @@ /*********************************************************************//** * @brief + * The isDDPumpD12RecordValid function checks if the D12 Dialysate Pump + * record is valid. It verifies CRC and updates + * the record with default values if invalid. + * @details \b Inputs: none + * @details \b Outputs: none + * @param record Pointer to DD D12 Dialysate record to check + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDDPumpD12RecordValid( DD_D12_DIALYSATE_PUMP_RECORD_T* record ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16 ( (U08*)record, sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ) - sizeof( U16 ) ); + U16 recordCRC = record->crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + record->targetPumpSpeed = DEFAULT_D12_PUMP_TARGET_SPEED; + record->calibrationTime = RECORD_DEFAULT_TIME; + record->crc = crc16 ( (U08*)record, sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ) - sizeof( U16 ) ); + status = FALSE; + } + + return status; +} + +/*********************************************************************//** + * @brief * The isDDAcidConcentrateRecordValid function checks if the acid * concentrate calibration record is valid. It verifies CRC and updates * the record with default values if invalid. @@ -749,108 +820,6 @@ /*********************************************************************//** * @brief - * The isDDFillConductiviesRecordValid function checks if the fill - * conductivity record is valid. It verifies CRC and updates the record - * with default values based on operation and acid type if invalid. - * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT if invalid acidType or - * operation is detected - * @details \b Inputs: none - * @details \b Outputs: none - * @param record Pointer to fill conductivity record to check - * @param acidType Type of acid for which values are checked - * @param operation Type of fill operation being checked - * @return TRUE if the record is valid otherwise FALSE - *************************************************************************/ -static BOOL isDDFillConductiviesRecordValid( DD_ACID_BICARB_FILL_COND_VALUES_T* record, - DD_ACID_TYPES_T acidType, DD_FILL_COND_OPS_T operation ) -{ - BOOL status = TRUE; - U16 calcCRC = crc16 ( (U08*)record, sizeof(DD_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 - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, ( U32 )acidType ); - 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 - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, ( U32 )acidType ); - 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; - - default: - // Software fault - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, ( U32 )operation ); - break; - } - - // CRC did not pass so set all values to default - record->acidConduSPerCM = acidSensorCond; - record->bicarbConduSPerCM = bicarbSensorCond; - record->calibrationTime = RECORD_DEFAULT_TIME; - record->crc = crc16 ( (U08*)record, sizeof(DD_ACID_BICARB_FILL_COND_VALUES_T) - sizeof(U16) ); - - // Set the to FALSE since the record is not valid - status = FALSE; - } - - return status; -} - -/*********************************************************************//** - * @brief * The isDDBloodLeakSesnorValid function checks if the blood leak sensor * calibration record is valid. It verifies CRC and updates the record * with default values if invalid. @@ -924,8 +893,8 @@ usageWriteTries = 0; status = TRUE; - enqueueEraseAndWriteSector( NVDATAMGMT_USAGE_INFO_RECORD ); - SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVDATAMGMT_USAGE_INFO_RECORD ].nvEvent, 0, 0 ); + enqueueEraseAndWriteSector( NVM_USAGE_INFO_RECORD ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_USAGE_INFO_RECORD ].nvEvent, 0, 0 ); } else if ( ++usageWriteTries > MAX_NUM_OF_WRITE_TRIES ) { @@ -965,11 +934,11 @@ ddUsageInfoGroup.crc = crc16( (U08*)&ddUsageInfoGroup, sizeof( DD_USAGE_INFO_GROUP_T ) - sizeof( U16 ) ); // Service record has been touched so the entire sector 0 of the EEPROM must be rewritten - enqueueEraseAndWriteSector( NVDATAMGMT_SERVICE_RECORD ); - enqueueEraseAndWriteSector( NVDATAMGMT_USAGE_INFO_RECORD ); + enqueueEraseAndWriteSector( NVM_SERVICE_RECORD ); + enqueueEraseAndWriteSector( NVM_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 ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_USAGE_INFO_RECORD ].nvEvent, 0, 0 ); + SEND_EVENT_WITH_2_U32_DATA( RECORDS_SPECS[ NVM_SERVICE_RECORD ].nvEvent, 0, 0 ); status = TRUE; } @@ -1054,6 +1023,18 @@ isNVDataInvalid |= ( 0 == ddCalibrationRecord.ddCalibrationGroups.concentratePumpsRecord.concentratePumps[ i ].calibrationTime ? TRUE : FALSE ); break; + case GET_CAL_D12_PUMP_RECORD: + nvDataStartPtr = (U08*)&ddCalibrationRecord.ddCalibrationGroups.d12DialysatePumpRecord; + nvDataLength = sizeof( ddCalibrationRecord.ddCalibrationGroups.d12DialysatePumpRecord ); + isNVDataInvalid |= ( 0 == ddCalibrationRecord.ddCalibrationGroups.d12DialysatePumpRecord.calibrationTime ? TRUE : FALSE ); + break; + + case GET_CAL_D48_PUMP_RECORD: + nvDataStartPtr = (U08*)&ddCalibrationRecord.ddCalibrationGroups.d48DialysatePumpRecord; + nvDataLength = sizeof( ddCalibrationRecord.ddCalibrationGroups.d48DialysatePumpRecord ); + isNVDataInvalid |= ( 0 == ddCalibrationRecord.ddCalibrationGroups.d48DialysatePumpRecord.d48DialysatePump.calibrationTime ? TRUE : FALSE ); + break; + case GET_CAL_ACID_CONCENTREATES: nvDataStartPtr = (U08*)&ddCalibrationRecord.ddCalibrationGroups.acidConcentratesRecord; nvDataLength = sizeof( ddCalibrationRecord.ddCalibrationGroups.acidConcentratesRecord ); @@ -1073,35 +1054,18 @@ isNVDataInvalid = ( 0 == ddCalibrationRecord.ddCalibrationGroups.accelerometerSensorCalRecord.calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_FILL_CONDUCTIVITIES_RECORD: - { - DD_FILL_COND_OPS_T fillOps; - - nvDataStartPtr = (U08*)&ddCalibrationRecord.ddCalibrationGroups.concentratesCondCalRecord.fillCondValues; - nvDataLength = sizeof( ddCalibrationRecord.ddCalibrationGroups.concentratesCondCalRecord.fillCondValues ); - - for ( i = 0; i < numOfSnsrs2Check; i++ ) - { - for ( fillOps = FILL_COND_NORMAL_OP; fillOps < NUM_OF_FILL_COND_TEST; fillOps++ ) - { - isNVDataInvalid |= ( 0 == ddCalibrationRecord.ddCalibrationGroups.concentratesCondCalRecord.fillCondValues[ i ][ fillOps ].calibrationTime ? TRUE : FALSE ); - } - } - } - break; - case GET_CAL_BLOOD_LEAK_SENSOR: nvDataStartPtr = (U08*)&ddCalibrationRecord.ddCalibrationGroups.bloodLeakSensorCalRecord; nvDataLength = sizeof( ddCalibrationRecord.ddCalibrationGroups.bloodLeakSensorCalRecord ); isNVDataInvalid = ( 0 == ddCalibrationRecord.ddCalibrationGroups.bloodLeakSensorCalRecord.calibrationTime ? TRUE : FALSE ); break; - case GET_SYS_RECORD: + case GET_SYSTEM_RECORD: nvDataStartPtr = (U08*)&ddSystemGroup.ddSystemRecord; nvDataLength = sizeof( ddSystemGroup.ddSystemRecord ); break; - case GET_SRV_RECORD: + case GET_SERVICE_RECORD: nvDataStartPtr = (U08*)&ddServiceGroup.ddServiceRecord; nvDataLength = sizeof( ddServiceGroup.ddServiceRecord ); break; @@ -1152,27 +1116,27 @@ * The updateNVSelfTestResult function updates the NV data management * self-test result with the provided value. * @details \b Inputs: none - * @details \b Outputs: nvDataMgmtSelfTestResult + * @details \b Outputs: nvmSelfTestResult * @param result Self-test result to be updated * @return none *************************************************************************/ void updateNVSelfTestResult( SELF_TEST_STATUS_T result ) { - nvDataMgmtSelfTestResult = result; + nvmSelfTestResult = result; } /*********************************************************************//** * @brief * The updateNVSelfTestState function updates the NV data management * self-test state with the provided value. * @details \b Inputs: none - * @details \b Outputs: nvDataMgmtSelfTestState + * @details \b Outputs: nvmSelfTestState * @param state Self-test state to be updated * @return none *************************************************************************/ -void updateNVSelfTestState( NVDATAMGMT_SELF_TEST_STATE_T state ) +void updateNVSelfTestState( NVM_SELF_TEST_STATE_T state ) { - nvDataMgmtSelfTestState = state; + nvmSelfTestState = state; } /*********************************************************************//** @@ -1211,27 +1175,27 @@ BOOL testSetNVRecordCRCOverride( U32 job, U16 crc ) { BOOL status = FALSE; - RECORD_JOBS_STATE_T nvJob = (RECORD_JOBS_STATE_T)job; + NVM_RECORD_TYPE_T nvJob = (NVM_RECORD_TYPE_T)job; switch( nvJob ) { - case NVDATAMGMT_CALIBRATION_RECORD: + case NVM_CALIBRATION_RECORD: ddCalibrationRecord.crc = crc; break; - case NVDATAMGMT_SYSTEM_RECORD: + case NVM_SYSTEM_RECORD: ddSystemGroup.ddSystemRecord.crc = crc; break; - case NVDATAMGMT_SERVICE_RECORD: + case NVM_SERVICE_RECORD: ddServiceGroup.ddServiceRecord.crc = crc; break; - case NVDATAMGMT_INSTITUTIONAL_RECORD: + case NVM_INSTITUTIONAL_RECORD: ddInstitutionalGroup.ddInstitutionalRecord.crc = crc; break; - case NVDATAMGMT_USAGE_INFO_RECORD: + case NVM_USAGE_INFO_RECORD: ddUsageInfoGroup.ddUsageInfo.crc = crc; break;