Index: firmware/App/Services/Messaging.c =================================================================== diff -u -r1fa38184526c2b0c072eb8745c653f772156a824 -r2e65cae607c3ee68326f82d6134b0de3777559f9 --- firmware/App/Services/Messaging.c (.../Messaging.c) (revision 1fa38184526c2b0c072eb8745c653f772156a824) +++ firmware/App/Services/Messaging.c (.../Messaging.c) (revision 2e65cae607c3ee68326f82d6134b0de3777559f9) @@ -267,12 +267,11 @@ { MSG_ID_DD_BICARB_CHAMBER_FILL_REQUEST_OVERRIDE_REQUEST, &testBiCarbChamberFillRequestOverride }, { MSG_ID_DD_BICART_DRAIN_REQUEST_OVERRIDE_REQUEST, &testDryBiCartDrainRequestOverride }, { MSG_ID_DD_BICART_CARTRIDGE_SELECT_OVERRIDE_REQUEST, &testDryBiCartTypeOverride }, - { MSG_ID_DD_NVM_GET_RECORD, &testDDGetNVRecord }, - { MSG_ID_DD_NVM_SET_SYSTEM_RECORD, &testDDSetNVSystemRecord }, - { MSG_ID_DD_NVM_SET_SERVICE_RECORD, &testDDSetNVServiceRecord }, - { MSG_ID_DD_NVM_SET_CALIBRATION_RECORD, &testDDSetNVCalibrationRecord }, - { MSG_ID_DD_NVM_SET_INSTITUTIONAL_RECORD, &testDDSetNVInstitutionalRecord }, - { MSG_ID_DD_NVM_SET_USAGE_INFO_RECORD, &testDDSetNVUsageInfoRecord }, + { MSG_ID_UI_DD_NVM_GET_RECORD_REQUEST, &testDDGetNVRecord }, + { MSG_ID_UI_DD_NVM_SET_SYSTEM_RECORD, &testDDSetNVSystemRecord }, + { MSG_ID_UI_DD_NVM_SET_SERVICE_RECORD, &testDDSetNVServiceRecord }, + { MSG_ID_UI_DD_NVM_SET_INSTITUTIONAL_RECORD, &testDDSetNVInstitutionalRecord }, + { MSG_ID_UI_DD_NVM_SET_USAGE_INFO_RECORD, &testDDSetNVUsageInfoRecord }, { MSG_ID_DD_NVM_RECORD_CRC_OVERRIDE_REQUEST, &testDDSetNVUsageInfoRecord }, { MSG_ID_FP_RO_REJECTION_RATIO_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testRORejectionRatioDataPublishIntervalOverride }, { MSG_ID_FP_RO_FILTERED_REJECTION_RATIO_OVERRIDE_REQUEST, &testRORejectionRatioFilteredOverride }, 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: Index: firmware/App/Services/NVRecordsDD.c =================================================================== diff -u -r3dcf9d96cae82528433d1f864b8145ca8bca2b6a -r2e65cae607c3ee68326f82d6134b0de3777559f9 --- firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision 3dcf9d96cae82528433d1f864b8145ca8bca2b6a) +++ firmware/App/Services/NVRecordsDD.c (.../NVRecordsDD.c) (revision 2e65cae607c3ee68326f82d6134b0de3777559f9) @@ -108,23 +108,23 @@ DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T bloodLeakSensorCalRecord; ///< DD blood leak detector calibration record } DD_CALIBRATION_GROUPS_T; -/// DG calibration records structure +/// DD calibration records structure typedef struct { DD_CALIBRATION_GROUPS_T ddCalibrationGroups; ///< DD calibration groups. U08 padding[ RECORD_PADDING_LENGTH(DD_CALIBRATION_GROUPS_T, MAX_EEPROM_WRITE_BUFFER_BYTES) ]; ///< DD calibration record padding byte array. U16 crc; ///< CRC for the DG calibration record structure. } DD_CALIBRATION_RECORD_T; -/// DG system group structure +/// DD system group structure typedef struct { DD_SYSTEM_RECORD_T ddSystemRecord; ///< DD system record. U08 padding[ RECORD_PADDING_LENGTH(DD_SYSTEM_RECORD_T, MAX_EEPROM_WRITE_BUFFER_BYTES) ]; ///< DD system group padding byte array. U16 crc; ///< CRC for the DG system group structure. } DD_SYSTEM_GROUP_T; -/// DG service record structure +/// DD service record structure typedef struct { DD_SERVICE_RECORD_T ddServiceRecord; ///< DD service record. @@ -141,7 +141,7 @@ U16 crc; ///< CRC for the HD institutional structure. } DD_INSTITUTIONAL_GROUP_T; -/// DG usage record structure +/// DD usage record structure typedef struct { DD_USAGE_INFO_RECORD_T ddUsageInfo; ///< DD usage info record. @@ -226,7 +226,7 @@ // Initialize the parameters nvmSelfTestState = NVM_SELF_TEST_STATE_READ_RECORDS; nvmSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; - usageWriteTries = 0; + usageWriteTries = 0; } /*********************************************************************//** @@ -459,10 +459,10 @@ if ( calcCRC != recordCRC ) { // CRC did not pass so set all values to default - memset( ddSystemGroup.ddSystemRecord.topLevelPN, RECORD_DEFAULT_CHARACTER, sizeof( ddSystemGroup.ddSystemRecord.topLevelPN ) ); - memset( ddSystemGroup.ddSystemRecord.topLevelSN, RECORD_DEFAULT_CHARACTER, sizeof( ddSystemGroup.ddSystemRecord.topLevelSN ) ); +// memset( ddSystemGroup.ddSystemRecord.topLevelPN, RECORD_DEFAULT_CHARACTER, sizeof( ddSystemGroup.ddSystemRecord.topLevelPN ) ); +// memset( ddSystemGroup.ddSystemRecord.topLevelSN, RECORD_DEFAULT_CHARACTER, sizeof( ddSystemGroup.ddSystemRecord.topLevelSN ) ); ddSystemGroup.ddSystemRecord.isROFeatured = FALSE; - ddSystemGroup.ddSystemRecord.isR0FeaturedBoostPump = FALSE; + ddSystemGroup.ddSystemRecord.isROFeaturedBoostPump = FALSE; ddSystemGroup.ddSystemRecord.mfgDate = 0; ddSystemGroup.ddSystemRecord.mfgLocation = 0; @@ -476,10 +476,10 @@ 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 ); - } +// if ( RECORD_DEFAULT_CHARACTER == ddSystemGroup.ddSystemRecord.topLevelSN[ 0 ] ) +// { +// activateAlarmNoData( ALARM_ID_DD_NVM_INVALID_SERIAL_NUMBER ); +// } } return status; @@ -948,8 +948,8 @@ // In DG the RO water generation since the last service in reset to 0 // ddServiceGroup.ddServiceRecord.lastServiceEpochDate = getRTCTimestamp(); - 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 ) ); + 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 ) ); // Update the DG usage info ddUsageInfoGroup.ddUsageInfo.roWaterGenSinceLastServiceL = 0; ddUsageInfoGroup.ddUsageInfo.crc = crc16( (U08*)&ddUsageInfoGroup.ddUsageInfo, sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof( U16 ) ); @@ -1125,7 +1125,7 @@ } else { - activateAlarmNoData( nvAlarm ); +// activateAlarmNoData( nvAlarm ); } } Index: firmware/App/Services/NVRecordsDD.h =================================================================== diff -u -r1fa38184526c2b0c072eb8745c653f772156a824 -r2e65cae607c3ee68326f82d6134b0de3777559f9 --- firmware/App/Services/NVRecordsDD.h (.../NVRecordsDD.h) (revision 1fa38184526c2b0c072eb8745c653f772156a824) +++ firmware/App/Services/NVRecordsDD.h (.../NVRecordsDD.h) (revision 2e65cae607c3ee68326f82d6134b0de3777559f9) @@ -68,6 +68,51 @@ DD_EVENT_ID_T nvEvent; ///< Jobs non-volatile DD event (i.e calibration, system). } PROCESS_RECORD_SPECS_T; +/// Enum for all the subcomponents for the DD calibration record +typedef enum DD_Cal_Records_components +{ + DD_CAL_RECORD_PRESSURE_SENSOR = 0, ///< Index for pressure sensors calibration data. + DD_CAL_RECORD_TEMPERATURE_SENSOR, ///< Index for temperature sensors calibration data. + DD_CAL_RECORD_CONCENTRATE_PUMP, ///< Index for concentrate pumps calibration record. + DD_CAL_RECORD_D12_PUMP, ///< Index for D12 dialysate pump calibration record. + DD_CAL_RECORD_D48_PUMP, ///< Index for D48 dialysate pump calibration record. + DD_CAL_RECORD_ACID_CONCENTRATE, ///< Index for acid concentrates calibration data. + 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 +}DD_CAL_REC_COMPONENTS; + +/// Enum for all the subcomponents for the DD institutional record +typedef enum DD_Instit_Records_components +{ + DD_INSTIT_MIN_DIALYSATE_FLOW_MLPM = 0, ///< Index for Min dialysate flow in mL/min. + DD_INSTIT_MAX_DIALYSATE_FLOW_MLPM, ///< Index for Max dialysate flow in mL/min. + DD_INSTIT_MIN_DIALYSATE_TEMP_C, ///< Index for Min dialysate temperature in C. + DD_INSTIT_MAX_DIALYSATE_TEMP_C, ///< Index for Max dialysate temperature in C. + DD_INSTIT_MIN_ACID_CONCENTRATE, ///< Index for Min acid concentrate + DD_INSTIT_MAX_ACID_CONCENTRATE, ///< Index for Max acid concentrate + DD_INSTIT_MIN_BICARB_CARTRIDGE_SIZE_G, ///< Index for Min bicarbonate cartridge size in grams. + DD_INSTIT_MAX_BICARB_CARTRIDGE_SIZE_G, ///< Index for Max bicarbonate cartridge size in grams. + DD_INSTIT_MIN_SODIUM_MEQL, ///< Index for Min sodium in mEq/L + DD_INSTIT_MAX_SODIUM_MEQL, ///< Index for Max sodium in mEq/L + DD_INSTIT_MIN_BICARBONATE_MEQL, ///< Index for Min bicarbonate in mEq/L + DD_INSTIT_MAX_BICARBONATE_MEQL, ///< Index for Max bicarbonate in mEq/L + DD_INSTIT_MIN_RO_REJECTION_RATIO_PCT, ///< Index for Min RO rejection ratio in percent. + DD_INSTIT_DISINFECTION_FREQUENCY, ///< Index for Disinfection days between cycles. + DD_INSTIT_DISINFECTION_CYCLE_TIME, ///< Index for Disinfection Cycle Time + DD_INSTIT_MIN_INLET_WATER_COND_ALARM_LIMIT_USPCM, ///< Index for Min inlet water conductivity alarm limit in uS/cm. + DD_INSTIT_MAX_INLET_WATER_COND_ALARM_LIMIT_USPCM, ///< Index for Max inlet water conductivity alarm limit in uS/cm. + DD_INSTIT_ACID_CONCENTRATE_JUG_SIZE_L, ///< Index for acid concentrate jug size in Liters + DD_INSTIT_MIN_ACID_ALARM_LIMIT_PCT, ///< Index for Min acid alarm limit in percent. + DD_INSTIT_MIN_BICARB_ALARM_LIMIT_PCT, ///< Index for Min bicarbonate alarm limit in percent. + DD_INSTIT_POST_TREAT_DRAIN_OPTION, ///< Index for Dialysate Post Treatment Drain Option  + 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 +}DD_INSTIT_REC_COMPONENTS; + /// DD available NV data to get typedef enum DD_nv_commands { @@ -76,11 +121,10 @@ GET_CAL_CONCENTRATE_PUMPS_RECORD, ///< Get concentrate pumps calibration record. GET_CAL_D12_PUMP_RECORD, ///< Get D12 dialysate pump calibration record. GET_CAL_D48_PUMP_RECORD, ///< Get D48 dialysate pump calibration record. - GET_CAL_DIALYSATE_PUMPS_RECORD, ///< Get dialysate pumps calibration record. GET_CAL_ACID_CONCENTREATES, ///< Get acid concentrates calibration data. GET_CAL_BICARB_CONCENTRATES, ///< Get bicarb concentrates calibration data. GET_CAL_ACCEL_SENSORS, ///< Get accelerometers calibration data. - GET_CAL_BLOOD_LEAK_SENSOR, + GET_CAL_BLOOD_LEAK_SENSOR, ///< Get blood leak sensor calibration data. GET_SYSTEM_RECORD, ///< Get system record. GET_SERVICE_RECORD, ///< Get service record. GET_INSTITUTIONAL_RECORD, ///< Get institutional record. @@ -230,7 +274,7 @@ typedef struct { BOOL isROFeatured; ///< True : RO featured. False : RO de-featured. - BOOL isR0FeaturedBoostPump; ///< True : RO featured with boost pump. False : RO featured without the boost pump. + BOOL isROFeaturedBoostPump; ///< True : RO featured with boost pump. False : RO featured without the boost pump. char topLevelPN[ MAX_TOP_LEVEL_PN_CHARS ]; ///< DD top level part number. char topLevelSN[ MAX_TOP_LEVEL_SN_CHARS ]; ///< DD top level serial number. U08 mfgLocation; ///< DD manufacturing location.