Index: firmware/App/Services/NVMessagingDD.c =================================================================== diff -u -r1fa38184526c2b0c072eb8745c653f772156a824 -r2e65cae607c3ee68326f82d6134b0de3777559f9 --- firmware/App/Services/NVMessagingDD.c (.../NVMessagingDD.c) (revision 1fa38184526c2b0c072eb8745c653f772156a824) +++ firmware/App/Services/NVMessagingDD.c (.../NVMessagingDD.c) (revision 2e65cae607c3ee68326f82d6134b0de3777559f9) @@ -29,7 +29,7 @@ // ********** private definitions ********** #define NEW_CAL_AVAILABLE_SIGNAL_TIMEOUT_MS (1 * MS_PER_SECOND) ///< New calibration available signal timeout in milliseconds. -#define NUM_OF_BYTES_PER_RECORD_PAYLOAD ( MAX_MSG_PAYLOAD_SIZE - ( sizeof( U32 ) * 3 ) ) ///< Number of bytes per calibration payload. +#define NUM_OF_BYTES_PER_RECORD_PAYLOAD ( MAX_MSG_PAYLOAD_SIZE - ( sizeof( U32 ) ) ) ///< Number of bytes per calibration payload. #define RECORD_DATA_SEND_INTERVAL_COUNT (MS_PER_SECOND / (5 * TASK_GENERAL_INTERVAL)) ///< Calibration data send time interval in counts. #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. @@ -54,10 +54,8 @@ /// DD NVM Record Payload typedef struct { - U32 payloadCurrNum; ///< Current Chunk number out of total number number of chunks - U32 payloadTotalNum; ///< Total number of chunks in which data is broken be sent - U32 length; ///< Length of data in the current chunk - U08 data[NUM_OF_BYTES_PER_RECORD_PAYLOAD]; ///< Data to be sent + U32 idx; ///< Index of sensor / pump / concentrates + U08 data[ NUM_OF_BYTES_PER_RECORD_PAYLOAD ]; ///< Data to be sent } DD_NVM_SEND_RECORD_PAYLOAD_T; // ********** private data ********** @@ -69,8 +67,6 @@ static NVM_RECORD_TYPE_T recordToPublish; ///< Record type which is being processed currently for sending 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 recordPublishMsgCount; ///< Record data publish message counter. -static U32 recordPublishTotalMsgs; ///< Record data total number of messages to be sent. static U32 recordSendDataIntervalCounter; ///< Record data send to CAN bust interval counter. static U32 previousRecordMessageNum; ///< Record previous message number. static U32 recordUpdateAddress; ///< DD record update address for all the write operations. @@ -82,8 +78,14 @@ // Process record functions static SEND_RECORD_STATE_T handleExecSendRecordIdleState( void ); static SEND_RECORD_STATE_T handleExecSendRecordSendState( void ); -static BOOL sendDDRecord( MSG_ID_T msgId, U32 payloadCurrNum, U32 payloadTotalNum, - U32 length, U08* calRcrdAddress ); + +static BOOL sendDDSystemRecord( void ); +static BOOL sendDDServiceRecord( void ); +static BOOL sendDDCalibrationRecord( void ); +static BOOL sendDDInstitutionalRecord( void ); +static BOOL sendDDUsageInfoRecord( void ); +static BOOL sendDDRecord( MSG_ID_T msgId, U32 idx, U32 length, U08* recordAddress ); + static BOOL receiveDDRecord( MESSAGE_T *message ); static BOOL verifyAndSaveReceivedRecord( NVM_RECORD_TYPE_T job, U32 currentMessage, U32 totalMessages, U32 length, U08 *addressPtr ); @@ -117,8 +119,6 @@ isPublishRecordRequested[ NVM_CALIBRATION_RECORD ] = FALSE; isPublishRecordRequested[ NVM_INSTITUTIONAL_RECORD ] = FALSE; isPublishRecordRequested[ NVM_USAGE_INFO_RECORD ] = FALSE; - recordPublishMsgCount = 1; - recordPublishTotalMsgs = 1; recordSendDataIntervalCounter = 0; previousRecordMessageNum = 0; recordReceiveStartTime = 0; @@ -236,14 +236,6 @@ // Set the publish flag to FALSE isPublishRecordRequested[ recordToPublish ] = FALSE; - // Get the record specifications to find the size of the job - PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( recordToPublish ); - - // Calculate the total number of messages required to be sent using ceilf function. This function rounds up the - // value and its result is converted to U32. - recordPublishTotalMsgs = (U32)ceilf( (F32)recordSpec.sizeofRecord / (F32)NUM_OF_BYTES_PER_RECORD_PAYLOAD ); - recordPublishMsgCount = 0; - // Time interval in between data to be sent. It is set to the interval count so on the first call // of the send calibration record function, the first packet of data is sent recordSendDataIntervalCounter = RECORD_DATA_SEND_INTERVAL_COUNT; @@ -275,47 +267,344 @@ static SEND_RECORD_STATE_T handleExecSendRecordSendState( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; - MSG_ID_T msgId; - // If the current message number is less than the total, keep sending - if ( recordPublishMsgCount < recordPublishTotalMsgs ) - { // If it is time to send data if ( ++recordSendDataIntervalCounter >= RECORD_DATA_SEND_INTERVAL_COUNT ) { - // Set to default cal data payload length - U32 length = NUM_OF_BYTES_PER_RECORD_PAYLOAD; + switch(recordToPublish) + { + case NVM_SYSTEM_RECORD: + sendDDSystemRecord(); + break; - PROCESS_RECORD_SPECS_T recordSpec = getProcessRecord( recordToPublish ); - U08* startPtr = recordSpec.structAddressPtr; + case NVM_SERVICE_RECORD: + sendDDServiceRecord(); + break; - // If this is the last calibration data payload, calculate the remainder of the bytes to send - if ( ( recordPublishMsgCount + 1 ) == recordPublishTotalMsgs ) - { - length = recordSpec.sizeofRecord - ( recordPublishMsgCount * NUM_OF_BYTES_PER_RECORD_PAYLOAD ); - } + case NVM_CALIBRATION_RECORD: + sendDDCalibrationRecord(); + break; - // Find the new location of the pointer which is the start of the calibration payload to be sent - startPtr += recordPublishMsgCount * NUM_OF_BYTES_PER_RECORD_PAYLOAD; + case NVM_INSTITUTIONAL_RECORD: + sendDDInstitutionalRecord(); + break; - // Get th message id of the NVM record response - msgId = getNVMRecordResponseMsgId( recordToPublish ); + case NVM_USAGE_INFO_RECORD: + sendDDUsageInfoRecord(); + break; - // Send the NVM record - sendDDRecord( msgId, recordPublishMsgCount + 1, recordPublishTotalMsgs, length, startPtr ); + default: + break; + } - recordPublishMsgCount++; recordSendDataIntervalCounter = 0; + state = NVM_SEND_RECORD_STATE_IDLE; } + + return state; +} + +static BOOL sendDDSystemRecord( void ) +{ + 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 ); + + sysStatus = sendDDRecord( MSG_ID_DD_NVM_SYSTEM_RECORD_RESPONSE, 0, + sizeof(DD_SYSTEM_RECORD_T), + (U08*)&systemRecord ); + + return sysStatus; +} + +static BOOL sendDDServiceRecord( void ) +{ + BOOL serStatus = FALSE; + 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 ); + + serStatus = sendDDRecord( MSG_ID_DD_NVM_SERVICE_RECORD_RESPONSE, 0, + sizeof(DD_SERVICE_RECORD_T), + (U08*)&serviceRecord ); + + return serStatus; +} + +static BOOL sendDDCalibrationRecord( void ) +{ + BOOL calStatus = FALSE; + int i; + + DD_PRES_SENSORS_CAL_RECORD_T* pressure; + calStatus = getNVMRecord( GET_CAL_PRESSURE_SENOSRS, + (U08*)&pressure, + sizeof( DD_PRES_SENSORS_CAL_RECORD_T ), + NUM_OF_PRESSURE_SENSORS, + ALARM_ID_DD_NVM_INVALID_CAL_PRESSURE_SENSOR ); + for ( i = 0; i < NUM_OF_PRESSURE_SENSORS; i++ ) + { + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_PRESSURE_SENSOR_RESPONSE, i, + sizeof(DD_PRES_SENSORS_CAL_RECORD_T), + (U08*)&pressure->pressureSensors[ i ] ); } - else + + DD_TEMP_SENSORS_CAL_RECORD_T* temperature; + calStatus = getNVMRecord( GET_CAL_TEMP_SENSORS, + (U08*)&temperature, + sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ), + NUM_OF_TEMPERATURE_SENSORS, + ALARM_ID_DD_NVM_INVALID_CAL_TEMP_SENSOR ); + for ( i = 0; i < NUM_OF_TEMPERATURE_SENSORS; i++ ) { - state = NVM_SEND_RECORD_STATE_IDLE; + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_TEMP_SENSOR_RESPONSE, i, + sizeof(DD_PRES_SENSORS_CAL_RECORD_T), + (U08*)&temperature->tempSensors[ i ] ); } - return state; + DD_CONC_PUMPS_CAL_RECORD_T* concPump; + calStatus = getNVMRecord( GET_CAL_CONCENTRATE_PUMPS_RECORD, + (U08*)&concPump, + sizeof( DD_CONC_PUMPS_CAL_RECORD_T ), + NUM_OF_CONCENTRATE_PUMPS, + ALARM_ID_DD_NVM_INVALID_CAL_CONC_PUMP ); + for ( i = 0; i < NUM_OF_CONCENTRATE_PUMPS; i++ ) + { + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_CONC_PUMP_RESPONSE, i, + sizeof(DD_CONC_PUMPS_CAL_RECORD_T), + (U08*)&concPump->concentratePumps[ i ] ); + } + + DD_D12_DIALYSATE_PUMP_RECORD_T* d12Pump; + calStatus = getNVMRecord( GET_CAL_D12_PUMP_RECORD, + (U08*)&d12Pump, + sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ), + 0, + ALARM_ID_DD_NVM_INVALID_CAL_D12_PUMP ); + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_D12_PUMP_RESPONSE, 0, + sizeof(DD_D12_DIALYSATE_PUMP_RECORD_T), + (U08*)&d12Pump ); + + DD_D48_DIALYSATE_PUMP_RECORD_T* d48Pump; + calStatus = getNVMRecord( GET_CAL_D48_PUMP_RECORD, + (U08*)&d48Pump, + sizeof( DD_D48_DIALYSATE_PUMP_RECORD_T ), + 0, + ALARM_ID_DD_NVM_INVALID_CAL_D48_PUMP ); + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_D48_PUMP_RESPONSE, 0, + sizeof(DD_D48_DIALYSATE_PUMP_RECORD_T), + (U08*)&d48Pump ); + + DD_ACID_CONCENTRATES_RECORD_T* acidConc; + calStatus = getNVMRecord( GET_CAL_ACID_CONCENTREATES, + (U08*)&acidConc, + sizeof( DD_ACID_CONCENTRATES_RECORD_T ), + NUM_OF_CAL_DATA_ACID_CONCENTRATES, + ALARM_ID_DD_NVM_INVALID_CAL_ACID_CONCENTRATE ); + for ( i = 0; i < NUM_OF_CAL_DATA_ACID_CONCENTRATES; i++ ) + { + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_ACID_CONCENTRATE_RESPONSE, i, + sizeof(DD_ACID_CONCENTRATES_RECORD_T), + (U08*)&acidConc->acidConcentrate[ i ] ); + } + + DD_BICARB_CONCENTRATES_RECORD_T* bicarbConc; + calStatus |= getNVMRecord( GET_CAL_BICARB_CONCENTRATES, + (U08*)&bicarbConc, + sizeof( DD_BICARB_CONCENTRATES_RECORD_T ), + NUM_OF_CAL_DATA_BICARB_CONCENTRATES, + ALARM_ID_DD_NVM_INVALID_CAL_BICARB_CONCENTRATE ); + for ( i = 0; i < NUM_OF_CAL_DATA_BICARB_CONCENTRATES; i++ ) + { + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_BICARB_CONCENTRATE_RESPONSE, i, + sizeof(DD_BICARB_CONCENTRATES_RECORD_T), + (U08*)&bicarbConc->bicarbConcentrate[ i ] ); + } + + DD_ACCEL_SENSOR_CAL_RECORD_T* accelerometer; + calStatus = getNVMRecord( GET_CAL_ACCEL_SENSORS, + (U08*)&accelerometer, + sizeof( DD_ACCEL_SENSOR_CAL_RECORD_T ), + 0, + ALARM_ID_DD_NVM_INVALID_CAL_ACCEL_SENSOR ); + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_ACCEL_SENSOR_RESPONSE, 0, + sizeof(DD_ACCEL_SENSOR_CAL_RECORD_T), + (U08*)&accelerometer ); + + DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T* bloodLeak; + calStatus = getNVMRecord( GET_CAL_BLOOD_LEAK_SENSOR, + (U08*)&bloodLeak, + sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ), + 0, + ALARM_ID_DD_NVM_INVALID_CAL_BLOOD_LEAK_SENSOR ); + calStatus = sendDDRecord( MSG_ID_DD_NVM_CAL_BLOOD_LEAK_SENSOR_RESPONSE, 0, + sizeof(DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T), + (U08*)&bloodLeak ); + + return calStatus; } +static BOOL sendDDInstitutionalRecord( void ) +{ + BOOL institStatus = FALSE; + DD_INSTITUTIONAL_RECORD_T* institRecord; + + institStatus = getNVMRecord( GET_INSTITUTIONAL_RECORD, + (U08*)&institRecord, + sizeof( DD_INSTITUTIONAL_RECORD_T ), + 0, + ALARM_ID_DD_NVM_INVALID_INSTITUTIONAL_RECORD_CRC ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM, + sizeof(U32), + (U08*)&institRecord->minDialysateFlowMLPM ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM, + sizeof(U32), + (U08*)&institRecord->maxDialysateFlowMLPM ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_DIALYSATE_TEMP_C, + sizeof(F32), + (U08*)&institRecord->minDialysateTempC ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_DIALYSATE_TEMP_C, + sizeof(F32), + (U08*)&institRecord->maxDialysateTempC ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_ACID_CONCENTRATE, + sizeof(U32), + (U08*)&institRecord->minAcidConcentrate ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_ACID_CONCENTRATE, + sizeof(U32), + (U08*)&institRecord->maxAcidConcentrate ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_BICARB_CARTRIDGE_SIZE_G, + sizeof(U32), + (U08*)&institRecord->minBicarbCartridgeSizeG ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_BICARB_CARTRIDGE_SIZE_G, + sizeof(U32), + (U08*)&institRecord->maxBicarbCartridgeSizeG ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_SODIUM_MEQL, + sizeof(U32), + (U08*)&institRecord->minSodiumMEQL ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_SODIUM_MEQL, + sizeof(U32), + (U08*)&institRecord->maxSodiumMEQL ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_BICARBONATE_MEQL, + sizeof(U32), + (U08*)&institRecord->minBicarbonateMEQL ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_BICARBONATE_MEQL, + sizeof(U32), + (U08*)&institRecord->maxBicarbonateMEQL ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_RO_REJECTION_RATIO_PCT, + sizeof(U32), + (U08*)&institRecord->minRORejectionRatioPCT ); + + 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 ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_INLET_WATER_COND_ALARM_LIMIT_USPCM, + sizeof(F32), + (U08*)&institRecord->minInletWaterCondAlarmLimitUSPCM ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MAX_INLET_WATER_COND_ALARM_LIMIT_USPCM, + sizeof(F32), + (U08*)&institRecord->maxInletWaterCondAlarmLimitUSPCM ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_ACID_CONCENTRATE_JUG_SIZE_L, + sizeof(F32), + (U08*)&institRecord->acidConcentrateJugSizeL ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_ACID_ALARM_LIMIT_PCT, + sizeof(F32), + (U08*)&institRecord->minAcidAlarmLimitPCT ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_MIN_BICARB_ALARM_LIMIT_PCT, + sizeof(F32), + (U08*)&institRecord->minBicarbAlarmLimitPCT ); + + institStatus = sendDDRecord( MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE, + DD_INSTIT_POST_TREAT_DRAIN_OPTION, + sizeof(U32), + (U08*)&institRecord->postTreatDrainOption ); + + 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; +} + +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. @@ -329,19 +618,16 @@ * @param recordAddress Start address of the record data * @return TRUE if msg successfully queued for transmit, FALSE if not *************************************************************************/ -static BOOL sendDDRecord( MSG_ID_T msgId, U32 payloadCurrNum, U32 payloadTotalNum, +static BOOL sendDDRecord( MSG_ID_T msgId, U32 idx, U32 length, U08* recordAddress ) { BOOL result = FALSE; - U08 payloadLen = 0; DD_NVM_SEND_RECORD_PAYLOAD_T payload; - payloadLen = sizeof( U32 ) + sizeof( U32 ) + sizeof( U32 ) + length; - payload.payloadCurrNum = payloadCurrNum; - payload.payloadTotalNum = payloadTotalNum; - payload.length = length; + payload.idx = idx; memcpy( payload.data, recordAddress, length ); - result = sendMessage( msgId, COMM_BUFFER_OUT_DD_CAN_PC, (U08 *)&payload, payloadLen ); + result = sendMessage( msgId, COMM_BUFFER_OUT_DD_CAN_PC, (U08 *)&payload, + sizeof( DD_NVM_SEND_RECORD_PAYLOAD_T ) ); return result; } @@ -508,23 +794,31 @@ switch ( msgID ) { - case MSG_ID_DD_NVM_SET_CALIBRATION_RECORD: - job = NVM_CALIBRATION_RECORD; - break; +// case MSG_ID_DD_NVM_RECV_CAL_PRESSURE_SENSOR: +// case MSG_ID_DD_NVM_RECV_CAL_TEMP_SENSOR: +// case MSG_ID_DD_NVM_RECV_CAL_CONC_PUMP: +// case MSG_ID_DD_NVM_RECV_CAL_D12_PUMP: +// case MSG_ID_DD_NVM_RECV_CAL_D48_PUMP: +// case MSG_ID_DD_NVM_RECV_CAL_ACID_CONCENTRATE: +// case MSG_ID_DD_NVM_RECV_CAL_BICARB_CONCENTRATE: +// case MSG_ID_DD_NVM_RECV_CAL_ACCEL_SENSOR: +// case MSG_ID_DD_NVM_RECV_CAL_BLOOD_LEAK_SENSOR: +// job = NVM_CALIBRATION_RECORD; +// break; - case MSG_ID_DD_NVM_SET_SYSTEM_RECORD: + case MSG_ID_UI_DD_NVM_SET_SYSTEM_RECORD: job = NVM_SYSTEM_RECORD; break; - case MSG_ID_DD_NVM_SET_SERVICE_RECORD: + case MSG_ID_UI_DD_NVM_SET_SERVICE_RECORD: job = NVM_SERVICE_RECORD; break; - case MSG_ID_DD_NVM_SET_INSTITUTIONAL_RECORD: + case MSG_ID_UI_DD_NVM_SET_INSTITUTIONAL_RECORD: job = NVM_INSTITUTIONAL_RECORD; break; - case MSG_ID_DD_NVM_SET_USAGE_INFO_RECORD: + case MSG_ID_UI_DD_NVM_SET_USAGE_INFO_RECORD: job = NVM_USAGE_INFO_RECORD; break; @@ -553,23 +847,23 @@ switch( job ) { case NVM_CALIBRATION_RECORD: - msgID = MSG_ID_DD_NVM_SEND_CALIBRATION_RECORD; +// msgID = MSG_ID_DD_NVM_SEND_CALIBRATION_RECORD; break; case NVM_SYSTEM_RECORD: - msgID = MSG_ID_DD_NVM_SEND_SYSTEM_RECORD; + msgID = MSG_ID_DD_NVM_SYSTEM_RECORD_RESPONSE; break; case NVM_SERVICE_RECORD: - msgID = MSG_ID_DD_NVM_SEND_SERVICE_RECORD; + msgID = MSG_ID_DD_NVM_SERVICE_RECORD_RESPONSE; break; case NVM_INSTITUTIONAL_RECORD: - msgID = MSG_ID_DD_NVM_SEND_INSTITUTIONAL_RECORD; + msgID = MSG_ID_DD_NVM_INSTITUTIONAL_RECORD_RESPONSE; break; case NVM_USAGE_INFO_RECORD: - msgID = MSG_ID_DD_NVM_SEND_USAGE_INFO_RECORD; + msgID = MSG_ID_DD_NVM_USAGE_INFO_RECORD_RESPONSE; break; default: