Index: firmware/App/Services/NVRecordsDD.c =================================================================== diff -u -rbe1ff666dbd2ff03342c22c8e50b21d0f9b988a9 -rc0855c6b4beeedc43b020c4e106d8e379de757d9 --- firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision be1ff666dbd2ff03342c22c8e50b21d0f9b988a9) +++ firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision c0855c6b4beeedc43b020c4e106d8e379de757d9) @@ -13,8 +13,8 @@ ***************************************************************************/ #include // For memcpy -#include "Common.h" #include "DDDefs.h" +#include "Messaging.h" #include "NVJobQ.h" #include "NVMessagingDD.h" #include "NVRecordsDD.h" @@ -43,9 +43,6 @@ #define USAGE_INFO_START_ADDRESS ( BANK7_SECTOR3_START_ADDRESS + USAGE_RECORD_OFFSET ) ///< Start address of usage info record in NV memory #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. @@ -66,31 +63,8 @@ #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_CONDUCTIVITY_COEFFICIENT 0.0F ///< Default Conductivity Coefficient Value -// Default Values for Institutional Records -#define DEFAULT_MIN_DIALYSATE_FLOW_MLPM 50 ///< Default value of min dialysate flow in mL/min -#define DEFAULT_MAX_DIALYSATE_FLOW_MLPM 600 ///< Default value of max dialysate flow in mL/min -#define DEFAULT_MIN_DIALYSATE_TEMP_C 35.0F ///< Default value of min dialysate temp in °C -#define DEFAULT_MAX_DIALYSATE_TEMP_C 38.0F ///< Default value of max dialysate temp in °C -#define DEFAULT_MIN_ACID_CONCENTRATE 0 ///< Default value of min acid concentrate -#define DEFAULT_MAX_ACID_CONCENTRATE 2 ///< Default value of max acid concentrate -#define DEFAULT_MIN_BICARB_CARTRIDGE_SIZE_G 0 ///< Default value of min bicarb cartridge size in grams -#define DEFAULT_MAX_BICARB_CARTRIDGE_SIZE_G 5 ///< Default value of max bicarb cartridge size in grams -#define DEFAULT_MIN_SODIUM_MEQL 130 ///< Default value of min sodium in mEq/L -#define DEFAULT_MAX_SODIUM_MEQL 155 ///< Default value of max sodium in mEq/L -#define DEFAULT_MIN_BICARBONATE_MEQL 20 ///< Default value of min bicarbonate in mEq/L -#define DEFAULT_MAX_BICARBONATE_MEQL 40 ///< Default value of max bicarbonate in mEq/L -#define DEFAULT_MAX_RO_REJECTION_RATIO_PCT 90 ///< Max RO rejection ratio in percent. -#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_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 MAX_NUM_OF_WRITE_TRIES 3U ///< Max number of write tries. #define RECORD_BYTE_SIZE(r) (sizeof(r) + sizeof(U16)) ///< Record byte size macro. @@ -110,6 +84,40 @@ #define INSTITUTIONAL_RECORD_PADDING_LENGTH ( RECORD_PADDING_LENGTH( DD_INSTITUTIONAL_RECORD_T, MAX_EEPROM_WRITE_BUFFER_BYTES ) ) #define USAGE_INFO_RECORD_PADDING_LENGTH ( RECORD_PADDING_LENGTH( DD_USAGE_INFO_RECORD_T, MAX_EEPROM_WRITE_BUFFER_BYTES ) ) +/// Institutional Basic parameter properties including data type, range limits and default values. +static const INSTIT_PARAMS_PROPERTIES_T INSTIT_BASIC_PROP[ NUM_OF_INSTIT_BASIC ] = +{ + // type min max default + { CRITICAL_DATA_TYPE_U32, { {.uInt=50}, {.uInt=600}, {.uInt=50} } }, ///< INSTIT_PARAM_DIALYSATE_FLOW + { CRITICAL_DATA_TYPE_F32, { {.sFlt=35.0}, {.sFlt=38.0}, {.sFlt=37.0} } }, ///< INSTIT_PARAM_DIALYSATE_TEMPERATURE + { CRITICAL_DATA_TYPE_U32, { {.uInt=0}, {.uInt=2}, {.uInt=0} } }, ///< INSTIT_PARAM_ACID_CONCENTRATE + { CRITICAL_DATA_TYPE_U32, { {.uInt=0}, {.uInt=5}, {.uInt=0} } }, ///< INSTIT_PARAM_DRY_BICARB_CART_SIZE + { CRITICAL_DATA_TYPE_U32, { {.uInt=130}, {.uInt=155}, {.uInt=137} } }, ///< INSTIT_PARAM_SODIUM + { CRITICAL_DATA_TYPE_U32, { {.uInt=20}, {.uInt=40}, {.uInt=33} } }, ///< INSTIT_PARAM_BICARBONATE + { CRITICAL_DATA_TYPE_U32, { {.uInt=1}, {.uInt=99}, {.uInt=90} } }, ///< INSTIT_PARAM_RO_REJECTION_RATIO_ALRAM +}; + +/// Institutional Advanced parameter properties including data type, range limits and default values. +static const INSTIT_PARAMS_PROPERTIES_T INSTIT_ADVANCED_PROP[ NUM_OF_INSTIT_ADVANCED ] = +{ + // type min max default + { CRITICAL_DATA_TYPE_U32, { {.uInt=1}, {.uInt=5}, {.uInt=3} } }, ///< INSTIT_PARAM_DISINFECTION_FREQUENCY + { CRITICAL_DATA_TYPE_F32, { {.sFlt=1}, {.sFlt=60}, {.sFlt=30} } }, ///< INSTIT_PARAM_DISINFECTION_CYCLE_TIME + { CRITICAL_DATA_TYPE_F32, { {.sFlt=1}, {.sFlt=200}, {.sFlt=200} } }, ///< INSTIT_PARAM_INLET_WATER_COND_LOW_ALARM + { CRITICAL_DATA_TYPE_F32, { {.sFlt=1}, {.sFlt=200}, {.sFlt=50} } }, ///< INSTIT_PARAM_INLET_WATER_COND_HIGH_ALARM + { CRITICAL_DATA_TYPE_F32, { {.sFlt=1}, {.sFlt=20}, {.sFlt=3.43} } }, ///< INSTIT_PARAM_ACID_CONCENTRATE_JUG_SIZE + { CRITICAL_DATA_TYPE_F32, { {.sFlt=1}, {.sFlt=50}, {.sFlt=0} } }, ///< INSTIT_PARAM_LOW_ACID_ALARM + { CRITICAL_DATA_TYPE_F32, { {.sFlt=1}, {.sFlt=50}, {.sFlt=0} } }, ///< INSTIT_PARAM_LOW_BICARB_ALARM + { CRITICAL_DATA_TYPE_U32, { {.uInt=0}, {.uInt=1}, {.uInt=0} } }, ///< INSTIT_PARAM_DIALYSATE_POST_TREAT_DRAIN_OPTION + { CRITICAL_DATA_TYPE_U32, { {.uInt=0}, {.uInt=2}, {.uInt=2} } }, ///< INSTIT_PARAM_BICARB_POST_TREAT_DRAIN_OPTION +}; + +/// Institutional Additional parameter properties including data type, range limits and default values. +static const INSTIT_PARAMS_PROPERTIES_T INSTIT_ADDITIONAL_PROP[ NUM_OF_INSTIT_ADDITIONAL ] = +{ + // type min max default + { CRITICAL_DATA_TYPE_U32, { {.uInt=0}, {.uInt=0}, {.uInt=0} } }, ///< INSTIT_ADDITIONAL_PARAM +}; #pragma pack(push, 1) // ********** DD record structures ********** @@ -128,7 +136,7 @@ DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T bloodLeakSensorCalRecord; ///< DD blood leak detector calibration record } DD_CALIBRATION_RECORD_T; -/// DD calibration records structure +/// DD calibration group structure typedef struct { DD_CALIBRATION_RECORD_T ddCalibrationRecord; ///< DD calibration groups. @@ -152,16 +160,23 @@ U16 crc; ///< CRC for the DG service structure. } DD_SERVICE_GROUP_T; - /// DD institutional record structure typedef struct { + DD_INSTIT_BASIC_RECORD_T basicRecord; ///< DD basic institutional record + DD_INSTIT_ADVANCED_RECORD_T advancedRecord; ///< DD advanced institutional record + DD_INSTIT_ADDITIONAL_RECORD_T additionalRecord; ///< DD additional institutional record +} DD_INSTITUTIONAL_RECORD_T; + +/// DD institutional group structure +typedef struct +{ DD_INSTITUTIONAL_RECORD_T ddInstitutionalRecord; ///< DD institutional record. U08 padding[ INSTITUTIONAL_RECORD_PADDING_LENGTH ]; ///< DD institutional group padding. U16 crc; ///< CRC for the HD institutional structure. } DD_INSTITUTIONAL_GROUP_T; -/// DD usage record structure +/// DD usage group structure typedef struct { DD_USAGE_INFO_RECORD_T ddUsageInfoRecord; ///< DD usage info record. @@ -190,35 +205,6 @@ {USAGE_INFO_START_ADDRESS, sizeof(DD_USAGE_INFO_GROUP_T), (U08*)&ddUsageInfoGroup, (U08*)&ddUsageInfoGroup.crc, DD_EVENT_USAGE_INFO_RECORD_UPDATE }, // NVM_USAGE_INFO_RECORD }; -/// Table showing data type of each institutional record component -const CRITICAL_DATA_TYPES_T institRecDataTypeTable[ NUM_OF_DD_INSTIT_RECORD_TYPE ] = -{ - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_MIN_DIALYSATE_TEMP_C - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_MAX_DIALYSATE_TEMP_C - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MIN_ACID_CONCENTRATE - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MAX_ACID_CONCENTRATE - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MIN_BICARB_CARTRIDGE_SIZE_G - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MAX_BICARB_CARTRIDGE_SIZE_G - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MIN_SODIUM_MEQL - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MAX_SODIUM_MEQL - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MIN_BICARBONATE_MEQL - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MAX_BICARBONATE_MEQL - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_MIN_RO_REJECTION_RATIO_PCT - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_DISINFECTION_FREQUENCY - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_DISINFECTION_CYCLE_TIME - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_MIN_INLET_WATER_COND_ALARM_LIMIT_USPCM - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_MAX_INLET_WATER_COND_ALARM_LIMIT_USPCM - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_ACID_CONCENTRATE_JUG_SIZE_L - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_MIN_ACID_ALARM_LIMIT_PCT - CRITICAL_DATA_TYPE_F32, // DD_INSTIT_MIN_BICARB_ALARM_LIMIT_PCT - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_POST_TREAT_DRAIN_OPTION - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_POST_TREAT_DRY_BICARB_OPTION - CRITICAL_DATA_TYPE_U32, // DD_INSTIT_CALIBRATION_TIME - CRITICAL_DATA_TYPE_U32 // DD_INSTIT_CRC -}; - 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. @@ -231,21 +217,28 @@ static NVM_SELF_TEST_STATE_T handleSelfTestCheckCRC( void ); // Record check helper functions -static BOOL isPolynomialRecordValid( POLYNOMIAL_CAL_PAYLOAD_T* record ); +static BOOL isLinearRecordValid( LINEAR_CAL_PAYLOAD_T* record ); +static BOOL isDDSerialNumberValid( void ); static BOOL isDDSystemRecordValid( void ); static BOOL isDDServiceRecordValid( void ); static BOOL isDDInstitutionalRecordValid( void ); -static BOOL isDDUsageRecordValid( void ); +static BOOL isDDInstitBasicRecordValid( void ); +static BOOL isDDInstitAdvancedRecordValid( void ); +static BOOL isDDInstitAdditionalRecordValid( 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 isDDBloodLeakSesnorValid( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* record ); +static BOOL isDDBloodLeakSensorValid( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* record ); +static BOOL isDDConductivitySensorValid( void ); +static BOOL isDDUsageRecordValid( void ); static void initDDSystemRecord( void ); static void initDDServiceRecord( void ); -static void initDDInstitutionalRecord( void ); +static void initDDInstitBasicRecord( void ); +static void initDDInstitAdvancedRecord( void ); +static void initDDInstitAdditionalRecord( void ); static void initDDUsageRecord( void ); static void updateRecordPadding( NVM_RECORD_TYPE_T recType ); @@ -348,67 +341,102 @@ * @brief * The handleSelfTestCheckCRC function checks the CRC of records and * 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. + * It updates the self-test result and schedules rewrite for invalid records. + * @details \b Alarms: ALARM_ID_DD_NVM_INVALID_SERIAL_NUMBER invalid serial number + * ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC invalid system record crc + * ALARM_ID_DD_NVM_INVALID_SERVICE_RECORD_CRC invalid service record crc, + * ALARM_ID_DD_NVM_INVALID_CALIBRATION_RECORD_CRC invalid cal record crc, + * ALARM_ID_DD_NVM_INVALID_INSTIT_BASIC_RECORD_CRC invalid basic instit crc, + * ALARM_ID_DD_NVM_INVALID_INSTIT_ADVANCED_RECORD_CRC invalid advanced instit crc + * ALARM_ID_DD_NVM_INVALID_INSTIT_ADDITIONAL_RECORD_CRC invalid additional instit crc, + * ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC invalid institutional crc + * ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC invalid usage record crc * @details \b Inputs: nvmSelfTestResult * @details \b Outputs: nvmSelfTestResult * @return state next self-test state *************************************************************************/ static NVM_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) { NVM_SELF_TEST_STATE_T state = NVM_SELF_TEST_STATE_COMPLETE; - BOOL hasSystemRecordPassed = TRUE; - BOOL hasServiceRecordPassed = TRUE; - BOOL haveCalGroupsPassed = TRUE; - BOOL hasInstitutionalRecordPassed = TRUE; - BOOL hasUsageRecordPassed = TRUE; + BOOL hasSerialNumberPassed = TRUE; + BOOL hasSystemRecordPassed = TRUE; + BOOL hasServiceRecordPassed = TRUE; + BOOL hasCalRecordPassed = TRUE; + BOOL hasConductivityCalRecordPassed = TRUE; + BOOL hasInstitBasicPassed = TRUE; + BOOL hasInstitAdvancedPassed = TRUE; + BOOL hasInstitAdditionalPassed = TRUE; + BOOL hasInstitutionalRecordPassed = TRUE; + BOOL hasUsageRecordPassed = TRUE; updateRecordReadStatus( NVM_RECORDS_CRC_CHECKED ); // If any of the records did not pass, they should be filled // with benign values. After that, schedule a write to sector // to re-write the records with the benign values - // Validate system record - hasSystemRecordPassed = isDDSystemRecordValid(); + // Validate the Records + hasSerialNumberPassed = isDDSerialNumberValid(); + hasSystemRecordPassed = isDDSystemRecordValid(); + hasServiceRecordPassed = isDDServiceRecordValid(); + hasConductivityCalRecordPassed = isDDConductivitySensorValid(); + hasCalRecordPassed = isDDCalibrationRecordValid(); + hasInstitBasicPassed = isDDInstitBasicRecordValid(); + hasInstitAdvancedPassed = isDDInstitAdvancedRecordValid(); + hasInstitAdditionalPassed = isDDInstitAdditionalRecordValid(); + hasInstitutionalRecordPassed = isDDInstitutionalRecordValid(); + hasUsageRecordPassed = isDDUsageRecordValid(); + + // Activate alarm for the records that have failed + if ( FALSE == hasSerialNumberPassed ) + { + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SERIAL_NUMBER ); + } + if ( FALSE == hasSystemRecordPassed ) { - enqueueEraseAndWriteSector ( NVM_SYSTEM_RECORD ); - sendNVEvent( NVM_SYSTEM_RECORD, 0, 0 ); + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ); } - // Validate service and calibration records - hasServiceRecordPassed = isDDServiceRecordValid(); - haveCalGroupsPassed = isDDCalibrationRecordValid(); - if ( ( FALSE == hasServiceRecordPassed ) || ( FALSE == haveCalGroupsPassed ) ) + if ( FALSE == hasServiceRecordPassed ) { - enqueueEraseAndWriteSector ( NVM_SERVICE_RECORD ); - sendNVEvent( NVM_SERVICE_RECORD, 0, 0 ); - sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SERVICE_RECORD_CRC ); + } - startNewCalRecordAvailableTimer(); - setNewCalibrationRecordAvailable( TRUE ); + if ( ( FALSE == hasConductivityCalRecordPassed ) || + ( FALSE == hasCalRecordPassed ) ) + { + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_CALIBRATION_RECORD_CRC ); } - // Validate institutional record - hasInstitutionalRecordPassed = isDDInstitutionalRecordValid(); + if ( FALSE == hasInstitBasicPassed ) + { + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_INSTIT_BASIC_RECORD_CRC ); + } + + if ( FALSE == hasInstitAdvancedPassed ) + { + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_INSTIT_ADVANCED_RECORD_CRC ); + } + + if ( FALSE == hasInstitAdditionalPassed ) + { + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_INSTIT_ADDITIONAL_RECORD_CRC ); + } + if ( FALSE == hasInstitutionalRecordPassed ) { - enqueueEraseAndWriteSector ( NVM_INSTITUTIONAL_RECORD ); - sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC ); } - // Validate usage info record - hasUsageRecordPassed = isDDUsageRecordValid(); if ( FALSE == hasUsageRecordPassed ) { - enqueueEraseAndWriteSector ( NVM_USAGE_INFO_RECORD ); - sendNVEvent( NVM_USAGE_INFO_RECORD, 0, 0 ); + activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC ); } // Check if the records' entire CRCs as well as the individual CRCs passed if ( ( TRUE == hasSystemRecordPassed ) && ( TRUE == hasServiceRecordPassed ) && - ( TRUE == haveCalGroupsPassed ) && ( TRUE == hasInstitutionalRecordPassed ) && + ( TRUE == hasCalRecordPassed ) && ( TRUE == hasInstitutionalRecordPassed ) && ( TRUE == hasUsageRecordPassed ) ) { nvmSelfTestResult = SELF_TEST_STATUS_PASSED; @@ -423,43 +451,40 @@ /*********************************************************************//** * @brief - * The benignPolynomialCalRecord function fills the provided polynomial + * The benignLinearCalRecord function fills the provided linear * calibration record with benign default values and updates its CRC. * @details \b Inputs: none * @details \b Outputs: none - * @param record Pointer to the polynomial calibration record to update + * @param record Pointer to the linear calibration record to update * @return none *************************************************************************/ -void benignPolynomialCalRecord( POLYNOMIAL_CAL_PAYLOAD_T* record ) +void benignLinearCalRecord( LINEAR_CAL_PAYLOAD_T* record ) { - record->fourthOrderCoeff = RECORD_FOURTH_ORDER_COEFF; - record->thirdOrderCoeff = RECORD_THIRD_ORDER_COEFF; - record->secondOrderCoeff = RECORD_SECOND_ORDER_COEFF; record->gain = RECORD_DEFAULT_GAIN; record->offset = RECORD_DEFAULT_OFFSET; record->calibrationTime = RECORD_DEFAULT_TIME; - record->crc = crc16 ( (U08*)record, sizeof( POLYNOMIAL_CAL_PAYLOAD_T ) - sizeof( U16 ) ); + record->crc = crc16 ( (U08*)record, sizeof( LINEAR_CAL_PAYLOAD_T ) - sizeof( U16 ) ); } /*********************************************************************//** * @brief - * The isPolynomialRecordValid function checks if the polynomial record + * The isLinearRecordValid function checks if the linear record * is valid by comparing calculated CRC with stored CRC. If invalid, * it updates the record with benign values. * @details \b Inputs: none * @details \b Outputs: none - * @param record Pointer to the polynomial calibration record to check + * @param record Pointer to the linear calibration record to check * @return TRUE if the records' data is valid otherwise FALSE *************************************************************************/ -static BOOL isPolynomialRecordValid( POLYNOMIAL_CAL_PAYLOAD_T* record ) +static BOOL isLinearRecordValid( LINEAR_CAL_PAYLOAD_T* record ) { BOOL status = TRUE; - U16 calcCRC = crc16 ( (U08*)record, sizeof( POLYNOMIAL_CAL_PAYLOAD_T ) - sizeof( U16 ) ); + U16 calcCRC = crc16 ( (U08*)record, sizeof( LINEAR_CAL_PAYLOAD_T ) - sizeof( U16 ) ); U16 recordCRC = record->crc; if ( calcCRC != recordCRC ) { - benignPolynomialCalRecord( record ); + benignLinearCalRecord( record ); // Set status to FALSE since the record is not valid status = FALSE; @@ -470,17 +495,34 @@ /*********************************************************************//** * @brief + * The isDDSerialNumberValid function checks the validity of the DD + * serial number. + * @details \b Inputs: ddSystemGroup.ddSystemRecord + * @details \b Outputs: none + * @return TRUE if the DD serial number valid otherwise FALSE + *************************************************************************/ +static BOOL isDDSerialNumberValid( void ) +{ + BOOL status = TRUE; + + // Verify the serial number from the system record + if ( RECORD_DEFAULT_CHARACTER == ddSystemGroup.ddSystemRecord.topLevelSN[ 0 ] ) + { + status = FALSE; + } + + return status; +} + +/*********************************************************************//** + * @brief * The isDDSystemRecordValid function checks the validity of the DD * system record. It verifies CRC and updates the record with default * values if invalid. - * @details \b Alarms: ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC if CRC - * check fails, ALARM_ID_DD_NVM_INVALID_SERIAL_NUMBER if serial number - * is not initialized * @details \b Inputs: ddSystemGroup.ddSystemRecord * @details \b Outputs: ddSystemGroup.ddSystemRecord, ddSystemGroup.crc * @return TRUE if the DD system record is valid otherwise FALSE *************************************************************************/ - static BOOL isDDSystemRecordValid( void ) { BOOL status = TRUE; @@ -498,18 +540,14 @@ // Recalculate the CRC with the default values updateRecordCRC( NVM_SYSTEM_RECORD ); - status = FALSE; + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_SYSTEM_RECORD ); - activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ); + // Indicate that the record was updated + sendNVEvent( NVM_SYSTEM_RECORD, 0, 0 ); + + status = FALSE; } - else - { - // Verify the serial number from the system record - if ( RECORD_DEFAULT_CHARACTER == ddSystemGroup.ddSystemRecord.topLevelSN[ 0 ] ) - { - activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SERIAL_NUMBER ); - } - } return status; } @@ -519,8 +557,6 @@ * The isDDServiceRecordValid function checks the validity of the DD * service record. It verifies CRC and updates the record with default * values if invalid. - * @details \b Alarms: ALARM_ID_DD_NVM_INVALID_SERVICE_RECORD_CRC if CRC - * check fails * @details \b Inputs: ddServiceGroup.ddServiceRecord * @details \b Outputs: ddServiceGroup.ddServiceRecord, * ddServiceGroup.crc @@ -543,10 +579,13 @@ // Recalculate the CRC with the default values updateRecordCRC( NVM_SERVICE_RECORD ); - status = FALSE; + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_SERVICE_RECORD ); - // Service record failure - activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SERVICE_RECORD_CRC ); + // Indicate that the record was updated + sendNVEvent( NVM_SERVICE_RECORD, 0, 0 ); + + status = FALSE; } return status; @@ -557,68 +596,141 @@ * 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; + U16 calcCRC = crc16( (U08*)&ddInstitutionalGroup.crc, + sizeof( DD_INSTITUTIONAL_GROUP_T ) - sizeof( U16 ) ); + U16 recordCRC = ddInstitutionalGroup.crc; + //Check if the group crc is valid if ( calcCRC != recordCRC ) { - // CRC did not pass so set all values to default - initDDInstitutionalRecord(); - // Initialize the padding updateRecordPadding( NVM_INSTITUTIONAL_RECORD ); // Recalculate the CRC with the default values updateRecordCRC( NVM_INSTITUTIONAL_RECORD ); - status = FALSE; + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_INSTITUTIONAL_RECORD ); - // Institutional record failure is also considered as RTC RAM failure - activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC ); + // Indicate that the record was updated + sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); + + status = FALSE; } return status; } /*********************************************************************//** * @brief - * The isDDUsageRecordValid function checks the validity of the DD - * usage information record. It verifies CRC and updates the record + * The isDDInstitBasicRecordValid function checks the validity of the DD + * basic institutional record. It verifies CRC and updates the record * with default values if invalid. - * @details \b Alarms: ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC if CRC - * check fails - * @details \b Inputs: ddUsageInfoGroup - * @details \b Outputs: ddUsageInfoGroup - * @return TRUE if the DD usage record is valid otherwise FALSE + * @details \b Inputs: ddInstitutionalGroup + * @details \b Outputs: ddInstitutionalGroup + * @return TRUE if the DD Basic Institutional record is valid otherwise FALSE *************************************************************************/ -static BOOL isDDUsageRecordValid( void ) +static BOOL isDDInstitBasicRecordValid( void ) { BOOL status = TRUE; - U16 calcCRC = crc16( (U08*)&ddUsageInfoGroup.ddUsageInfoRecord, sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); - U16 recordCRC = ddUsageInfoGroup.ddUsageInfoRecord.crc; + U16 calcCRC = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.basicRecord, + sizeof( DD_INSTIT_BASIC_RECORD_T ) - sizeof( U16 ) ); + U16 recordCRC = ddInstitutionalGroup.ddInstitutionalRecord.basicRecord.crc; if ( calcCRC != recordCRC ) { // CRC did not pass so set all values to default - initDDUsageRecord(); + initDDInstitBasicRecord(); - // Initialize the padding - updateRecordPadding( NVM_USAGE_INFO_RECORD ); + // Recalculate the CRC with the default values + updateRecordCRC( NVM_INSTITUTIONAL_RECORD ); + // Write the record to flash + enqueueEraseAndWriteSector( NVM_INSTITUTIONAL_RECORD ); + + // Indicate that the record was updated + sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); + + status = FALSE; + } + + return status; +} + +/*********************************************************************//** + * @brief + * The isDDInstitAdvancedRecordValid function checks the validity of the DD + * advanced institutional record. It verifies CRC and updates the record + * with default values if invalid. + * @details \b Inputs: ddInstitutionalGroup + * @details \b Outputs: ddInstitutionalGroup + * @return TRUE if the DD Advanced Institutional record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDDInstitAdvancedRecordValid( void ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord, + sizeof( DD_INSTIT_ADVANCED_RECORD_T ) - sizeof( U16 ) ); + U16 recordCRC = ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord.crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + initDDInstitAdvancedRecord(); + // Recalculate the CRC with the default values - updateRecordCRC( NVM_USAGE_INFO_RECORD ); + updateRecordCRC( NVM_INSTITUTIONAL_RECORD ); + + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_INSTITUTIONAL_RECORD ); + + // Indicate that the record was updated + sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); + status = FALSE; + } - activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC ); + return status; +} + +/*********************************************************************//** + * @brief + * The isDDInstitAdditionalRecordValid function checks the validity of the DD + * addtional institutional record. It verifies CRC and updates the record + * with default values if invalid. + * @details \b Inputs: ddInstitutionalGroup + * @details \b Outputs: ddInstitutionalGroup + * @return TRUE if the DD Addtional Institutional record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDDInstitAdditionalRecordValid( void ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord, + sizeof( DD_INSTIT_ADDITIONAL_RECORD_T ) - sizeof( U16 ) ); + U16 recordCRC = ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord.crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + initDDInstitAdditionalRecord(); + + // Recalculate the CRC with the default values + updateRecordCRC( NVM_INSTITUTIONAL_RECORD ); + + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_INSTITUTIONAL_RECORD ); + + // Indicate that the record was updated + sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); + + status = FALSE; } return status; @@ -638,47 +750,47 @@ static BOOL isDDCalibrationRecordValid( void ) { U32 i; - POLYNOMIAL_CAL_PAYLOAD_T* record; + LINEAR_CAL_PAYLOAD_T* record; BOOL isHardwareRecordValid = TRUE; BOOL isCalRecordValid = TRUE; U16 recordCRC = crc16 ( (U08*)&ddCalibrationGroup, sizeof( DD_CALIBRATION_GROUP_T ) - sizeof( U16 ) ); // Create a benign polynomial calibration record. This record is used to // clear the reserved calibration record. The reserved spaces are not used // but this will prevent those records to be nan or a random number. - POLYNOMIAL_CAL_PAYLOAD_T tempRecord; + LINEAR_CAL_PAYLOAD_T tempRecord; - benignPolynomialCalRecord( &tempRecord ); + benignLinearCalRecord( &tempRecord ); // Get the calibration record of the hardware (i.e. pressure sensor) DD_PRES_SENSORS_CAL_RECORD_T* pressure = &ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord; // The ones that are an array, are looped through for ( i = 0; i < NUM_OF_PRESSURE_SENSORS; i++ ) { // Get calibration payload and assign it to a pointer - record = (POLYNOMIAL_CAL_PAYLOAD_T*)&pressure->pressureSensors[ i ]; + 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 - isHardwareRecordValid = isPolynomialRecordValid( record ); + isHardwareRecordValid = isLinearRecordValid( record ); isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; } DD_TEMP_SENSORS_CAL_RECORD_T* temperature = &ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord; for ( i = 0; i < NUM_OF_TEMPERATURE_SENSORS; i++ ) { - record = (POLYNOMIAL_CAL_PAYLOAD_T*)&temperature->tempSensors[ i ]; - isHardwareRecordValid = isPolynomialRecordValid( record ); + record = (LINEAR_CAL_PAYLOAD_T*)&temperature->tempSensors[ i ]; + isHardwareRecordValid = isLinearRecordValid( record ); isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; } DD_CONC_PUMPS_CAL_RECORD_T* concPump = &ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord; for ( i = 0; i < NUM_OF_CONCENTRATE_PUMPS; i++ ) { - record = (POLYNOMIAL_CAL_PAYLOAD_T*)&concPump->concentratePumps[ i ]; - isHardwareRecordValid = isPolynomialRecordValid( record ); + record = (LINEAR_CAL_PAYLOAD_T*)&concPump->concentratePumps[ i ]; + isHardwareRecordValid = isLinearRecordValid( record ); isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; } @@ -687,8 +799,8 @@ isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; DD_D48_DIALYSATE_PUMP_RECORD_T* d48Pump = &ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord; - record = (POLYNOMIAL_CAL_PAYLOAD_T*)&d48Pump->d48DialysatePump; - isHardwareRecordValid = isPolynomialRecordValid( record ); + record = (LINEAR_CAL_PAYLOAD_T*)&d48Pump->d48DialysatePump; + isHardwareRecordValid = isLinearRecordValid( record ); isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; DD_ACID_CONCENTRATES_RECORD_T* acidConc = &ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord; @@ -710,22 +822,28 @@ isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* bloodLeak = &ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord; - isHardwareRecordValid = isDDBloodLeakSesnorValid( bloodLeak ); + isHardwareRecordValid = isDDBloodLeakSensorValid( bloodLeak ); isCalRecordValid = ( isCalRecordValid == FALSE ) ? FALSE : isHardwareRecordValid; // If the sub groups failed, they are all updated to their benign values // so the main CRC of the calibration group is calculated again if ( ( FALSE == isCalRecordValid ) || ( recordCRC != ddCalibrationGroup.crc ) ) { - isCalRecordValid = FALSE; + isCalRecordValid = FALSE; // Initialize the padding - updateRecordPadding( NVM_USAGE_INFO_RECORD ); + updateRecordPadding( NVM_CALIBRATION_RECORD ); // Recalculate the CRC - ddCalibrationGroup.crc = crc16 ( (U08*)&ddCalibrationGroup, sizeof( DD_CALIBRATION_GROUP_T ) - sizeof( U16 ) ); + updateRecordCRC( NVM_CALIBRATION_RECORD ); - activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_CALIBRATION_RECORD_CRC ); + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_CALIBRATION_RECORD ); + + // Indicate that the record was updated + sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); + startNewCalRecordAvailableTimer(); + setNewCalibrationRecordAvailable( TRUE ); } return isCalRecordValid; @@ -855,15 +973,15 @@ /*********************************************************************//** * @brief - * The isDDBloodLeakSesnorValid function checks if the blood leak sensor + * The isDDBloodLeakSensorValid function checks if the blood leak sensor * calibration 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 blood leak sensor calibration record to check * @return TRUE if the record is valid otherwise FALSE *************************************************************************/ -static BOOL isDDBloodLeakSesnorValid( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* record ) +static BOOL isDDBloodLeakSensorValid( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* record ) { BOOL status = TRUE; U16 calcCRC = crc16 ( (U08*)record, sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ) - sizeof( U16 ) ); @@ -884,6 +1002,102 @@ /*********************************************************************//** * @brief + * The isDDConductivitySesnorValid function checks if the conductivity sensor + * calibration 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 conductivity sensor calibration record to check + * @return TRUE if the record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDDConductivitySensorValid( void ) +{ + BOOL status = TRUE; + BOOL isRecordValid = TRUE; + U08 sensorIdx; + U16 calcCRC; + CONDUCTIVITY_COEFFICIENTS_T record; + + for ( sensorIdx = 0; sensorIdx < NUM_OF_CONDUCTIVITY_SENSORS; sensorIdx++ ) + { + // Get the Conductivity Sensor Calibration Data + record = getConductivityCalibrationData( sensorIdx ); + + // Calculate the CRC + calcCRC = crc16( (U08*)&record, sizeof( CONDUCTIVITY_COEFFICIENTS_T ) - sizeof( U16 ) ); + + // Check if calculated CRC matches the stored CRC + if ( calcCRC != record.crc ) + { + // CRC did not match, update the record to benign values. + record.K_high = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.alpha_high = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.eta_high = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.zeta_high = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.K_low = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.alpha_low = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.eta_low = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.zeta_low = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.beta = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.delta = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.reserved1 = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.reserved2 = DEFAULT_CONDUCTIVITY_COEFFICIENT; + record.calibrationTime = RECORD_DEFAULT_TIME; + record.crc = crc16 ( (U08*)&record, + sizeof( CONDUCTIVITY_COEFFICIENTS_T ) - sizeof( U16 ) ); + + // Write to sensor's flash (not DD's NVM ) + setConductivityCalibrationData( (CONDUCTIVITY_SENSORS_T)sensorIdx, record ); + + // Set flag to FALSE since the record is not valid + isRecordValid = FALSE; + status = ( status == FALSE ) ? FALSE : isRecordValid; + } + } + + 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. + * @details \b Inputs: ddUsageInfoGroup + * @details \b Outputs: ddUsageInfoGroup + * @return TRUE if the DD usage record is valid otherwise FALSE + *************************************************************************/ +static BOOL isDDUsageRecordValid( void ) +{ + BOOL status = TRUE; + U16 calcCRC = crc16( (U08*)&ddUsageInfoGroup.ddUsageInfoRecord, sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); + U16 recordCRC = ddUsageInfoGroup.ddUsageInfoRecord.crc; + + if ( calcCRC != recordCRC ) + { + // CRC did not pass so set all values to default + initDDUsageRecord(); + + // Initialize the padding + updateRecordPadding( NVM_USAGE_INFO_RECORD ); + + // Recalculate the CRC with the default values + updateRecordCRC( NVM_USAGE_INFO_RECORD ); + + // Write the record to flash + enqueueEraseAndWriteSector ( NVM_USAGE_INFO_RECORD ); + + // Indicate that the record was updated + sendNVEvent( NVM_USAGE_INFO_RECORD, 0, 0 ); + + status = FALSE; + } + + return status; +} + +/*********************************************************************//** + * @brief * The initDDSystemRecord function initializes the DD system record * with default values. It resets configuration fields and fills * string fields with default characters. @@ -912,7 +1126,7 @@ *************************************************************************/ static void initDDServiceRecord( void ) { - ddServiceGroup.ddServiceRecord.isHDFOnlineFluid = FALSE; + ddServiceGroup.ddServiceRecord.isHDFOnlineFluidAvailable = FALSE; ddServiceGroup.ddServiceRecord.waterRecovery = 0; ddServiceGroup.ddServiceRecord.serviceLoc = 0; ddServiceGroup.ddServiceRecord.lastServiceEpochDate = 0; @@ -922,42 +1136,75 @@ /*********************************************************************//** * @brief - * The initDDInstitutionalRecord function initializes the DD - * institutional record with default values. It sets configuration - * limits, alarm thresholds, and treatment options to default values. + * The initDDInstitBasicRecord function initializes the DD basic + * institutional record with default values. * @details \b Inputs: none * @details \b Outputs: ddInstitutionalGroup.ddInstitutionalRecord * @return none *************************************************************************/ -static void initDDInstitutionalRecord( void ) +static void initDDInstitBasicRecord( void ) { - ddInstitutionalGroup.ddInstitutionalRecord.minDialysateFlowMLPM = DEFAULT_MIN_DIALYSATE_FLOW_MLPM; - ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateFlowMLPM = DEFAULT_MAX_DIALYSATE_FLOW_MLPM; - ddInstitutionalGroup.ddInstitutionalRecord.minDialysateTempC = DEFAULT_MIN_DIALYSATE_TEMP_C; - ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateTempC = DEFAULT_MAX_DIALYSATE_TEMP_C; - ddInstitutionalGroup.ddInstitutionalRecord.minAcidConcentrate = DEFAULT_MIN_ACID_CONCENTRATE; - ddInstitutionalGroup.ddInstitutionalRecord.maxAcidConcentrate = DEFAULT_MAX_ACID_CONCENTRATE; - ddInstitutionalGroup.ddInstitutionalRecord.minBicarbCartridgeSizeG = DEFAULT_MIN_BICARB_CARTRIDGE_SIZE_G; - ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbCartridgeSizeG = DEFAULT_MAX_BICARB_CARTRIDGE_SIZE_G; - ddInstitutionalGroup.ddInstitutionalRecord.minSodiumMEQL = DEFAULT_MIN_SODIUM_MEQL; - ddInstitutionalGroup.ddInstitutionalRecord.maxSodiumMEQL = DEFAULT_MAX_SODIUM_MEQL; - ddInstitutionalGroup.ddInstitutionalRecord.minBicarbonateMEQL = DEFAULT_MIN_BICARBONATE_MEQL; - ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbonateMEQL = DEFAULT_MAX_BICARBONATE_MEQL; - 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(); + U32 i; + + for ( i = FIRST_INSTIT_BASIC_PARAM; i < NUM_OF_INSTIT_BASIC; i++ ) + { + ddInstitutionalGroup.ddInstitutionalRecord.basicRecord.param[ i ].min = INSTIT_BASIC_PROP[ i ].data.min; + ddInstitutionalGroup.ddInstitutionalRecord.basicRecord.param[ i ].max = INSTIT_BASIC_PROP[ i ].data.max; + ddInstitutionalGroup.ddInstitutionalRecord.basicRecord.param[ i ].def = INSTIT_BASIC_PROP[ i ].data.def; + } + + ddInstitutionalGroup.ddInstitutionalRecord.basicRecord.crc = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.basicRecord, + sizeof( DD_INSTIT_BASIC_RECORD_T ) - sizeof( U16 ) ); } /*********************************************************************//** * @brief + * The initDDInstitAdvancedRecord function initializes the DD advanced + * institutional record with default values. + * @details \b Inputs: none + * @details \b Outputs: ddInstitutionalGroup.ddInstitutionalRecord + * @return none + *************************************************************************/ +static void initDDInstitAdvancedRecord( void ) +{ + U32 i; + + for ( i = FIRST_INSTIT_ADVANCED_PARAM; i < NUM_OF_INSTIT_ADVANCED; i++ ) + { + ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord.param[ i ].min = INSTIT_ADVANCED_PROP[ i ].data.min; + ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord.param[ i ].max = INSTIT_ADVANCED_PROP[ i ].data.max; + ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord.param[ i ].def = INSTIT_ADVANCED_PROP[ i ].data.def; + } + + ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord.crc = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord, + sizeof( DD_INSTIT_ADVANCED_RECORD_T ) - sizeof( U16 ) ); +} + +/*********************************************************************//** + * @brief + * The initDDInstitAdditionalRecord function initializes the DD additional + * institutional record with default values. + * @details \b Inputs: none + * @details \b Outputs: ddInstitutionalGroup.ddInstitutionalRecord + * @return none + *************************************************************************/ +static void initDDInstitAdditionalRecord( void ) +{ + U32 i; + + for ( i = FIRST_INSTIT_ADDITIONAL_PARAM; i < NUM_OF_INSTIT_ADDITIONAL; i++ ) + { + ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord.param[ i ].min = INSTIT_ADDITIONAL_PROP[ i ].data.min; + ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord.param[ i ].max = INSTIT_ADDITIONAL_PROP[ i ].data.max; + ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord.param[ i ].def = INSTIT_ADDITIONAL_PROP[ i ].data.def; + } + + ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord.crc = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord, + sizeof( DD_INSTIT_ADDITIONAL_RECORD_T ) - sizeof( U16 ) ); +} + +/*********************************************************************//** + * @brief * The initDDUsageRecord function initializes the DD usage record with * default values. It resets usage information, counters, and * maintenance timestamps. @@ -995,46 +1242,36 @@ switch ( recType ) { case NVM_SYSTEM_RECORD: + for ( i = 0; i < SYSTEM_RECORD_PADDING_LENGTH; i++ ) { - for ( i = 0; i < SYSTEM_RECORD_PADDING_LENGTH; i++ ) - { - ddSystemGroup.padding[ i ] = 0; - } + ddSystemGroup.padding[ i ] = 0; } break; case NVM_SERVICE_RECORD: - { for ( i = 0; i < SERVICE_RECORD_PADDING_LENGTH; i++ ) { ddServiceGroup.padding[ i ] = 0; } - } break; case NVM_CALIBRATION_RECORD: - { for ( i = 0; i < CALIBRATION_RECORD_PADDING_LENGTH; i++ ) { ddCalibrationGroup.padding[ i ] = 0; } - } break; case NVM_INSTITUTIONAL_RECORD: - { for ( i = 0; i < INSTITUTIONAL_RECORD_PADDING_LENGTH; i++ ) { ddInstitutionalGroup.padding[ i ] = 0; } - } break; case NVM_USAGE_INFO_RECORD: - { for ( i = 0; i < USAGE_INFO_RECORD_PADDING_LENGTH; i++ ) { ddUsageInfoGroup.padding[ i ] = 0; } - } break; default: @@ -1063,45 +1300,35 @@ switch ( recType ) { case NVM_SYSTEM_RECORD: - { ddSystemGroup.ddSystemRecord.crc = crc16 ( (U08*)&ddSystemGroup.ddSystemRecord, sizeof( DD_SYSTEM_RECORD_T ) - sizeof( U16 ) ); ddSystemGroup.crc = crc16 ( (U08*)&ddSystemGroup, sizeof( DD_SYSTEM_GROUP_T ) - sizeof( U16 ) ); - } - break; + break; + case NVM_SERVICE_RECORD: - { ddServiceGroup.ddServiceRecord.crc = crc16 ( (U08*)&ddServiceGroup.ddServiceRecord, sizeof( DD_SERVICE_RECORD_T ) - sizeof( U16 ) ); ddServiceGroup.crc = crc16 ( (U08*)&ddServiceGroup, sizeof( DD_SERVICE_GROUP_T ) - sizeof( U16 ) ); - } break; + case NVM_CALIBRATION_RECORD: - { ddCalibrationGroup.crc = crc16 ( (U08*)&ddCalibrationGroup, sizeof( DD_CALIBRATION_GROUP_T ) - sizeof( U16 ) ); - } - break; + break; case NVM_INSTITUTIONAL_RECORD: - { - 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 ) ); - } - break; + ddInstitutionalGroup.crc = crc16 ( (U08*)&ddInstitutionalGroup, + sizeof( DD_INSTITUTIONAL_GROUP_T ) - sizeof( U16 ) ); + break; case NVM_USAGE_INFO_RECORD: - { ddUsageInfoGroup.ddUsageInfoRecord.crc = crc16 ( (U08*)&ddUsageInfoGroup.ddUsageInfoRecord, sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); ddUsageInfoGroup.crc = crc16 ( (U08*)&ddUsageInfoGroup, sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); - } - break; + break; default: break; @@ -1217,7 +1444,7 @@ *************************************************************************/ U32 getMinRORejectionRatioInInstitRecordPCT( void ) { - return ddInstitutionalGroup.ddInstitutionalRecord.minRORejectionRatioPCT; +// return ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord[ INSTIT_PARAM_RO_REJECTION_RATIO_ALRAM ].min; } /*********************************************************************//** @@ -1233,185 +1460,11 @@ F32 getMinInletWaterConductivityLimitInstitRecordUSPCM( void ) { - return ddInstitutionalGroup.ddInstitutionalRecord.minInletWaterCondAlarmLimitUSPCM; +// return ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord[ INSTIT_PARAM_INLET_WATER_COND_LOW_ALARM ].min; } /*********************************************************************//** * @brief - * The getPressureSensorCalRecord function gets the calibration record - * of the specified pressure sensor. - * @details \b Inputs: ddCalibrationGroup.ddCalibrationRecord - * @details \b Outputs: none - * @param snsrIdx Pressure sensor index - * @return record corresponding pressure sensor calibration record - *************************************************************************/ -POLYNOMIAL_CAL_PAYLOAD_T getPressureSensorCalRecord( U08 snsrIdx ) -{ - POLYNOMIAL_CAL_PAYLOAD_T record; - benignPolynomialCalRecord( &record ); - - if ( snsrIdx < NUM_OF_PRESSURE_SENSORS ) - { - record = ( ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord.pressureSensors[ snsrIdx ] ); - } - - return record; -} - -/*********************************************************************//** - * @brief - * The getTemperatureSensorCalRecord function gets the calibration - * record of the specified temperature sensor. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord - * @details \b Outputs: none - * @param snsrIdx Temperature sensor index - * @return record corresponding temperature sensor calibration record - *************************************************************************/ -POLYNOMIAL_CAL_PAYLOAD_T getTemperatureSensorCalRecord( U08 snsrIdx ) -{ - POLYNOMIAL_CAL_PAYLOAD_T record; - benignPolynomialCalRecord( &record ); - - if ( snsrIdx < NUM_OF_TEMPERATURE_SENSORS ) - { - record = ( ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord.tempSensors[ snsrIdx ] ); - } - - return record; -} - -/*********************************************************************//** - * @brief - * The getConcPumpCalRecord function gets the calibration record of the - * specified concentrate pump. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord - * @details \b Outputs: none - * @param pumpIdx Concentrate pump index - * @return record corresponding concentrate pump calibration record - *************************************************************************/ -POLYNOMIAL_CAL_PAYLOAD_T getConcPumpCalRecord( U08 pumpIdx ) -{ - POLYNOMIAL_CAL_PAYLOAD_T record; - benignPolynomialCalRecord( &record ); - - if ( pumpIdx < NUM_OF_CONCENTRATE_PUMPS ) - { - record = ( ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord.concentratePumps[ pumpIdx ] ); - } - - return record; -} - -/*********************************************************************//** - * @brief - * The getD12PumpCalRecord function gets the calibration record of the - * D12 dialysate pump. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord - * @details \b Outputs: none - * @return ddCalibrationGroup.ddCalibrationRecord. - * d12DialysatePumpRecord - *************************************************************************/ -DD_D12_DIALYSATE_PUMP_RECORD_T getD12PumpCalRecord( void ) -{ - return ( ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord ); -} - -/*********************************************************************//** - * @brief - * The getD48PumpCalRecord function gets the calibration record of the - * D48 dialysate pump. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord - * @details \b Outputs: none - * @return ddCalibrationGroup.ddCalibrationRecord. - * d48DialysatePumpRecord - *************************************************************************/ -DD_D48_DIALYSATE_PUMP_RECORD_T getD48PumpCalRecord( void ) -{ - return ( ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord ); -} - -/*********************************************************************//** - * @brief - * The getAcidConcentrateCalRecord function gets the calibration record - * of the specified acid concentrate. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord - * @details \b Outputs: none - * @param acidIdx Acid concentrate index - * @return record corresponding acid concentrate calibration record - *************************************************************************/ -DD_ACID_CONCENTRATE_T getAcidConcentrateCalRecord( U08 acidIdx ) -{ - DD_ACID_CONCENTRATE_T record = { 0 }; - - if ( acidIdx < NUM_OF_ACID_TYPE ) - { - record = ( ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord.acidConcentrate[ acidIdx ] ); - } - - return record; -} - -/*********************************************************************//** - * @brief - * The getBicarbConcentrateCalRecord function gets the calibration - * record of the specified bicarb concentrate. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord - * @details \b Outputs: none - * @param bicarbIdx Bicarb concentrate index - * @return record corresponding bicarb concentrate calibration record - *************************************************************************/ -DD_BICARB_CONCENTRATE_T getBicarbConcentrateCalRecord( U08 bicarbIdx ) -{ - DD_BICARB_CONCENTRATE_T record = { 0 }; - - if ( bicarbIdx < NUM_OF_BICARB_TYPE ) - { - record = ( ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord.bicarbConcentrate[ bicarbIdx ] ); - } - - return record; -} - -/*********************************************************************//** - * @brief - * The getAccelSensorCalRecord function gets the calibration record of - * the accelerometer sensor. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord. - * accelerometerSensorCalRecord - * @details \b Outputs: none - * @return ddCalibrationGroup.ddCalibrationRecord. - * accelerometerSensorCalRecord - *************************************************************************/ -DD_ACCEL_SENSOR_CAL_RECORD_T getAccelSensorCalRecord( void ) -{ - return ( ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord ); -} - -/*********************************************************************//** - * @brief - * The getBloodLeakSensorCalRecord function gets the calibration record - * of the blood leak sensor. - * @details \b Inputs: - * ddCalibrationGroup.ddCalibrationRecord. - * bloodLeakSensorCalRecord - * @details \b Outputs: none - * @return ddCalibrationGroup.ddCalibrationRecord. - * bloodLeakSensorCalRecord - *************************************************************************/ -DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T getBloodLeakSensorCalRecord( void ) -{ - return ( ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord ); -} - -/*********************************************************************//** - * @brief * The getNVMRecord function copies the requested non-volatile * data into the provided buffer and checks if the data is valid. It * raises the specified alarm if invalid data is detected. @@ -1434,83 +1487,104 @@ U08* nvDataStartPtr = 0; BOOL isNVDataInvalid = FALSE; U32 nvDataLength = 0; + CONDUCTIVITY_COEFFICIENTS_T condCalRecord[ NUM_OF_CONDUCTIVITY_SENSORS ]; switch ( nvData ) { - case GET_CAL_PRESSURE_SENOSRS: + case NV_DD_DATA_SYSTEM_RECORD: + nvDataStartPtr = (U08*)&ddSystemGroup.ddSystemRecord; + nvDataLength = sizeof( ddSystemGroup.ddSystemRecord ); + break; + + case NV_DD_DATA_SERVICE_RECORD: + nvDataStartPtr = (U08*)&ddServiceGroup.ddServiceRecord; + nvDataLength = sizeof( ddServiceGroup.ddServiceRecord ); + break; + + case NV_DD_DATA_CAL_PRESSURE_SENOSRS: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord ); for ( i = 0; i < numOfSnsrs2Check; i++ ) isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord.pressureSensors[ i ].calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_TEMP_SENSORS: + case NV_DD_DATA_CAL_TEMPERATURE_SENSORS: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord ); for ( i = 0; i < numOfSnsrs2Check; i++ ) isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord.tempSensors[ i ].calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_CONCENTRATE_PUMPS_RECORD: + case NV_DD_DATA_CAL_CONCENTRATE_PUMPS_RECORD: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord ); for ( i = 0; i < numOfSnsrs2Check; i++ ) isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord.concentratePumps[ i ].calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_D12_PUMP_RECORD: + case NV_DD_DATA_CAL_D12_PUMP_RECORD: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord ); isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord.calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_D48_PUMP_RECORD: + case NV_DD_DATA_CAL_D48_PUMP_RECORD: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord ); isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord.d48DialysatePump.calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_ACID_CONCENTREATES: + case NV_DD_DATA_CAL_ACID_CONCENTREATES: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord ); for ( i = 0; i < numOfSnsrs2Check; i++ ) isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord.acidConcentrate[ i ].calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_BICARB_CONCENTRATES: + case NV_DD_DATA_CAL_BICARB_CONCENTRATES: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord ); for ( i = 0; i < numOfSnsrs2Check; i++ ) isNVDataInvalid |= ( 0 == ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord.bicarbConcentrate[ i ].calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_ACCEL_SENSORS: + case NV_DD_DATA_CAL_ACCELEROMETER_SENSOR: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord; isNVDataInvalid = ( 0 == ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord.calibrationTime ? TRUE : FALSE ); break; - case GET_CAL_BLOOD_LEAK_SENSOR: + case NV_DD_DATA_CAL_BLOOD_LEAK_SENSOR: nvDataStartPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord; nvDataLength = sizeof( ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord ); isNVDataInvalid = ( 0 == ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord.calibrationTime ? TRUE : FALSE ); break; - case GET_SYSTEM_RECORD: - nvDataStartPtr = (U08*)&ddSystemGroup.ddSystemRecord; - nvDataLength = sizeof( ddSystemGroup.ddSystemRecord ); + case NV_DD_DATA_CAL_CONDUCTIVITY_SENSORS: + nvDataStartPtr = (U08*)&condCalRecord; + nvDataLength = sizeof( condCalRecord ); + for ( i = 0; i < numOfSnsrs2Check; i++ ) + { + condCalRecord[ i ] = getConductivityCalibrationData( i ); + isNVDataInvalid |= ( 0 == condCalRecord[ i ].calibrationTime ? TRUE : FALSE ); + } break; - case GET_SERVICE_RECORD: - nvDataStartPtr = (U08*)&ddServiceGroup.ddServiceRecord; - nvDataLength = sizeof( ddServiceGroup.ddServiceRecord ); + case NV_DD_DATA_INSTIT_BASIC_RECORD: + nvDataStartPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.basicRecord; + nvDataLength = sizeof( ddInstitutionalGroup.ddInstitutionalRecord.basicRecord ); break; - case GET_INSTITUTIONAL_RECORD: - nvDataStartPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord; - nvDataLength = sizeof( ddInstitutionalGroup.ddInstitutionalRecord ); - break; + case NV_DD_DATA_INSTIT_ADVANCED_RECORD: + nvDataStartPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord; + nvDataLength = sizeof( ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord ); + break; - case GET_USAGE_RECORD: + case NV_DD_DATA_INSTIT_ADDITIONAL_RECORD: + nvDataStartPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord; + nvDataLength = sizeof( ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord ); + break; + + case NV_DD_DATA_USAGE_INFO_RECORD: nvDataStartPtr = (U08*)&ddUsageInfoGroup.ddUsageInfoRecord; nvDataLength = sizeof( ddUsageInfoGroup.ddUsageInfoRecord ); break; @@ -1561,272 +1635,122 @@ * @param bufferAddress Pointer to the source data buffer * @return TRUE if the record was updated successfully otherwise FALSE *************************************************************************/ -BOOL setNVMRecord( NVM_RECORD_TYPE_T recType, U08* bufferAddress ) +BOOL setNVMMRecord( NV_DATA_T recType, U08* bufferAddress, U08 idx ) { BOOL result = FALSE; U08* destPtr = NULL; U16 dataSize = 0; + NVM_RECORD_TYPE_T recTypeGroup; + CONDUCTIVITY_COEFFICIENTS_T condCalRecord; switch ( recType ) { - case NVM_SYSTEM_RECORD: - destPtr = (U08*)&ddSystemGroup.ddSystemRecord; - dataSize = sizeof( ddSystemGroup.ddSystemRecord ); + case NV_DD_DATA_SYSTEM_RECORD: + destPtr = (U08*)&ddSystemGroup.ddSystemRecord; + dataSize = sizeof( ddSystemGroup.ddSystemRecord ); + recTypeGroup = NVM_SYSTEM_RECORD; break; - case NVM_SERVICE_RECORD: - destPtr = (U08*)&ddServiceGroup.ddServiceRecord; - dataSize = sizeof( ddServiceGroup.ddServiceRecord ); + case NV_DD_DATA_SERVICE_RECORD: + destPtr = (U08*)&ddServiceGroup.ddServiceRecord; + dataSize = sizeof( ddServiceGroup.ddServiceRecord ); + recTypeGroup = NVM_SERVICE_RECORD; break; - case NVM_USAGE_INFO_RECORD: - destPtr = (U08*)&ddUsageInfoGroup.ddUsageInfoRecord; - dataSize = sizeof( ddUsageInfoGroup.ddUsageInfoRecord ); + case NV_DD_DATA_CAL_PRESSURE_SENOSRS: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord.pressureSensors[ idx ]; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord.pressureSensors[ 0 ] ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - default: + case NV_DD_DATA_CAL_TEMPERATURE_SENSORS: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord.tempSensors[ idx ]; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord.tempSensors[ 0 ] ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - } - if ( ( destPtr != NULL ) && ( bufferAddress != NULL ) && ( dataSize > 0 ) ) - { - - memcpy( destPtr, bufferAddress, dataSize ); - updateRecordCRC( recType ); - result = TRUE; - } - - return result; - -} - -/*********************************************************************//** - * @brief - * The setNVMCalRecord function updates the specified calibration - * record with the provided data buffer. It copies the calibration - * data and updates the calibration record CRC. - * @details \b Inputs: none - * @details \b Outputs: ddCalibrationGroup.ddCalibrationRecord, - * ddCalibrationGroup.crc - * @param calRecType Calibration record type to update - * @param bufferAddress Pointer to the source data buffer - * @param idx Calibration record index - * @return TRUE if the calibration record was updated successfully - * otherwise FALSE - *************************************************************************/ -BOOL setNVMCalRecord( DD_CAL_REC_TYPE calRecType, U08* bufferAddress, U08 idx ) -{ - BOOL result = FALSE; - U08* destPtr = NULL; - U16 dataSize = 0; - - switch ( calRecType ) - { - case DD_CAL_RECORD_PRESSURE_SENSOR: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord.pressureSensors[ idx ]; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.presSensorsCalRecord.pressureSensors[ 0 ] ); + case NV_DD_DATA_CAL_CONCENTRATE_PUMPS_RECORD: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord.concentratePumps[ idx ]; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord.concentratePumps[ 0 ] ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - case DD_CAL_RECORD_TEMPERATURE_SENSOR: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord.tempSensors[ idx ]; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.tempSensorsCalRecord.tempSensors[ 0 ] ); + case NV_DD_DATA_CAL_D12_PUMP_RECORD: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - case DD_CAL_RECORD_CONCENTRATE_PUMP: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord.concentratePumps[ idx ]; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.concentratePumpsRecord.concentratePumps[ 0 ] ); + case NV_DD_DATA_CAL_D48_PUMP_RECORD: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - case DD_CAL_RECORD_D12_PUMP: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.d12DialysatePumpRecord ); - break; - - case DD_CAL_RECORD_D48_PUMP: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.d48DialysatePumpRecord ); - break; - - case DD_CAL_RECORD_ACID_CONCENTRATE: + case NV_DD_DATA_CAL_ACID_CONCENTREATES: destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord.acidConcentrate[ idx ]; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord.acidConcentrate[ 0 ] ); + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.acidConcentratesRecord.acidConcentrate[ 0 ] ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - case DD_CAL_RECORD_BICARB_CONCENTRATE: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord.bicarbConcentrate[ idx ]; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord.bicarbConcentrate[ 0 ] ); + case NV_DD_DATA_CAL_BICARB_CONCENTRATES: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord.bicarbConcentrate[ idx ]; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.bicarbConcentratesRecord.bicarbConcentrate[ 0 ] ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - case DD_CAL_RECORD_ACCELEROMETER_SENSOR: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord ); + case NV_DD_DATA_CAL_ACCELEROMETER_SENSOR: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.accelerometerSensorCalRecord ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - case DD_CAL_RECORD_BLLOD_LEAK_SENSOR: - destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord; - dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord ); + case NV_DD_DATA_CAL_BLOOD_LEAK_SENSOR: + destPtr = (U08*)&ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord; + dataSize = sizeof( ddCalibrationGroup.ddCalibrationRecord.bloodLeakSensorCalRecord ); + recTypeGroup = NVM_CALIBRATION_RECORD; break; - default: + case NV_DD_DATA_CAL_CONDUCTIVITY_SENSORS: + if (bufferAddress != NULL ) + { + memcpy( &condCalRecord, bufferAddress, sizeof( CONDUCTIVITY_COEFFICIENTS_T ) ); + setConductivityCalibrationData( idx, condCalRecord ); + } break; - } - if ( ( destPtr != NULL ) && ( bufferAddress != NULL ) && ( dataSize > 0 ) ) - { - memcpy( destPtr, bufferAddress, dataSize ); - updateRecordCRC( NVM_CALIBRATION_RECORD ); - result = TRUE; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The getNVMInstitRecord function gets the value of the specified - * institutional record item. - * @details \b Inputs: ddInstitutionalGroup.ddInstitutionalRecord - * @details \b Outputs: none - * @param institRecType Institutional record item to retrieve - * @param valuePtr Pointer to the buffer where the value will be copied - * @return TRUE if the value was retrieved successfully otherwise FALSE - *************************************************************************/ -BOOL getNVMInstitRecord( DD_INSTIT_REC_TYPE institRecType, U08 *valuePtr ) -{ - BOOL result = FALSE; - - U08 *srcPtr = NULL; - U16 dataSize = 0; - - switch (institRecType) - { - case DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minDialysateFlowMLPM; - dataSize = sizeof(U32); + case NV_DD_DATA_INSTIT_BASIC_RECORD: + destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.basicRecord; + dataSize = sizeof( ddInstitutionalGroup.ddInstitutionalRecord.basicRecord ); + recTypeGroup = NVM_INSTITUTIONAL_RECORD; break; - case DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateFlowMLPM; - dataSize = sizeof(U32); + case NV_DD_DATA_INSTIT_ADVANCED_RECORD: + destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord; + dataSize = sizeof( ddInstitutionalGroup.ddInstitutionalRecord.advancedRecord ); + recTypeGroup = NVM_INSTITUTIONAL_RECORD; break; - case DD_INSTIT_MIN_DIALYSATE_TEMP_C: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minDialysateTempC; - dataSize = sizeof(F32); + case NV_DD_DATA_INSTIT_ADDITIONAL_RECORD: + destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord; + dataSize = sizeof( ddInstitutionalGroup.ddInstitutionalRecord.additionalRecord ); + recTypeGroup = NVM_INSTITUTIONAL_RECORD; break; - case DD_INSTIT_MAX_DIALYSATE_TEMP_C: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateTempC; - dataSize = sizeof(F32); + case NV_DD_DATA_USAGE_INFO_RECORD: + destPtr = (U08*)&ddUsageInfoGroup.ddUsageInfoRecord; + dataSize = sizeof( ddUsageInfoGroup.ddUsageInfoRecord ); + recTypeGroup = NVM_USAGE_INFO_RECORD; break; - case DD_INSTIT_MIN_ACID_CONCENTRATE: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minAcidConcentrate; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_ACID_CONCENTRATE: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxAcidConcentrate; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_BICARB_CARTRIDGE_SIZE_G: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minBicarbCartridgeSizeG; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_BICARB_CARTRIDGE_SIZE_G: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbCartridgeSizeG; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_SODIUM_MEQL: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minSodiumMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_SODIUM_MEQL: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxSodiumMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_BICARBONATE_MEQL: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minBicarbonateMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_BICARBONATE_MEQL: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbonateMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_RO_REJECTION_RATIO_PCT: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minRORejectionRatioPCT; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_DISINFECTION_FREQUENCY: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.disinfectionFrequency; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_DISINFECTION_CYCLE_TIME: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.disinfectionCycleTime; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_INLET_WATER_COND_ALARM_LIMIT_USPCM: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minInletWaterCondAlarmLimitUSPCM; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MAX_INLET_WATER_COND_ALARM_LIMIT_USPCM: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxInletWaterCondAlarmLimitUSPCM; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_ACID_CONCENTRATE_JUG_SIZE_L: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.acidConcentrateJugSizeL; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_ACID_ALARM_LIMIT_PCT: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minAcidAlarmLimitPCT; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_BICARB_ALARM_LIMIT_PCT: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minBicarbAlarmLimitPCT; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_POST_TREAT_DRAIN_OPTION: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.postTreatDrainOption; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_POST_TREAT_DRY_BICARB_OPTION: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.postTreatDryBicarbOption; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_CALIBRATION_TIME: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.calibrationTime; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_CRC: - srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.crc; - dataSize = sizeof(U16); - break; - default: break; } - if ( ( NULL != srcPtr ) && ( NULL != valuePtr ) && ( dataSize > 0 ) ) + if ( ( destPtr != NULL ) && ( bufferAddress != NULL ) && ( dataSize > 0 ) ) { - memcpy( valuePtr, srcPtr, dataSize ); + memcpy( destPtr, bufferAddress, dataSize ); + updateRecordCRC( recTypeGroup ); result = TRUE; } @@ -1835,177 +1759,6 @@ /*********************************************************************//** * @brief - * The setNVMInstitRecord function updates the specified institutional - * record item with the provided value. It updates the institutional - * record CRC after the value is written. - * @details \b Inputs: none - * @details \b Outputs: ddInstitutionalGroup.ddInstitutionalRecord, - * ddInstitutionalGroup.crc - * @param institRecType Institutional record item to update - * @param valuePtr Pointer to the value to be written - * @return TRUE if the value was updated successfully otherwise FALSE - *************************************************************************/ -BOOL setNVMInstitRecord( DD_INSTIT_REC_TYPE institRecType, U08 *valuePtr ) -{ - BOOL result = FALSE; - U08 *destPtr = NULL; - U16 dataSize = 0; - - switch (institRecType) - { - case DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minDialysateFlowMLPM; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateFlowMLPM; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_DIALYSATE_TEMP_C: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minDialysateTempC; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MAX_DIALYSATE_TEMP_C: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateTempC; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_ACID_CONCENTRATE: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minAcidConcentrate; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_ACID_CONCENTRATE: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxAcidConcentrate; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_BICARB_CARTRIDGE_SIZE_G: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minBicarbCartridgeSizeG; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_BICARB_CARTRIDGE_SIZE_G: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbCartridgeSizeG; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_SODIUM_MEQL: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minSodiumMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_SODIUM_MEQL: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxSodiumMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_BICARBONATE_MEQL: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minBicarbonateMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MAX_BICARBONATE_MEQL: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxBicarbonateMEQL; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_MIN_RO_REJECTION_RATIO_PCT: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minRORejectionRatioPCT; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_DISINFECTION_FREQUENCY: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.disinfectionFrequency; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_DISINFECTION_CYCLE_TIME: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.disinfectionCycleTime; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_INLET_WATER_COND_ALARM_LIMIT_USPCM: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minInletWaterCondAlarmLimitUSPCM; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MAX_INLET_WATER_COND_ALARM_LIMIT_USPCM: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxInletWaterCondAlarmLimitUSPCM; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_ACID_CONCENTRATE_JUG_SIZE_L: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.acidConcentrateJugSizeL; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_ACID_ALARM_LIMIT_PCT: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minAcidAlarmLimitPCT; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_MIN_BICARB_ALARM_LIMIT_PCT: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minBicarbAlarmLimitPCT; - dataSize = sizeof(F32); - break; - - case DD_INSTIT_POST_TREAT_DRAIN_OPTION: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.postTreatDrainOption; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_POST_TREAT_DRY_BICARB_OPTION: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.postTreatDryBicarbOption; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_CALIBRATION_TIME: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.calibrationTime; - dataSize = sizeof(U32); - break; - - case DD_INSTIT_CRC: - destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.crc; - dataSize = sizeof(U16); - break; - - default: - break; - } - - if ( ( NULL != destPtr ) && ( NULL != valuePtr ) && ( dataSize > 0 ) ) - { - memcpy( destPtr, valuePtr, dataSize ); - - // Update CRC after every change - updateRecordCRC( NVM_INSTITUTIONAL_RECORD ); - - result = TRUE; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The getInstitRecDataType function gets the data type associated with - * the specified institutional record item. - * @details \b Inputs: institRecDataTypeTable - * @details \b Outputs: none - * @param institRecType Institutional record type - * @return Data type of the institutional record component - *************************************************************************/ -CRITICAL_DATA_TYPES_T getInstitRecDataType( DD_INSTIT_REC_TYPE institRecType ) -{ - return institRecDataTypeTable[ institRecType ]; -} - -/*********************************************************************//** - * @brief * The sendNVEvent function sends the event associated with the * specified NV record type. * @details \b Inputs: RECORDS_SPECS @@ -2101,7 +1854,7 @@ break; case NVM_INSTITUTIONAL_RECORD: - ddInstitutionalGroup.ddInstitutionalRecord.crc = crc; + ddInstitutionalGroup.crc = crc; break; case NVM_USAGE_INFO_RECORD: