Index: firmware/App/Services/NVMessagingDD.c =================================================================== diff -u -rb925bf251dfd5584a0839cee93ccf8566a0ec2fb -r2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07 --- firmware/App/Services/NVMessagingDD.c (.../NVMessagingDD.c) (revision b925bf251dfd5584a0839cee93ccf8566a0ec2fb) +++ firmware/App/Services/NVMessagingDD.c (.../NVMessagingDD.c) (revision 2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07) @@ -34,6 +34,7 @@ #define RECORD_DATA_RECEIVE_TIMEOUT_MS (4 * MS_PER_SECOND) ///< Record data receive all the data packets timeout in ms. #define RECORD_DATA_MAX_MESSAGE_DFFIRENCE 1 ///< Calibration data receive message different from the previous message. #define RECORD_DATA_FIRST_RECEIVING_MSG_NUM 1 ///< Calibration data first receiving message number. +#define MAX_NUM_OF_SEND_RETRIES 5 ///< Maximum number of retries to send a record /// NVM send records states typedef enum NVM_Send_Records_States @@ -54,7 +55,7 @@ /// DD NVM Record Payload typedef struct { - U32 idx; ///< Index of sensor / pump / concentrates + U08 idx; ///< Index of sensor / pump / concentrates U08 data[ NUM_OF_BYTES_PER_RECORD_PAYLOAD ]; ///< Data to be sent } DD_NVM_SEND_RECORD_PAYLOAD_T; @@ -68,11 +69,13 @@ static NVM_RECORD_TYPE_T nvPublishRecordType; ///< Used to index over isPublishRecordRequested in the idle state static NVM_RECORD_TYPE_T currentRxRecordType; ///< Record type which is being processed currently for receiving static U32 recordSendDataIntervalCounter; ///< Record data send to CAN bust interval counter. +static U32 sendRetryCount; ///< Counter for number of retries to send a record static U32 previousRecordMessageNum; ///< Record previous message number. static U32 recordUpdateAddress; ///< DD record update address for all the write operations. static U32 calRecordReceiveStartTime; ///< Time stamp the calibration record was received. static U32 institRecordReceiveStartTime; ///< Time stamp the institutional record was received. static U32 recordReceiveStartTime; ///< Time stamp the calibration/service was received. +static DD_INSTIT_REC_TYPE sendInstitRec; ///< Current Institutional Record to be sent static BOOL isPublishRecordRequested[ NUM_OF_NVM_RECORD_TYPES ]; ///< Record state machine publish request flag. // ********** private function prototypes ********** @@ -81,17 +84,15 @@ static SEND_RECORD_STATE_T handleExecSendRecordIdleState( void ); static SEND_RECORD_STATE_T handleExecSendRecordSendState( void ); -static BOOL sendDDSystemRecord( void ); -static BOOL sendDDServiceRecord( void ); -static BOOL sendDDCalibrationRecord( void ); -static BOOL sendDDInstitutionalRecord( void ); -static BOOL sendDDUsageInfoRecord( void ); +static SEND_RECORD_STATE_T handleSendDDSystemRecord( void ); +static SEND_RECORD_STATE_T handleSendDDServiceRecord( void ); +static SEND_RECORD_STATE_T handleSendDDCalibrationRecord( void ); +static SEND_RECORD_STATE_T handleSendDDInstitutionalRecord( void ); +static SEND_RECORD_STATE_T handleSendDDUsageInfoRecord( void ); static BOOL sendDDRecord( MSG_ID_T msgId, U32 idx, U32 length, U08* recordAddress ); -static BOOL receiveDDRecord( MESSAGE_T *message, NVM_RECORD_TYPE_T recordType, U16 recordSize ); static BOOL receiveCalRecord( MESSAGE_T *message, DD_CAL_REC_TYPE calRecordType, U16 recordSize ); -static BOOL receiveInstitRecord( MESSAGE_T *message ); -static BOOL verifyAndSaveReceivedRecord( NVM_RECORD_TYPE_T job, U32 currentMessage, + static BOOL verifyAndSaveReceivedRecord( NVM_RECORD_TYPE_T job, U32 currentMessage, U32 totalMessages, U32 length, U08 *addressPtr ); static NVM_RECORD_TYPE_T getNVMRecordJobState( MSG_ID_T msgID ); static MSG_ID_T getNVMRecordResponseMsgId (NVM_RECORD_TYPE_T job ); @@ -126,6 +127,7 @@ recordSendDataIntervalCounter = 0; previousRecordMessageNum = 0; recordReceiveStartTime = 0; + sendInstitRec = DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM; } /*********************************************************************//** @@ -160,9 +162,10 @@ if( nvmExecreceiveRecordState == NVM_RECEIVE_RECORD_STATE_RECEIVE ) { - if ( TRUE == didTimeout( calRecordReceiveStartTime, RECORD_DATA_RECEIVE_TIMEOUT_MS ) ) + if ( ( NVM_CALIBRATION_RECORD == currentRxRecordType ) && + ( TRUE == didTimeout( calRecordReceiveStartTime, RECORD_DATA_RECEIVE_TIMEOUT_MS ) ) ) { - // Exec receive state machine timed out. Schedule a read to update the structure + updateRecordCRC(NVM_CALIBRATION_RECORD); enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); startNewCalRecordAvailableTimer(); setNewCalibrationRecordAvailable( TRUE ); @@ -171,9 +174,10 @@ nvmExecreceiveRecordState = NVM_RECEIVE_RECORD_STATE_IDLE; } - if ( TRUE == didTimeout( institRecordReceiveStartTime, RECORD_DATA_RECEIVE_TIMEOUT_MS ) ) + if ( ( NVM_INSTITUTIONAL_RECORD == currentRxRecordType ) && + ( TRUE == didTimeout( institRecordReceiveStartTime, RECORD_DATA_RECEIVE_TIMEOUT_MS ) ) ) { - // Exec receive state machine timed out. Schedule a read to update the structure + updateRecordCRC(NVM_INSTITUTIONAL_RECORD); enqueueEraseAndWriteSector( NVM_INSTITUTIONAL_RECORD ); PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( NVM_INSTITUTIONAL_RECORD ); sendNVEvent( NVM_INSTITUTIONAL_RECORD , 0, 0 ); @@ -286,74 +290,145 @@ switch(recordToPublish) { case NVM_SYSTEM_RECORD: - sendDDSystemRecord(); + state = handleSendDDSystemRecord(); break; case NVM_SERVICE_RECORD: - sendDDServiceRecord(); + state = handleSendDDServiceRecord(); break; case NVM_CALIBRATION_RECORD: - sendDDCalibrationRecord(); + state = handleSendDDCalibrationRecord(); break; case NVM_INSTITUTIONAL_RECORD: - sendDDInstitutionalRecord(); + state = handleSendDDInstitutionalRecord(); break; case NVM_USAGE_INFO_RECORD: - sendDDUsageInfoRecord(); + state = handleSendDDUsageInfoRecord(); break; default: break; } recordSendDataIntervalCounter = 0; - state = NVM_SEND_RECORD_STATE_IDLE; } return state; } -static BOOL sendDDSystemRecord( void ) +static SEND_RECORD_STATE_T handleSendDDSystemRecord( void ) { + SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sysStatus = FALSE; - DD_SYSTEM_RECORD_T* systemRecord; - sysStatus = getNVMRecord( GET_SYSTEM_RECORD, - (U08*)&systemRecord, - sizeof( DD_SYSTEM_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ); + DD_SYSTEM_RECORD_T systemRecord; - sysStatus = sendDDRecord( MSG_ID_DD_NVM_SYSTEM_RECORD_RESPONSE, 0, - sizeof(DD_SYSTEM_RECORD_T), - (U08*)&systemRecord ); + // Get the record + if( TRUE == getNVMRecord( GET_SYSTEM_RECORD, + (U08*)&systemRecord, + sizeof( DD_SYSTEM_RECORD_T ) , + 0, + ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ) ) + { + // Send the record + sysStatus = sendMessage( MSG_ID_DD_NVM_SYSTEM_RECORD_RESPONSE, + COMM_BUFFER_OUT_CAN_DD_BROADCAST, + (U08 *)&systemRecord, + sizeof( DD_SYSTEM_RECORD_T ) ); + } - return sysStatus; + // Check if record send successfully + if ( TRUE == sysStatus ) + { + // Reset the retry count + sendRetryCount = 0; + + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; + + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + } + else + { + sendRetryCount ++; + } + + // Utilized all the retries. Something is wrong. + if( sendRetryCount > MAX_NUM_OF_SEND_RETRIES ) + { + // Reset the retry count + sendRetryCount = 0; + + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; + + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + } + + return state; } -static BOOL sendDDServiceRecord( void ) +static SEND_RECORD_STATE_T handleSendDDServiceRecord( void ) { + SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL serStatus = FALSE; - DD_SERVICE_RECORD_T* serviceRecord; + DD_SERVICE_RECORD_T serviceRecord; - serStatus = getNVMRecord( GET_SERVICE_RECORD, - (U08*)&serviceRecord, - sizeof( DD_SERVICE_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ); + // Get the record + if( TRUE == getNVMRecord( GET_SERVICE_RECORD, + (U08*)&serviceRecord, + sizeof( DD_SERVICE_RECORD_T ) , + 0, + ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ) ) + { + // Send the record + serStatus = sendMessage( MSG_ID_DD_NVM_SERVICE_RECORD_RESPONSE, + COMM_BUFFER_OUT_CAN_DD_BROADCAST, + (U08 *)&serviceRecord, + sizeof( DD_SERVICE_RECORD_T ) ); + } - serStatus = sendDDRecord( MSG_ID_DD_NVM_SERVICE_RECORD_RESPONSE, 0, - sizeof(DD_SERVICE_RECORD_T), - (U08*)&serviceRecord ); + // Check if record send successfully + if ( TRUE == serStatus ) + { + // Reset the retry count + sendRetryCount = 0; - return serStatus; + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; + + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + } + else + { + sendRetryCount ++; + } + + // Utilized all the retries. Something is wrong. + if( sendRetryCount > MAX_NUM_OF_SEND_RETRIES ) + { + // Reset the retry count + sendRetryCount = 0; + + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; + + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + } + + return state; } -static BOOL sendDDCalibrationRecord( void ) +static SEND_RECORD_STATE_T handleSendDDCalibrationRecord( void ) { + SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL calStatus = FALSE; int i; @@ -462,161 +537,136 @@ sizeof(DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T), (U08*)&bloodLeak ); - return calStatus; + return state; } -static BOOL sendDDInstitutionalRecord( void ) +static SEND_RECORD_STATE_T handleSendDDInstitutionalRecord( void ) { - BOOL institStatus = FALSE; - DD_INSTITUTIONAL_RECORD_T* institRecord; + BOOL sendStatus = FALSE; + SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; + U32 valueU32 = 0; + F32 valueF32 = 0.0; + DD_NVM_SEND_RECORD_PAYLOAD_T payload; + CRITICAL_DATA_TYPES_T dataType; - institStatus = getNVMRecord( GET_INSTITUTIONAL_RECORD, - (U08*)&institRecord, - sizeof( DD_INSTITUTIONAL_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC ); + // Get the data type of the institutional record + dataType = getInstitRecDataType( (DD_INSTIT_REC_TYPE)sendInstitRec ); - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM, - sizeof(U32), - (U08*)&institRecord->minDialysateFlowMLPM ); + // Create the payload based on the data type + if( CRITICAL_DATA_TYPE_U32 == dataType ) + { + if ( TRUE == ( getNVMInstitRecord((DD_INSTIT_REC_TYPE)sendInstitRec , (U08*)&valueU32 ) ) ) + { + memcpy( &payload.data, &valueU32, sizeof( U32 ) ); + } + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM, - sizeof(U32), - (U08*)&institRecord->maxDialysateFlowMLPM ); + if( CRITICAL_DATA_TYPE_F32 == dataType ) + { + if ( TRUE == ( getNVMInstitRecord((DD_INSTIT_REC_TYPE)sendInstitRec , (U08*)&valueF32 ) ) ) + { + memcpy( &payload.data, &valueF32, sizeof( F32 ) ); + } + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_DIALYSATE_TEMP_C, - sizeof(F32), - (U08*)&institRecord->minDialysateTempC ); + payload.idx = (U08)sendInstitRec; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_DIALYSATE_TEMP_C, - sizeof(F32), - (U08*)&institRecord->maxDialysateTempC ); + // Send the record + sendStatus = sendMessage( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + COMM_BUFFER_OUT_CAN_DD_BROADCAST, + (U08*)&payload, + sizeof( DD_NVM_SEND_RECORD_PAYLOAD_T ) ); - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_ACID_CONCENTRATE, - sizeof(U32), - (U08*)&institRecord->minAcidConcentrate ); + // Check if record was sent successfully + if ( TRUE == sendStatus) + { + // Reset the retry count + sendRetryCount = 0; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_ACID_CONCENTRATE, - sizeof(U32), - (U08*)&institRecord->maxAcidConcentrate ); + // Move on to publish the next institutional record + sendInstitRec = (DD_INSTIT_REC_TYPE)( (U32)sendInstitRec + 1 ); - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_BICARB_CARTRIDGE_SIZE_G, - sizeof(U32), - (U08*)&institRecord->minBicarbCartridgeSizeG ); + } + else + { + sendRetryCount ++; + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_BICARB_CARTRIDGE_SIZE_G, - sizeof(U32), - (U08*)&institRecord->maxBicarbCartridgeSizeG ); + // If all the allowed retries has been utilized or + // If all the institutional records have been published + if ( ( sendRetryCount > MAX_NUM_OF_SEND_RETRIES ) || + ( sendInstitRec >= NUM_OF_DD_INSTIT_RECORD_TYPE ) ) + { + // Reset Index tracker for next request. + sendInstitRec = DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_SODIUM_MEQL, - sizeof(U32), - (U08*)&institRecord->minSodiumMEQL ); + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_SODIUM_MEQL, - sizeof(U32), - (U08*)&institRecord->maxSodiumMEQL ); + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_BICARBONATE_MEQL, - sizeof(U32), - (U08*)&institRecord->minBicarbonateMEQL ); + // Reset the retry count + sendRetryCount = 0; + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_BICARBONATE_MEQL, - sizeof(U32), - (U08*)&institRecord->maxBicarbonateMEQL ); + return state; +} - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_RO_REJECTION_RATIO_PCT, - sizeof(U32), - (U08*)&institRecord->minRORejectionRatioPCT ); +static SEND_RECORD_STATE_T handleSendDDUsageInfoRecord( void ) +{ + SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; + BOOL usageStatus = FALSE; + DD_USAGE_INFO_RECORD_T usageInfoRecord; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_DISINFECTION_FREQUENCY, - sizeof(F32), - (U08*)&institRecord->disinfectionFrequency ); - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_DISINFECTION_CYCLE_TIME, - sizeof(F32), - (U08*)&institRecord->disinfectionCycleTime ); + // Get the record + if( TRUE == getNVMRecord( GET_USAGE_RECORD, + (U08*)&usageInfoRecord, + sizeof( DD_USAGE_INFO_RECORD_T ), + 0, + ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC ) ) + { + // Send the record + usageStatus = sendMessage( MSG_ID_DD_NVM_USAGE_INFO_RECORD_RESPONSE, + COMM_BUFFER_OUT_CAN_DD_BROADCAST, + (U08 *)&usageInfoRecord, + sizeof( DD_USAGE_INFO_RECORD_T ) ); + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_INLET_WATER_COND_ALARM_LIMIT_USPCM, - sizeof(F32), - (U08*)&institRecord->minInletWaterCondAlarmLimitUSPCM ); + // Check if record send successfully + if ( TRUE == usageStatus ) + { + // Reset the retry count + sendRetryCount = 0; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MAX_INLET_WATER_COND_ALARM_LIMIT_USPCM, - sizeof(F32), - (U08*)&institRecord->maxInletWaterCondAlarmLimitUSPCM ); + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_ACID_CONCENTRATE_JUG_SIZE_L, - sizeof(F32), - (U08*)&institRecord->acidConcentrateJugSizeL ); + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + } + else + { + sendRetryCount ++; + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_ACID_ALARM_LIMIT_PCT, - sizeof(F32), - (U08*)&institRecord->minAcidAlarmLimitPCT ); + // Utilized all the retries. Something is wrong. + if( sendRetryCount > MAX_NUM_OF_SEND_RETRIES ) + { + // Reset the retry count + sendRetryCount = 0; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_MIN_BICARB_ALARM_LIMIT_PCT, - sizeof(F32), - (U08*)&institRecord->minBicarbAlarmLimitPCT ); + // Clear the publishing flags + recordToPublish = NUM_OF_NVM_RECORD_TYPES; - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_POST_TREAT_DRAIN_OPTION, - sizeof(U32), - (U08*)&institRecord->postTreatDrainOption ); + // Move to Send Idle State + state = NVM_SEND_RECORD_STATE_IDLE; + } - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_POST_TREAT_DRY_BICARB_OPTION, - sizeof(U32), - (U08*)&institRecord->postTreatDryBicarbOption ); - - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_CALIBRATION_TIME, - sizeof(U32), - (U08*)&institRecord->calibrationTime ); - - institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, - DD_INSTIT_CRC, - sizeof(U16), - (U08*)&institRecord->crc ); - - return institStatus; + return state; } -static BOOL sendDDUsageInfoRecord( void ) -{ - BOOL usageStatus = FALSE; - DD_USAGE_INFO_RECORD_T* usageInfoRecord; - - usageStatus = getNVMRecord( GET_USAGE_RECORD, - (U08*)&usageInfoRecord, - sizeof( DD_USAGE_INFO_RECORD_T ), - 0, - ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC ); - - usageStatus = sendDDRecord( MSG_ID_DD_NVM_USAGE_INFO_RECORD_RESPONSE, 0, - sizeof(DD_USAGE_INFO_RECORD_T), - (U08*)&usageInfoRecord ); - - return usageStatus; -} - /*********************************************************************//** * @brief * The sendDDRecord function sends a DD record payload over communication. @@ -638,49 +688,12 @@ payload.idx = idx; memcpy( payload.data, recordAddress, length ); - result = sendMessage( msgId, COMM_BUFFER_OUT_DD_CAN_PC, (U08 *)&payload, + result = sendMessage( msgId, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&payload, sizeof( DD_NVM_SEND_RECORD_PAYLOAD_T ) ); return result; } -/*********************************************************************//** - * @brief - * The receiveDDRecord function processes a received DD record message. - * It extracts payload information and verifies the received data before - * saving it. - * @details \b Inputs: none - * @details \b Outputs: none - * @param message Pointer to received message structure - * @return TRUE if the record is successfully verified and saved, - * otherwise FALSE - *************************************************************************/ -static BOOL receiveDDRecord( MESSAGE_T *message, NVM_RECORD_TYPE_T recordType, U16 recordSize ) -{ - BOOL status = FALSE; - - if (message->hdr.payloadLen == recordSize) - { - U08 tempBuffer[ recordSize ]; - memcpy( tempBuffer, message->payload, recordSize ); - - // CRC assumed at end of record - U16 *recordCRC = (U16 *)( tempBuffer + ( recordSize - sizeof(U16) ) ); - U16 calcCRC = crc16( tempBuffer, recordSize - sizeof(U16) ); - - if ( calcCRC == *recordCRC ) - { - PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( recordType ); - memcpy( recordSpec.structAddressPtr, tempBuffer, recordSize ); - setNVMRecord( recordType, tempBuffer ); - status = enqueueEraseAndWriteSector( recordType ); - sendNVEvent( recordType, 0, 0 ); - } - } - - return status; -} - static BOOL receiveCalRecord( MESSAGE_T *message, DD_CAL_REC_TYPE calRecordType, U16 recordSize ) { BOOL status = FALSE; @@ -690,7 +703,6 @@ U08 expectedPayloadLen = ( sizeof(U08) + recordSize ); U08 tempBuffer[ recordSize ]; - if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy(&idx, payloadPtr, sizeof(U32)); @@ -711,37 +723,13 @@ // So we write it to flash when we finish receiving all packets or // a timeout occurs. calRecordReceiveStartTime = getMSTimerCount(); + currentRxRecordType = NVM_CALIBRATION_RECORD; } } return status; } -static BOOL receiveInstitRecord( MESSAGE_T *message ) -{ - BOOL status = FALSE; - U08 idx = 0; - U08* payloadPtr = message->payload; - U08 expectedPayloadLen = sizeof(U08); - - if ( message->hdr.payloadLen >= expectedPayloadLen ) - { - nvmExecreceiveRecordState = NVM_RECEIVE_RECORD_STATE_RECEIVE; - - memcpy( &idx, payloadPtr, sizeof(U32) ); - payloadPtr += sizeof(U08); - - status = setNVMInstitRecord( (DD_CAL_REC_TYPE)idx, payloadPtr ); - - // It is possible that we receive multiple packets of instit record - // So we write it to flash when we finish receiving all packets or - // a timeout occurs. - institRecordReceiveStartTime = getMSTimerCount(); - } - - return status; -} - /*********************************************************************//** * @brief * The monitorNewCalSignal function monitors the new calibration signal @@ -818,11 +806,30 @@ BOOL testDDSetNVSystemRecord( MESSAGE_T *message ) { BOOL result = FALSE; + U08 tempBuffer[ sizeof( DD_SYSTEM_RECORD_T ) ]; + // System record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { - result = receiveDDRecord( message, NVM_SYSTEM_RECORD, sizeof( DD_SYSTEM_RECORD_T ) ); + if (message->hdr.payloadLen == sizeof( DD_SYSTEM_RECORD_T )) + { + memcpy( tempBuffer, message->payload, sizeof( DD_SYSTEM_RECORD_T ) ); + + // CRC assumed at end of record + U16 *recordCRC = (U16 *)( tempBuffer + ( sizeof( DD_SYSTEM_RECORD_T ) - sizeof(U16) ) ); + U16 calcCRC = crc16( tempBuffer, sizeof( DD_SYSTEM_RECORD_T ) - sizeof(U16) ); + + if ( calcCRC == *recordCRC ) + { + currentRxRecordType = NVM_SYSTEM_RECORD; + PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( NVM_SYSTEM_RECORD ); + memcpy( recordSpec.structAddressPtr, tempBuffer, sizeof( DD_SYSTEM_RECORD_T ) ); + setNVMRecord( NVM_SYSTEM_RECORD, tempBuffer ); + result = enqueueEraseAndWriteSector( NVM_SYSTEM_RECORD ); + sendNVEvent( NVM_SYSTEM_RECORD, 0, 0 ); + } + } } return result; @@ -841,11 +848,30 @@ BOOL testDDSetNVServiceRecord( MESSAGE_T *message ) { BOOL result = FALSE; + U08 tempBuffer[ sizeof( DD_SERVICE_RECORD_T ) ]; // Service record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { - result = receiveDDRecord( message, NVM_SERVICE_RECORD, sizeof( DD_SERVICE_RECORD_T ) ); + if (message->hdr.payloadLen == ( sizeof( DD_SERVICE_RECORD_T ) ) ) + { + memcpy( tempBuffer, message->payload, sizeof( DD_SERVICE_RECORD_T ) ); + + // CRC assumed at end of record + U16 *recordCRC = (U16 *)( tempBuffer + ( sizeof( DD_SERVICE_RECORD_T ) - sizeof(U16) ) ); + U16 calcCRC = crc16( tempBuffer, sizeof( DD_SERVICE_RECORD_T ) - sizeof(U16) ); + + if ( calcCRC == *recordCRC ) + { + currentRxRecordType = NVM_SERVICE_RECORD; + PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( NVM_SERVICE_RECORD ); + memcpy( recordSpec.structAddressPtr, tempBuffer, sizeof( DD_SERVICE_RECORD_T ) ); + setNVMRecord( NVM_SERVICE_RECORD, tempBuffer ); + result = enqueueEraseAndWriteSector( NVM_SERVICE_RECORD ); + sendNVEvent( NVM_SERVICE_RECORD, 0, 0 ); + } + } + } return result; @@ -863,7 +889,27 @@ BOOL testDDSetNVUsageInfoRecord( MESSAGE_T *message ) { BOOL result = FALSE; - result = receiveDDRecord( message, NVM_USAGE_INFO_RECORD, sizeof( DD_USAGE_INFO_RECORD_T ) ); + U08 tempBuffer[ sizeof( DD_USAGE_INFO_RECORD_T ) ]; + + if (message->hdr.payloadLen == ( sizeof( DD_USAGE_INFO_RECORD_T ) )) + { + memcpy( tempBuffer, message->payload, sizeof( DD_USAGE_INFO_RECORD_T ) ); + + // CRC assumed at end of record + U16 *recordCRC = (U16 *)( tempBuffer + ( sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof(U16) ) ); + U16 calcCRC = crc16( tempBuffer, sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof(U16) ); + + if ( calcCRC == *recordCRC ) + { + currentRxRecordType = NVM_USAGE_INFO_RECORD; + PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( NVM_USAGE_INFO_RECORD ); + memcpy( recordSpec.structAddressPtr, tempBuffer, sizeof( DD_USAGE_INFO_RECORD_T ) ); + setNVMRecord( NVM_USAGE_INFO_RECORD, tempBuffer ); + result = enqueueEraseAndWriteSector( NVM_USAGE_INFO_RECORD ); + sendNVEvent( NVM_USAGE_INFO_RECORD, 0, 0 ); + } + } + return result; } @@ -879,7 +925,26 @@ BOOL testDDSetNVInstitutionalRecord( MESSAGE_T *message ) { BOOL result = FALSE; - result = receiveInstitRecord( message ); + U08 idx = 0; + U08* payloadPtr = message->payload; + U08 expectedPayloadLen = sizeof(U08); + + if ( message->hdr.payloadLen >= expectedPayloadLen ) + { + nvmExecreceiveRecordState = NVM_RECEIVE_RECORD_STATE_RECEIVE; + + memcpy( &idx, payloadPtr, sizeof(U32) ); + payloadPtr += sizeof(U08); + + result = setNVMInstitRecord( (DD_CAL_REC_TYPE)idx, payloadPtr ); + + // It is possible that we receive multiple packets of instit record + // So we write it to flash when we finish receiving all packets or + // a timeout occurs. + institRecordReceiveStartTime = getMSTimerCount(); + currentRxRecordType = NVM_INSTITUTIONAL_RECORD; + } + return result; } Index: firmware/App/Services/NVRecordsDD.c =================================================================== diff -u -rb925bf251dfd5584a0839cee93ccf8566a0ec2fb -r2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07 --- firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision b925bf251dfd5584a0839cee93ccf8566a0ec2fb) +++ firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision 2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07) @@ -175,6 +175,35 @@ {USAGE_INFO_START_ADDRESS, sizeof(DD_USAGE_INFO_GROUP_T), (U08*)&ddUsageInfoGroup, (U08*)&ddUsageInfoGroup.crc, DD_EVENT_USAGE_INFO_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. @@ -206,8 +235,8 @@ static void initDDCalibrationRecord( void ); static void updateRecordPadding( NVM_RECORD_TYPE_T recType ); -static void updateRecordCRC( NVM_RECORD_TYPE_T recType ); + /*********************************************************************//** * @brief * The initNVRecordsDD function initializes the NV records data management @@ -234,8 +263,8 @@ int i; for( i = 0; i < NUM_OF_NVM_RECORD_TYPES; i++ ) { - updateRecordPadding(i); - updateRecordCRC(i); + updateRecordPadding( (NVM_RECORD_TYPE_T)i ); + updateRecordCRC( ( NVM_RECORD_TYPE_T )i); } } @@ -843,11 +872,13 @@ static void initDDServiceRecord( void ) { - ddServiceGroup.ddServiceRecord.isHDFOnlineFluid = FALSE; - ddServiceGroup.ddServiceRecord.waterRecovery = 0; - ddServiceGroup.ddServiceRecord.serviceLoc = 0; - ddServiceGroup.ddServiceRecord.lastServiceEpochDate = 0; - ddServiceGroup.ddServiceRecord.serviceIntervalSeconds = RECORD_DEFAULT_SERVICE_INTERVAL_S; + ddServiceGroup.ddServiceRecord.isHDFOnlineFluid = TRUE; + ddServiceGroup.ddServiceRecord.waterRecovery = 1; + ddServiceGroup.ddServiceRecord.serviceLoc = 2; + ddServiceGroup.ddServiceRecord.lastServiceEpochDate = 3; + ddServiceGroup.ddServiceRecord.serviceIntervalSeconds = 4; +// ddServiceGroup.ddServiceRecord.serviceIntervalSeconds = RECORD_DEFAULT_SERVICE_INTERVAL_S; + ddServiceGroup.ddServiceRecord.lastResetTimeEpoch = 5; // ddServiceGroup.ddServiceRecord.lastResetTimeEpoch = getRTCTimestamp(); } @@ -1012,10 +1043,8 @@ } -static void updateRecordCRC( NVM_RECORD_TYPE_T recType ) +void updateRecordCRC( NVM_RECORD_TYPE_T recType ) { - U32 i = 0; - switch( recType ) { case NVM_SYSTEM_RECORD: @@ -1359,6 +1388,7 @@ { memcpy( destPtr, bufferAddress, dataSize ); + updateRecordCRC(recType); result = TRUE; } @@ -1426,12 +1456,161 @@ if ( (destPtr != NULL ) && ( bufferAddress != NULL ) && ( dataSize > 0 ) ) { memcpy( destPtr, bufferAddress, dataSize ); + updateRecordCRC( NVM_CALIBRATION_RECORD ); result = TRUE; } return result; } +CRITICAL_DATA_TYPES_T getInstitRecDataType( DD_INSTIT_REC_TYPE institRecType ) +{ + return institRecDataTypeTable[ institRecType ]; +} + +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); + break; + + case DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM: + srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateFlowMLPM; + dataSize = sizeof(U32); + break; + + case DD_INSTIT_MIN_DIALYSATE_TEMP_C: + srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.minDialysateTempC; + dataSize = sizeof(F32); + break; + + case DD_INSTIT_MAX_DIALYSATE_TEMP_C: + srcPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.maxDialysateTempC; + dataSize = sizeof(F32); + 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 ) ) + { + memcpy( valuePtr, srcPtr, dataSize ); + result = TRUE; + } + + return result; +} + + BOOL setNVMInstitRecord( DD_INSTIT_REC_TYPE institRecType, U08 *valuePtr ) { BOOL result = FALSE; @@ -1558,7 +1737,7 @@ case DD_INSTIT_CRC: destPtr = (U08*)&ddInstitutionalGroup.ddInstitutionalRecord.crc; - dataSize = sizeof(U32); + dataSize = sizeof(U16); break; @@ -1571,8 +1750,7 @@ memcpy( destPtr, valuePtr, dataSize ); // Update CRC after every change - ddInstitutionalGroup.crc = crc16( (U08*)&ddInstitutionalGroup.ddInstitutionalRecord, - sizeof( DD_INSTITUTIONAL_RECORD_T ) - sizeof(U16) ); + updateRecordCRC( NVM_INSTITUTIONAL_RECORD ); result = TRUE; } Index: firmware/App/Services/NVRecordsDD.h =================================================================== diff -u -rb925bf251dfd5584a0839cee93ccf8566a0ec2fb -r2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07 --- firmware/App/Services/NVRecordsDD.h (.../NVRecordsDD.h) (revision b925bf251dfd5584a0839cee93ccf8566a0ec2fb) +++ firmware/App/Services/NVRecordsDD.h (.../NVRecordsDD.h) (revision 2f1c3a32a7e6f196fb0ca6f28fdb91b5ff237c07) @@ -25,6 +25,7 @@ #include "PressureSensor.h" #include "RinsePump.h" #include "TemperatureSensors.h" +#include "Utilities.h" /** * @defgroup NVRecordsDD NVRecordsDD @@ -80,7 +81,7 @@ DD_CAL_RECORD_BICARB_CONCENTRATE, ///< Index for bicarb concentrates calibration data. DD_CAL_RECORD_ACCELEROMETER_SENSOR, ///< Index for accelerometers calibration data. DD_CAL_RECORD_BLLOD_LEAK_SENSOR, ///< Index for blood leak sensor calibration data. - NUM_OF_CAL_RECORD_COMPONENTS ///< Total number of components in calibration record + NUM_OF_CAL_RECORD_TYPE ///< Total number of components in calibration record }DD_CAL_REC_TYPE; /// Enum for all the subcomponents for the DD institutional record @@ -110,7 +111,7 @@ DD_INSTIT_POST_TREAT_DRY_BICARB_OPTION, ///< Index for Dry Bicarbonate Post Treatment Option  DD_INSTIT_CALIBRATION_TIME, ///< Index for Calibration time in epoch. DD_INSTIT_CRC, ///< Index for CRC of the institutional record. - NUM_OF_DD_INSTIT_RECORD_COMPONENTS ///< Total number of components in institutional record + NUM_OF_DD_INSTIT_RECORD_TYPE ///< Total number of components in institutional record }DD_INSTIT_REC_TYPE; /// DD available NV data to get @@ -352,8 +353,11 @@ U08 numOfSnsrs2Check, ALARM_ID_T nvAlarm ); BOOL setNVMRecord( NVM_RECORD_TYPE_T recType, U08* bufferAddress ); BOOL setNVMCalRecord(DD_CAL_REC_TYPE calRecType, U08* bufferAddress, U08 idx); +CRITICAL_DATA_TYPES_T getInstitRecDataType( DD_INSTIT_REC_TYPE institRecType ); +BOOL getNVMInstitRecord( DD_INSTIT_REC_TYPE institRecType, U08 *valuePtr ); BOOL setNVMInstitRecord(DD_INSTIT_REC_TYPE institRecType, U08 *valuePtr); void sendNVEvent( NVM_RECORD_TYPE_T recType, U32 d1, U32 d2 ); +void updateRecordCRC( NVM_RECORD_TYPE_T recType ); void updateNVSelfTestResult( SELF_TEST_STATUS_T result ); void updateNVSelfTestState( NVM_SELF_TEST_STATE_T state ); void updateSelfTestReadRecordsFlag ( BOOL value );