/************************************************************************** * * Copyright (c) 2026-2027 Diality Inc. - All Rights Reserved. * * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file NVMessagingDD.c * * @author (original) Arpita Srivastava * @date (original) 31-Mar-2026 * ***************************************************************************/ #include // For ceilf function #include "ConductivitySensors.h" #include "Messaging.h" #include "NVJobQ.h" #include "NVMessagingDD.h" #include "NVRecordsDD.h" #include "OperationModes.h" #include "TaskGeneral.h" #include "Timers.h" #include "Utilities.h" // For crc calculation /** * @addtogroup NVMessagingDD * @{ */ // ********** 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 ) ) ) ///< 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. #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 { NVM_SEND_RECORD_STATE_IDLE = 0, ///< NVM process record idle state. NVM_SEND_RECORD_STATE_SEND, ///< NVM process record send record state. NUM_OF_NVM_SEND_RECORD_STATES ///< Number of NVM process records state. } SEND_RECORD_STATE_T; #pragma pack(push, 1) /// DD NVM Record Payload typedef struct { U08 idx; ///< Index of sensor / pump / concentrates U08 data[ NUM_OF_BYTES_PER_RECORD_PAYLOAD ]; ///< Data to be sent } DD_NVM_RECORD_PAYLOAD_T; /// DD NVM Get System Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_SYSTEM_RECORD_T data; ///< Data to be sent }DD_NVM_GET_SYSTEM_REC_PAYLOAD_T; /// DD NVM Set System Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 isROFeaturedRejectReason; ///< Reason to reject System record parameter isROFeatured U32 isROFeaturedBoostPumpRejectReason; ///< Reason to reject System record parameter isROFeaturedBoostPump U32 topLevelPNRejectReason; ///< Reason to reject System record parameter topLevelPN[ MAX_TOP_LEVEL_PN_CHARS ] U32 topLevelSNRejectReason; ///< Reason to reject System record parameter topLevelSN[ MAX_TOP_LEVEL_SN_CHARS ] U32 mfgLocationRejectReason; ///< Reason to reject System record parameter mfgLocation U32 mfgDateRejectReason; ///< Reason to reject System record parameter mfgDate }DD_NVM_SET_SYSTEM_REC_PAYLOAD_T; /// DD NVM Get Service Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_SERVICE_RECORD_T data; ///< Data to be sent }DD_NVM_GET_SERVICE_REC_PAYLOAD_T; /// DD NVM Set Service Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 isHDFOnlineFluidAvailableRejectReason; ///< Reason to reject Service record parameter isHDFOnlineFluidAvailable U32 waterRecoveryRejectReason; ///< Reason to reject Service record parameter waterRecovery U32 serviceLocRejectReason; ///< Reason to reject Service record parameter serviceLoc U32 lastServiceEpochDateRejectReason; ///< Reason to reject Service record parameter lastServiceEpochDate U32 serviceIntervalSecondsRejectReason; ///< Reason to reject Service record parameter serviceIntervalSeconds U32 lastResetTimeEpochRejectReason; ///< Reason to reject Service record parameter lastResetTimeEpoch }DD_NVM_SET_SERVICE_REC_PAYLOAD_T; /// DD NVM Get Usage Info Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_USAGE_INFO_RECORD_T data; ///< Data to be sent }DD_NVM_GET_USAGE_INFO_REC_PAYLOAD_T; /// DD NVM Set Usage Info Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 roWaterGenTotalLRejectReason; ///< Reason to reject Usage Info record parameter roWaterGenTotalL U32 roWaterGenSinceLastServiceLRejectReason; ///< Reason to reject Usage Info record parameter roWaterGenSinceLastServiceL U32 lastBasicFlushCompleteDateEpochRejectReason; ///< Reason to reject Usage Info record parameter lastBasicFlushCompleteDateEpoch U32 lastHeatDisCompleteDateEpochRejectReason; ///< Reason to reject Usage Info record parameter lastHeatDisCompleteDateEpoch U32 lastHeatActiveCoolCompleteDateEpochRejectReason; ///< Reason to reject Usage Info record parameter lastHeatActiveCoolCompleteDateEpoch U32 lastFilterFlushCompleteDateEpochRejectReason; ///< Reason to reject Usage Info record parameter lastFilterFlushCompleteDateEpoch U32 lastResetTimeEpochRejectReason; ///< Reason to reject Usage Info record parameter lastResetTimeEpoch }DD_NVM_SET_USAGE_INFO_REC_PAYLOAD_T; /// Institutional data reject reason structure. typedef struct { U32 minRejectReason; ///< Reason to reject Institutional record parameter min U32 maxRejectReason; ///< Reason to reject Institutional record parameter max U32 defRejectReason; ///< Reason to reject Institutional record parameter def } INSTIT_DATA_REJECT_REASON_T; /// DD NVM Get Institutional Basic Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_INSTIT_BASIC_RECORD_T data; ///< Data to be sent }DD_NVM_GET_INSTIT_BASIC_REC_PAYLOAD_T; /// DD NVM Set Institutional Basic Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request INSTIT_DATA_REJECT_REASON_T param[ NUM_OF_INSTIT_BASIC ]; ///< Reject reasons for each param of basic institutional record. }DD_NVM_SET_INSTIT_BASIC_REC_PAYLOAD_T; /// DD NVM Get Institutional Advanced Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_INSTIT_ADVANCED_RECORD_T data; ///< Data to be sent }DD_NVM_GET_INSTIT_ADVANCED_REC_PAYLOAD_T; /// DD NVM Set Institutional Advanced Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request INSTIT_DATA_REJECT_REASON_T param[ NUM_OF_INSTIT_ADVANCED ]; ///< Reject reasons for each param of advanced institutional record. }DD_NVM_SET_INSTIT_ADVANCED_REC_PAYLOAD_T; /// DD NVM Get Institutional Additional Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_INSTIT_ADDITIONAL_RECORD_T data; ///< Data to be sent }DD_NVM_GET_INSTIT_ADDITIONAL_REC_PAYLOAD_T; /// DD NVM Set Institutional Additional Record Response Payload typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request INSTIT_DATA_REJECT_REASON_T param[ NUM_OF_INSTIT_ADDITIONAL ]; ///< Reject reasons for each param of Additional institutional record. }DD_NVM_SET_INSTIT_ADDITIONAL_REC_PAYLOAD_T; /// Linear reject reason calibration structure typedef struct { U32 gainRejectReason; ///< Reason to reject linear calibration record parameter gain. U32 offsetRejectReason; ///< Reason to reject linear calibration record parameter offset. U32 calibrationTimeRejectReason; ///< Reason to reject linear calibration record parameter calibrationTime. } LINEAR_REJECT_REASON_CAL_PAYLOAD_T; /// DD NVM Get Record Payload for Linear structures Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. U08 idx; ///< Index of sensor / pump / concentrates LINEAR_CAL_PAYLOAD_T data; ///< Data to be sent } DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for Linear structures Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 idxRejectReason; ///< Reason to reject sensor index of the calibration record LINEAR_REJECT_REASON_CAL_PAYLOAD_T data; ///< Linear record reject reasons } DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for D12 Pump Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_D12_DIALYSATE_PUMP_RECORD_T data; ///< Data to be sent } DD_NVM_GET_D12_PUMP_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for D12 Pump Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 targetPumpSpeedRejectReason; ///< Reason to reject D12 pump calibration record parameter targetPumpSpeed U32 calibrationTimeRejectReason; ///< Reason to reject D12 pump calibration record parameter calibrationTime } DD_NVM_SET_D12_PUMP_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for D48 Pump Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. LINEAR_CAL_PAYLOAD_T data; ///< Data to be sent } DD_NVM_GET_D48_PUMP_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for D48 Pump Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request LINEAR_REJECT_REASON_CAL_PAYLOAD_T data; ///< Reason to reject D48 pump calibration record parameter } DD_NVM_SET_D48_PUMP_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for Acid Concentrate Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. U08 idx; ///< Index of acid concentrates DD_ACID_CONCENTRATE_T data; ///< Data to be sent } DD_NVM_GET_ACID_CONC_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for Acid Concentrate Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 idxRejectReason; ///< Reason to reject Acid Conc index U32 acidConcMixRatioRejectReason; ///< Reason to reject Acid Conc calibration record parameter acidConcMixRatio U32 acidFullBottleVolumeMLRejectReason; ///< Reason to reject Acid Conc calibration record parameter acidFullBottleVolumeML U32 acidConductivityUSPerCMRejectReason; ///< Reason to reject Acid Conc calibration record parameter acidConductivityUSPerCM U32 acidBottleTemperatureRejectReason; ///< Reason to reject Acid Conc calibration record parameter acidBottleTemperature U32 calibrationTimeRejectReason; ///< Reason to reject Acid Conc calibration record parameter calibrationTime } DD_NVM_SET_ACID_CONC_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for Bicarb Concentrate Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. U08 idx; ///< Index of bicarb concentrates DD_BICARB_CONCENTRATE_T data; ///< Data to be sent } DD_NVM_GET_BICARB_CONC_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for Bicarb Concentrate Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U08 idxRejectReason; ///< Reason to reject bicarb Conc index U32 bicarbConcMixRatioRejectReason; ///< Reason to reject bicarb Conc calibration record parameter bicarbConcMixRatio U32 bicarbStartVolumeMLRejectReason; ///< Reason to reject bicarb Conc calibration record parameter bicarbStartVolumeML U32 bicarbConductivityUSPerCMRejectReason; ///< Reason to reject bicarb Conc calibration record parameter bicarbConductivityUSPerCM U32 bicarbBottleTemperatureRejectReason; ///< Reason to reject bicarb Conc calibration record parameter bicarbBottleTemperature U32 calibrationTimeRejectReason; ///< Reason to reject bicarb Conc calibration record parameter calibrationTime } DD_NVM_SET_BICARB_CONC_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for Accelerometer Sensor Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_ACCEL_SENSOR_CAL_RECORD_T data; ///< Data to be sent } DD_NVM_GET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for Accelerometer Sensor Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 accelXOffsetRejectReason; ///< Reason to reject accel sensor calibration record parameter accelXOffset U32 accelYOffsetRejectReason; ///< Reason to reject accel sensor calibration record parameter accelYOffset U32 accelZOffsetRejectReason; ///< Reason to reject accel sensor calibration record parameter accelZOffset U32 calibrationTimeRejectReason; ///< Reason to reject accel sensor calibration record parameter calibrationTime } DD_NVM_SET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for Blood Leak Sensor Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T data; ///< Data to be sent } DD_NVM_GET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for Blood Leak Sensor Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 setPointRejectReason; ///< Reason to reject blood leak sensor calibration record parameter setPoint U32 calibrationTimeRejectReason; ///< Reason to reject blood leak sensor calibration record parameter calibrationTime } DD_NVM_SET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T; /// DD NVM Get Record Payload for Conductivity Sensor Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Rejection reason if not accepted. U08 idx; ///< Index of conductivity sensor CONDUCTIVITY_COEFFICIENTS_T data; ///< Data to be sent } DD_NVM_GET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T; /// DD NVM Set Record Payload for Conductivity Sensor Calibration Data typedef struct { BOOL accepted; ///< Accepted/Rejected U32 rejectionReason; ///< Reason to reject the entire request U32 idxRejectReason; ///< Reason to reject conductivity sensor index U32 K_highRejectReason; ///< Reason to reject conductivity sensor calibration record parameter K_high U32 alpha_higRejectReason; ///< Reason to reject conductivity sensor calibration record parameter alpha_high U32 eta_highRejectReason; ///< Reason to reject conductivity sensor calibration record parameter eta_high U32 zeta_highRejectReason; ///< Reason to reject conductivity sensor calibration record parameter zeta_high U32 K_lowRejectReason; ///< Reason to reject conductivity sensor calibration record parameter K_low U32 alpha_lowRejectReason; ///< Reason to reject conductivity sensor calibration record parameter alpha_low U32 eta_lowRejectReason; ///< Reason to reject conductivity sensor calibration record parameter eta_low U32 zeta_lowRejectReason; ///< Reason to reject conductivity sensor calibration record parameter zeta_low U32 betaRejectReason; ///< Reason to reject conductivity sensor calibration record parameter beta U32 deltaRejectReason; ///< Reason to reject conductivity sensor calibration record parameter delta U32 reserved1RejectReason; ///< Reason to reject conductivity sensor calibration record parameter reserved1 U32 reserved2RejectReason; ///< Reason to reject conductivity sensor calibration record parameter reserved2 U32 calibrationTimeRejectReason; ///< Reason to reject conductivity sensor calibration record parameter calibrationTime } DD_NVM_SET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T; #pragma pack(pop) // ********** private data ********** static SEND_RECORD_STATE_T nvMExecSendRecordState; ///< NVM exec process record state. static U32 newRecordStartTimer; ///< New record availability start timer. static BOOL isNewCalRecordAvailable; ///< Signal to indicate whether a new NVM data is available. static NV_DATA_T recordToPublish; ///< Record type which is being processed currently for sending static NV_DATA_T nvPublishRecordType; ///< Used to index over isPublishRecordRequested in the idle state static U32 recordSendDataIntervalCounter; ///< Record data send to CAN bust interval counter. static U32 sendRetryCount; ///< Counter for number of retries to send a record static U08 sendCalIdx; ///< Current Index of sensor calibration data to be sent static BOOL isPublishRecordRequested[ NUM_OF_NV_DD_DATA ]; ///< Record state machine publish request flag. // ********** private function prototypes ********** // Process record functions static SEND_RECORD_STATE_T handleExecSendRecordIdleState( void ); static SEND_RECORD_STATE_T handleExecSendRecordSendState( void ); static SEND_RECORD_STATE_T handleSendDDSystemRecord( void ); static SEND_RECORD_STATE_T handleSendDDServiceRecord( void ); static SEND_RECORD_STATE_T handleSendDDUsageInfoRecord( void ); static SEND_RECORD_STATE_T handleSendDDInstitBasicRecord( void ); static SEND_RECORD_STATE_T handleSendDDInstitAdvancedRecord( void ); static SEND_RECORD_STATE_T handleSendDDInstitAdditionalRecord( void ); static SEND_RECORD_STATE_T handleSendPressureSensorCalRecord( void ); static SEND_RECORD_STATE_T handleSendTempSensorCalRecord( void ); static SEND_RECORD_STATE_T handleSendConcPumpCalRecord( void ); static SEND_RECORD_STATE_T handleSendD12PumpCalRecord( void ); static SEND_RECORD_STATE_T handleSendD48PumpCalRecord( void ); static SEND_RECORD_STATE_T handleSendAcidConcCalRecord( void ); static SEND_RECORD_STATE_T handleSendBicarbConcCalRecord( void ); static SEND_RECORD_STATE_T handleSendAccelSensorCalRecord( void ); static SEND_RECORD_STATE_T handleSendBloodLeakSensorCalRecord( void ); static SEND_RECORD_STATE_T handleSendConductivitySensorCalRecord( void ); static SEND_RECORD_STATE_T updateSendRetryCount( BOOL sendStatus ); static SEND_RECORD_STATE_T updateCalSendRetryCountAndIndex( BOOL sendStatus, U08 maxIdx ); static void monitorNewCalSignal( void ); /*********************************************************************//** * @brief * The initNVMessagingDD function initializes NV messaging related * states and variables. It resets send and receive states, flags, * counters, and timing values. * @details \b Inputs: None * @details \b Outputs: nvMExecSendRecordState, * nvmExecreceiveRecordState, newRecordStartTimer, * isNewCalRecordAvailable, nvPublishRecordType, * isPublishRecordRequested, recordPublishMsgCount, * recordPublishTotalMsgs, recordSendDataIntervalCounter, * previousRecordMessageNum, recordReceiveStartTime * @return None *************************************************************************/ void initNVMessagingDD( void ) { nvMExecSendRecordState = NVM_SEND_RECORD_STATE_IDLE; newRecordStartTimer = 0; isNewCalRecordAvailable = FALSE; nvPublishRecordType = NV_DD_DATA_SYSTEM_RECORD; recordSendDataIntervalCounter = 0; U32 i; for ( i = 0; i < NUM_OF_NV_DD_DATA; i++ ) { isPublishRecordRequested[ i ] = FALSE; } } /*********************************************************************//** * @brief * The execNVMPSendreceiveDDRecord function executes the NV record processing * state machines. It handles send and receive operations and monitors * for timeouts and calibration signals. * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT if invalid send state * @details \b Inputs: nvMExecSendRecordState, * nvmExecreceiveRecordState, recordReceiveStartTime * @details \b Outputs: nvMExecSendRecordState, * nvmExecreceiveRecordState * @return None *************************************************************************/ void execNVMPSendReceiveRecord( void ) { switch ( nvMExecSendRecordState ) { case NVM_SEND_RECORD_STATE_IDLE: nvMExecSendRecordState = handleExecSendRecordIdleState(); break; case NVM_SEND_RECORD_STATE_SEND: nvMExecSendRecordState = handleExecSendRecordSendState(); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_NVM_INVALID_EXEC_SEND_STATE, ( U32 )nvMExecSendRecordState ); nvMExecSendRecordState = NVM_SEND_RECORD_STATE_IDLE; break; } // if( nvmExecreceiveRecordState == NVM_RECEIVE_RECORD_STATE_RECEIVE ) // { // if ( ( NVM_CALIBRATION_RECORD == currentRxRecordType ) && // ( TRUE == didTimeout( calRecordReceiveStartTime, RECORD_DATA_RECEIVE_TIMEOUT_MS ) ) ) // { // updateRecordCRC(NVM_CALIBRATION_RECORD); // enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); // startNewCalRecordAvailableTimer(); // setNewCalibrationRecordAvailable( TRUE ); // sendNVEvent( NVM_CALIBRATION_RECORD , 0, 0 ); // nvmExecreceiveRecordState = NVM_RECEIVE_RECORD_STATE_IDLE; // } // // if ( ( NVM_INSTITUTIONAL_RECORD == currentRxRecordType ) && // ( TRUE == didTimeout( institRecordReceiveStartTime, RECORD_DATA_RECEIVE_TIMEOUT_MS ) ) ) // { // updateRecordCRC(NVM_INSTITUTIONAL_RECORD); // enqueueEraseAndWriteSector( NVM_INSTITUTIONAL_RECORD ); // sendNVEvent( NVM_INSTITUTIONAL_RECORD , 0, 0 ); // nvmExecreceiveRecordState = NVM_RECEIVE_RECORD_STATE_IDLE; // } // } // Check the calibration signal monitorNewCalSignal(); } /*********************************************************************//** * @brief * The setNewCalibrationRecordAvailable function updates the flag * indicating new NV record availability. * @details \b Inputs: None * @details \b Outputs: isNewCalRecordAvailable * @param value Flag value to be updated * @return None *************************************************************************/ void setNewCalibrationRecordAvailable( BOOL isAvailable) { isNewCalRecordAvailable = isAvailable; } /*********************************************************************//** * @brief * The getNewCalRecordAvalability function gets the status of new * calibration record availability. * @details \b Inputs: isNewCalRecordAvailable * @details \b Outputs: None * @return TRUE if new calibration record is available otherwise FALSE *************************************************************************/ BOOL getNewCalRecordAvalability( void ) { return isNewCalRecordAvailable; } /*********************************************************************//** * @brief * The startNewCalRecordAvailableTimer function starts the time for * new calibration record availability. * @details \b Inputs: None * @details \b Outputs: newRecordStartTimer * @return None *************************************************************************/ void startNewCalRecordAvailableTimer( void ) { newRecordStartTimer = getMSTimerCount(); } /*********************************************************************//** * @brief * The handleExecSendRecordIdleState function handles the idle state of * the exec send record state machine. It prepares record data for * publishing when requested. * @details \b Inputs: isPublishRecordRequested, * nvPublishRecordType * @details \b Outputs: isPublishRecordRequested, * recordPublishTotalMsgs, recordPublishMsgCount, * recordSendDataIntervalCounter, nvPublishRecordType, * recordToPublish * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleExecSendRecordIdleState( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_IDLE; if ( TRUE == isPublishRecordRequested[ nvPublishRecordType ] ) { recordToPublish = nvPublishRecordType; // Set the publish flag to FALSE isPublishRecordRequested[ recordToPublish ] = FALSE; // 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; state = NVM_SEND_RECORD_STATE_SEND; } nvPublishRecordType = ( NV_DATA_T )( nvPublishRecordType + 1 ); if( nvPublishRecordType >= NUM_OF_NV_DD_DATA ) { nvPublishRecordType = NV_DD_DATA_SYSTEM_RECORD; } return state; } /*********************************************************************//** * @brief * The handleExecSendRecordSendState function handles the send state of * the exec send record state machine. It sends record data in chunks * based on timing and message count. * @details \b Inputs: recordPublishTotalMsgs, * recordPublishMsgCount, recordSendDataIntervalCounter, * recordToPublish * @details \b Outputs: recordPublishMsgCount, * recordSendDataIntervalCounter * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleExecSendRecordSendState( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; // If it is time to send data if ( ++recordSendDataIntervalCounter >= RECORD_DATA_SEND_INTERVAL_COUNT ) { switch ( recordToPublish ) { case NV_DD_DATA_SYSTEM_RECORD: state = handleSendDDSystemRecord(); break; case NV_DD_DATA_SERVICE_RECORD: state = handleSendDDServiceRecord(); break; case NV_DD_DATA_CAL_PRESSURE_SENOSRS: state = handleSendPressureSensorCalRecord(); break; case NV_DD_DATA_CAL_TEMPERATURE_SENSORS: state = handleSendTempSensorCalRecord(); break; case NV_DD_DATA_CAL_CONCENTRATE_PUMPS_RECORD: state = handleSendConcPumpCalRecord(); break; case NV_DD_DATA_CAL_D12_PUMP_RECORD: state = handleSendD12PumpCalRecord(); break; case NV_DD_DATA_CAL_D48_PUMP_RECORD: state = handleSendD48PumpCalRecord(); break; case NV_DD_DATA_CAL_ACID_CONCENTREATES: state = handleSendAcidConcCalRecord(); break; case NV_DD_DATA_CAL_BICARB_CONCENTRATES: state = handleSendBicarbConcCalRecord(); break; case NV_DD_DATA_CAL_ACCELEROMETER_SENSOR: state = handleSendAccelSensorCalRecord(); break; case NV_DD_DATA_CAL_BLOOD_LEAK_SENSOR: state = handleSendBloodLeakSensorCalRecord(); break; case NV_DD_DATA_CAL_CONDUCTIVITY_SENSORS: state = handleSendConductivitySensorCalRecord(); break; case NV_DD_DATA_INSTIT_BASIC_RECORD: state = handleSendDDInstitBasicRecord(); break; case NV_DD_DATA_INSTIT_ADVANCED_RECORD: state = handleSendDDInstitAdvancedRecord(); break; case NV_DD_DATA_INSTIT_ADDITIONAL_RECORD: state = handleSendDDInstitAdditionalRecord(); break; case NV_DD_DATA_USAGE_INFO_RECORD: state = handleSendDDUsageInfoRecord(); break; default: break; } recordSendDataIntervalCounter = 0; } return state; } /*********************************************************************//** * @brief * The handleSendDDSystemRecord function sends the DD system record. * It retries transmission on failure and returns to the idle state * after a successful send or when retries are exhausted. * @details \b Inputs: None * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendDDSystemRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_SYSTEM_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_SYSTEM_RECORD, (U08*)&payload.data, sizeof( DD_SYSTEM_RECORD_T ) , 0, ALARM_ID_DD_NVM_INVALID_SYSTEM_RECORD_CRC ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_SYSTEM_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_SYSTEM_REC_PAYLOAD_T ) ); } state = updateSendRetryCount( sendStatus ); return state; } /*********************************************************************//** * @brief * The handleSendDDServiceRecord function sends the DD service record. * It retries transmission on failure and returns to the idle state * after a successful send or when retries are exhausted. * @details \b Inputs: None * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendDDServiceRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_SERVICE_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_SERVICE_RECORD, (U08*)&payload.data, sizeof( DD_SERVICE_RECORD_T ) , 0, ALARM_ID_DD_NVM_INVALID_SERVICE_RECORD_CRC ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_SERVICE_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_SERVICE_REC_PAYLOAD_T ) ); } state = updateSendRetryCount( sendStatus ); return state; } /*********************************************************************//** * @brief * The handleSendDDUsageInfoRecord function sends the DD usage * information record. It retries transmission on failure and returns * to the idle state after a successful send or when retries are * exhausted. * @details \b Inputs: None * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendDDUsageInfoRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_USAGE_INFO_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_USAGE_INFO_RECORD, (U08*)&payload.data, sizeof( DD_USAGE_INFO_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_USAGE_RECORD_CRC ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_USAGE_INFO_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_USAGE_INFO_REC_PAYLOAD_T ) ); } state = updateSendRetryCount( sendStatus ); return state; } /*********************************************************************//** * @brief * The handleSendDDInstitBasicRecord function sends the DD basic * institutional record. It retries transmission on failure and returns * to the idle state after a successful send or when retries are * exhausted. * @details \b Inputs: None * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendDDInstitBasicRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_INSTIT_BASIC_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_INSTIT_BASIC_RECORD, (U08*)&payload.data, sizeof( DD_INSTIT_BASIC_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_INSTIT_BASIC_RECORD_CRC ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_INSTIT_BASIC_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_INSTIT_BASIC_REC_PAYLOAD_T ) ); } state = updateSendRetryCount( sendStatus ); return state; } /*********************************************************************//** * @brief * The handleSendDDInstitAdvancedRecord function sends the DD advanced * institutional record. It retries transmission on failure and returns * to the idle state after a successful send or when retries are * exhausted. * @details \b Inputs: None * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendDDInstitAdvancedRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_INSTIT_ADVANCED_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_INSTIT_ADVANCED_RECORD, (U08*)&payload.data, sizeof( DD_INSTIT_ADVANCED_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_INSTIT_ADVANCED_RECORD_CRC ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_INSTIT_ADVANCED_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_INSTIT_ADVANCED_REC_PAYLOAD_T ) ); } state = updateSendRetryCount( sendStatus ); return state; } /*********************************************************************//** * @brief * The handleSendDDInstitAdditionalRecord function sends the DD additional * institutional record. It retries transmission on failure and returns * to the idle state after a successful send or when retries are * exhausted. * @details \b Inputs: None * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendDDInstitAdditionalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_INSTIT_ADDITIONAL_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_INSTIT_ADDITIONAL_RECORD, (U08*)&payload.data, sizeof( DD_INSTIT_ADDITIONAL_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_INSTIT_ADDITIONAL_RECORD_CRC ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_INSTIT_ADDITIONAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_INSTIT_ADDITIONAL_REC_PAYLOAD_T ) ); } state = updateSendRetryCount( sendStatus ); return state; } /*********************************************************************//** * @brief * The handleSendPressureSensorCalRecord function sends the calibration * record of the selected pressure sensor. * @details \b Inputs: sendCalIdx * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendPressureSensorCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T payload; DD_PRES_SENSORS_CAL_RECORD_T record; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_PRESSURE_SENOSRS, (U08*)&record, sizeof( DD_PRES_SENSORS_CAL_RECORD_T ), NUM_OF_PRESSURE_SENSORS, ALARM_ID_DD_NVM_INVALID_CAL_PRESSURE_SENSOR ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; payload.idx = sendCalIdx; payload.data = record.pressureSensors[ sendCalIdx ]; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_PRESSURE_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, NUM_OF_PRESSURE_SENSORS ); return state; } /*********************************************************************//** * @brief * The handleSendTempSensorCalRecord function sends the calibration record * of the selected temperature sensor. * @details \b Inputs: sendCalIdx * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendTempSensorCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T payload; DD_TEMP_SENSORS_CAL_RECORD_T record; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_TEMPERATURE_SENSORS, (U08*)&record, sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ), NUM_OF_TEMPERATURE_SENSORS, ALARM_ID_DD_NVM_INVALID_CAL_TEMP_SENSOR ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; payload.idx = sendCalIdx; payload.data = record.tempSensors[ sendCalIdx ]; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_TEMPERATURE_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, NUM_OF_TEMPERATURE_SENSORS ); return state; } /*********************************************************************//** * @brief * The handleSendConcPumpCalRecord function sends the calibration record * of the selected concentrate pump. * @details \b Inputs: sendCalIdx * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendConcPumpCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T payload; DD_CONC_PUMPS_CAL_RECORD_T record; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_CONCENTRATE_PUMPS_RECORD, (U08*)&record, sizeof( DD_CONC_PUMPS_CAL_RECORD_T ), NUM_OF_CONCENTRATE_PUMPS, ALARM_ID_DD_NVM_INVALID_CAL_CONC_PUMP ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; payload.idx = sendCalIdx; payload.data = record.concentratePumps[ sendCalIdx ]; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_CONC_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, NUM_OF_CONCENTRATE_PUMPS ); return state; } /*********************************************************************//** * @brief * The handleSendD12PumpCalRecord function sends the calibration record of * the D12 dialysate pump. * @details \b Inputs: None * @details \b Outputs: sendCalIdx * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendD12PumpCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_D12_PUMP_CAL_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_D12_PUMP_RECORD, (U08*)&payload.data, sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_CAL_D12_PUMP ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; sendCalIdx = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_D12_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_D12_PUMP_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, 0 ); return state; } /*********************************************************************//** * @brief * The handleSendD48PumpCalRecord function sends the calibration record of * the D48 dialysate pump. * @details \b Inputs: None * @details \b Outputs: sendCalIdx * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendD48PumpCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_D48_PUMP_CAL_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_D48_PUMP_RECORD, (U08*)&payload.data, sizeof( DD_D48_DIALYSATE_PUMP_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_CAL_D48_PUMP ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; sendCalIdx = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_D48_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_D48_PUMP_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, 0 ); return state; } /*********************************************************************//** * @brief * The handleSendAcidConcCalRecord function sends the calibration record of * the selected acid concentrate. * @details \b Inputs: sendCalIdx * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendAcidConcCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_ACID_CONC_CAL_REC_PAYLOAD_T payload; DD_ACID_CONCENTRATES_RECORD_T record; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_ACID_CONCENTREATES, (U08*)&record, sizeof( DD_ACID_CONCENTRATES_RECORD_T ), NUM_OF_ACID_TYPE, ALARM_ID_DD_NVM_INVALID_CAL_ACID_CONCENTRATE ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; payload.idx = sendCalIdx; payload.data = record.acidConcentrate[ sendCalIdx ]; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_ACID_CONC_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_ACID_CONC_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, NUM_OF_ACID_TYPE ); return state; } /*********************************************************************//** * @brief * The handleSendAcidConcCalRecord function sends the calibration record of * the selected acid concentrate. * @details \b Inputs: sendCalIdx * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendBicarbConcCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_BICARB_CONC_CAL_REC_PAYLOAD_T payload; DD_BICARB_CONCENTRATES_RECORD_T record; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_BICARB_CONCENTRATES, (U08*)&record, sizeof( DD_BICARB_CONCENTRATES_RECORD_T ), NUM_OF_BICARB_TYPE, ALARM_ID_DD_NVM_INVALID_CAL_BICARB_CONCENTRATE ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; payload.idx = sendCalIdx; payload.data = record.bicarbConcentrate[ sendCalIdx ]; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_BICARB_CONC_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_BICARB_CONC_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, NUM_OF_BICARB_TYPE ); return state; } /*********************************************************************//** * @brief * The handleSendAccelSensorCalRecord function sends the calibration record * of the accelerometer sensor. * @details \b Inputs: None * @details \b Outputs: sendCalIdx * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendAccelSensorCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_ACCELEROMETER_SENSOR, (U08*)&payload.data, sizeof( DD_ACCEL_SENSOR_CAL_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_CAL_ACCEL_SENSOR ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; sendCalIdx = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_ACCEL_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, 0 ); return state; } /*********************************************************************//** * @brief * The handleSendBloodLeakSensorCalRecord function sends the calibration * record of the blood leak sensor. * @details \b Inputs: None * @details \b Outputs: sendCalIdx * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendBloodLeakSensorCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T payload; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_BLOOD_LEAK_SENSOR, (U08*)&payload.data, sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ), 0, ALARM_ID_DD_NVM_INVALID_CAL_BLOOD_LEAK_SENSOR ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; sendCalIdx = 0; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_BLOOD_LEAK_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, 0 ); return state; } /*********************************************************************//** * @brief * The handleSendConductivitySensorCalRecord function sends the calibration * record of the conductivity sensor. * @details \b Inputs: sendCalIdx * @details \b Outputs: None * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T handleSendConductivitySensorCalRecord( void ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL sendStatus = FALSE; DD_NVM_GET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T payload; DD_CONDUCTIVITY_SENSOR_CAL_RECORD_T record; // Get the record if ( TRUE == getNVMRecord( NV_DD_DATA_CAL_CONDUCTIVITY_SENSORS, (U08*)&record, sizeof( DD_CONDUCTIVITY_SENSOR_CAL_RECORD_T ), NUM_OF_CONDUCTIVITY_SENSORS, ALARM_ID_DD_NVM_INVALID_CAL_CONDUCTIVITY_SENSOR ) ) { payload.accepted = TRUE; payload.rejectionReason = 0; payload.idx = sendCalIdx; payload.data = record.condSensors[ sendCalIdx ]; // Send the record sendStatus = sendMessage( MSG_ID_DD_UI_NVM_GET_CONDUCTIVITY_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&payload, sizeof( DD_NVM_GET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T ) ); } state = updateCalSendRetryCountAndIndex( sendStatus, NUM_OF_CONDUCTIVITY_SENSORS ); return state; } /*********************************************************************//** * @brief * The monitorNewCalSignal function monitors the new calibration signal * and clears it when the timeout has elapsed. * @details \b Inputs: isNewCalRecordAvailable, * newRecordStartTimer * @details \b Outputs: isNewCalRecordAvailable * @return None *************************************************************************/ static void monitorNewCalSignal( void ) { // Check if new calibration record is available and // the timer has elapsed if ( ( TRUE == didTimeout( newRecordStartTimer, NEW_CAL_AVAILABLE_SIGNAL_TIMEOUT_MS ) ) && ( TRUE == getNewCalRecordAvalability() ) ) { // Clear the new calibration record available flag setNewCalibrationRecordAvailable( FALSE ); } } /*********************************************************************//** * @brief * The updateSendRetryCount function updates the retry counts and * record to be published based on the send status. * @details \b Inputs: None * @details \b Outputs: recordToPublish, sendRetryCount * @param sendStatus True if record was sent successfully, otherwise FALSE. * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T updateSendRetryCount( BOOL sendStatus ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; // Check if record send successfully if ( TRUE == sendStatus ) { // Reset the retry count sendRetryCount = 0; // Clear the publishing flags recordToPublish = NUM_OF_NV_DD_DATA; // 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_NV_DD_DATA; // Move to Send Idle State state = NVM_SEND_RECORD_STATE_IDLE; } return state; } /*********************************************************************//** * @brief * The updateCalSendRetryCountAndIndex function updates the retry counts, * sensor index, record to be published based on the send status of the calibration data. * @details \b Inputs: None * @details \b Outputs: recordToPublish, sendRetryCount, sendCalIdx * @param sendStatus True if record was sent successfully, otherwise FALSE. * @@param maxIdx Maximum Index value of the current calibration item being sent * @return state next state of the state machine *************************************************************************/ static SEND_RECORD_STATE_T updateCalSendRetryCountAndIndex( BOOL sendStatus, U08 maxIdx ) { SEND_RECORD_STATE_T state = NVM_SEND_RECORD_STATE_SEND; BOOL resetState = FALSE; // Check if record was sent successfully if ( TRUE == sendStatus) { sendCalIdx++; sendRetryCount = 0; // Check if we sent the last record of calibration component if ( sendCalIdx >= maxIdx ) { resetState = TRUE; } } else { sendRetryCount ++; } // If all the allowed retries has been utilized or if ( sendRetryCount >= MAX_NUM_OF_SEND_RETRIES ) { resetState = TRUE; } if ( TRUE == resetState) { // Reset Sensor Index for the next request sendCalIdx = 0; // Reset the retry count sendRetryCount = 0; // Clear the publishing flags recordToPublish = NUM_OF_NV_DD_DATA; // Move to Send Idle State state = NVM_SEND_RECORD_STATE_IDLE; } return state; } BOOL handleDDGetSystemRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_SYSTEM_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_SYSTEM_RECORD ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_SYSTEM_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_SYSTEM_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetSystemRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08 expectedPayloadLen = sizeof( DD_SYSTEM_RECORD_T ) - sizeof( U16 ); DD_NVM_SET_SYSTEM_REC_PAYLOAD_T response = { 0 }; DD_SYSTEM_RECORD_T record; // System record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &record, message->payload, expectedPayloadLen ); setNVMMRecord( NV_DD_DATA_SYSTEM_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_SYSTEM_RECORD ); sendNVEvent( NVM_SYSTEM_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_SYSTEM_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_SYSTEM_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetServicRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_SERVICE_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_SERVICE_RECORD ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_SERVICE_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_SERVICE_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetServicRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08 expectedPayloadLen = sizeof( DD_SERVICE_RECORD_T ) - sizeof( U16 ); DD_NVM_SET_SERVICE_REC_PAYLOAD_T response = { 0 }; DD_SERVICE_RECORD_T record; // Service record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &record, message->payload, expectedPayloadLen ); setNVMMRecord( NV_DD_DATA_SERVICE_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_SERVICE_RECORD ); sendNVEvent( NVM_SERVICE_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_SERVICE_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_SERVICE_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetUsageInfoRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_USAGE_INFO_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_USAGE_INFO_RECORD ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_USAGE_INFO_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_USAGE_INFO_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetUsageInfoRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08 expectedPayloadLen = sizeof( DD_USAGE_INFO_RECORD_T ) - sizeof( U16 ); DD_NVM_SET_USAGE_INFO_REC_PAYLOAD_T response = { 0 }; DD_USAGE_INFO_RECORD_T record; if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &record, message->payload, expectedPayloadLen ); setNVMMRecord( NV_DD_DATA_USAGE_INFO_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_USAGE_INFO_RECORD ); sendNVEvent( NVM_USAGE_INFO_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } sendMessage( MSG_ID_DD_UI_NVM_SET_USAGE_INFO_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_USAGE_INFO_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetInstitBasicRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_INSTIT_BASIC_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_INSTIT_BASIC_RECORD ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_INSTIT_BASIC_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_INSTIT_BASIC_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetInstitBasicRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08 expectedPayloadLen = sizeof( DD_INSTIT_BASIC_RECORD_T ) - sizeof( U16 ); DD_NVM_SET_INSTIT_BASIC_REC_PAYLOAD_T response = { 0 }; DD_INSTIT_BASIC_RECORD_T record; if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &record, message->payload, expectedPayloadLen ); record.crc = crc16( (U08*)&record, sizeof( DD_INSTIT_BASIC_RECORD_T ) - sizeof( U16 ) ); setNVMMRecord( NV_DD_DATA_INSTIT_BASIC_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_INSTITUTIONAL_RECORD ); sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } sendMessage( MSG_ID_DD_UI_NVM_SET_INSTIT_BASIC_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_INSTIT_BASIC_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetInstitAdvancedRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_INSTIT_ADVANCED_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_INSTIT_ADVANCED_RECORD ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_INSTIT_ADVANCED_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_INSTIT_ADVANCED_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetInstitAdvancedRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08 expectedPayloadLen = sizeof( DD_INSTIT_ADVANCED_RECORD_T ) - sizeof( U16 ); DD_NVM_SET_INSTIT_ADVANCED_REC_PAYLOAD_T response = { 0 }; DD_INSTIT_ADVANCED_RECORD_T record; if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &record, message->payload, expectedPayloadLen ); record.crc = crc16( (U08*)&record, sizeof( DD_INSTIT_ADVANCED_RECORD_T ) - sizeof( U16 ) ); setNVMMRecord( NV_DD_DATA_INSTIT_ADVANCED_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_INSTITUTIONAL_RECORD ); sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } sendMessage( MSG_ID_DD_UI_NVM_SET_INSTIT_ADVANCED_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_INSTIT_ADVANCED_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetInstitAdditionalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_INSTIT_ADDITIONAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_INSTIT_ADDITIONAL_RECORD ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_INSTIT_ADDITIONAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_INSTIT_ADDITIONAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetInstitAdditionalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08 expectedPayloadLen = sizeof( DD_INSTIT_ADDITIONAL_RECORD_T ) - sizeof( U16 ); DD_NVM_SET_INSTIT_ADDITIONAL_REC_PAYLOAD_T response = { 0 }; DD_INSTIT_ADDITIONAL_RECORD_T record; if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &record, message->payload, expectedPayloadLen ); record.crc = crc16( (U08*)&record, sizeof( DD_INSTIT_ADDITIONAL_RECORD_T ) - sizeof( U16 ) ); setNVMMRecord( NV_DD_DATA_INSTIT_ADDITIONAL_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_INSTITUTIONAL_RECORD ); sendNVEvent( NVM_INSTITUTIONAL_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } sendMessage( MSG_ID_DD_UI_NVM_SET_INSTIT_ADDITIONAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_INSTIT_ADDITIONAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetPressureSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_PRESSURE_SENOSRS ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_PRESSURE_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetPressureSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( LINEAR_CAL_PAYLOAD_T ) - sizeof( U16 ); // Data - CRC U08 expectedPayloadLen = sizeof( U08 ) + recordSize; // Index + Data - CRC DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T response = { 0 }; U08 idx; LINEAR_CAL_PAYLOAD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &idx, payloadPtr, sizeof(U08)); payloadPtr += sizeof(U08); if( idx < NUM_OF_PRESSURE_SENSORS ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_PRESSURE_SENOSRS, (U08*)&record, idx ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.idxRejectReason = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; } } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_PRESSURE_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetTemperatureSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_TEMPERATURE_SENSORS ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_TEMPERATURE_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetTemperatureSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( LINEAR_CAL_PAYLOAD_T ) - sizeof( U16 ); // Data - CRC U08 expectedPayloadLen = sizeof( U08 ) + recordSize; // Index + Data - CRC DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T response = { 0 }; U08 idx; LINEAR_CAL_PAYLOAD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &idx, payloadPtr, sizeof(U08)); payloadPtr += sizeof(U08); if( idx < NUM_OF_TEMPERATURE_SENSORS ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_TEMPERATURE_SENSORS, (U08*)&record, idx ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.idxRejectReason = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; } } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_TEMPERATURE_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetConcPumpCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_CONCENTRATE_PUMPS_RECORD] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_CONC_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_LINEAR_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetConcPumpCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( LINEAR_CAL_PAYLOAD_T ) - sizeof( U16 ); // Data - CRC U08 expectedPayloadLen = sizeof( U08 ) + recordSize; // Index + Data - CRC DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T response = { 0 }; U08 idx; LINEAR_CAL_PAYLOAD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &idx, payloadPtr, sizeof(U08)); payloadPtr += sizeof(U08); if( idx < NUM_OF_CONCENTRATE_PUMPS ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_CONCENTRATE_PUMPS_RECORD, (U08*)&record, idx ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.idxRejectReason = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; } } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_CONC_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_LINEAR_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetD12PumpCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_D12_PUMP_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_D12_PUMP_RECORD] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_D12_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_D12_PUMP_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetD12PumpCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( DD_D12_DIALYSATE_PUMP_RECORD_T ) - sizeof( U16 ); // Data - CRC DD_NVM_SET_D12_PUMP_CAL_REC_PAYLOAD_T response = { 0 }; DD_D12_DIALYSATE_PUMP_RECORD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == recordSize ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_D12_PUMP_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_D12_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_D12_PUMP_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetD48PumpCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_D48_PUMP_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_D48_PUMP_RECORD] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_D48_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_D48_PUMP_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetD48PumpCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( DD_D48_DIALYSATE_PUMP_RECORD_T ) - sizeof( U16 ); // Data - CRC DD_NVM_SET_D48_PUMP_CAL_REC_PAYLOAD_T response = { 0 }; DD_D48_DIALYSATE_PUMP_RECORD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == recordSize ) { memcpy( &record, payloadPtr, recordSize ); record.d48DialysatePump.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_D48_PUMP_RECORD, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_D48_PUMP_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_D48_PUMP_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetAcidConcCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_ACID_CONC_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_ACID_CONCENTREATES] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_ACID_CONC_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_ACID_CONC_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetAcidConcCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( DD_ACID_CONCENTRATE_T ) - sizeof( U16 ); // Data - CRC U08 expectedPayloadLen = sizeof( U08 ) + recordSize; // Index + Data - CRC DD_NVM_SET_ACID_CONC_CAL_REC_PAYLOAD_T response = { 0 }; U08 idx; DD_ACID_CONCENTRATE_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &idx, payloadPtr, sizeof(U08)); payloadPtr += sizeof(U08); if( idx < NUM_OF_ACID_TYPE ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_ACID_CONCENTREATES, (U08*)&record, idx ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.idxRejectReason = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; } } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_ACID_CONC_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_ACID_CONC_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetBicarbConcCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_BICARB_CONC_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_BICARB_CONCENTRATES] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_BICARB_CONC_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_BICARB_CONC_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetBicarbConcCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( DD_BICARB_CONCENTRATE_T ) - sizeof( U16 ); // Data - CRC U08 expectedPayloadLen = sizeof( U08 ) + recordSize; // Index + Data - CRC DD_NVM_SET_BICARB_CONC_CAL_REC_PAYLOAD_T response = { 0 }; U08 idx; DD_BICARB_CONCENTRATE_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == expectedPayloadLen ) { memcpy( &idx, payloadPtr, sizeof(U08)); payloadPtr += sizeof(U08); if( idx < NUM_OF_BICARB_TYPE ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_BICARB_CONCENTRATES, (U08*)&record, idx ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.idxRejectReason = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; } } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_BICARB_CONC_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_BICARB_CONC_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetAccelSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_ACCELEROMETER_SENSOR] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_ACCEL_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetAccelSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( DD_ACCEL_SENSOR_CAL_RECORD_T ) - sizeof( U16 ); // Data - CRC DD_NVM_SET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T response = { 0 }; DD_ACCEL_SENSOR_CAL_RECORD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == recordSize ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_ACCELEROMETER_SENSOR, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_ACCEL_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_ACCEL_SENSOR_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetBloodLeakSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_BLOOD_LEAK_SENSOR] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_BLOOD_LEAK_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetBloodLeakSensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ) - sizeof( U16 ); // Data - CRC DD_NVM_SET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T response = { 0 }; DD_BLOOD_LEAK_SENSOR_CAL_RECORD_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == recordSize ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_BLOOD_LEAK_SENSOR, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_BLOOD_LEAK_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_BLOOD_LEAK_SENSOR_CAL_REC_PAYLOAD_T ) ); return result; } BOOL handleDDGetConductivitySensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; DD_NVM_GET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T response; if ( NVM_SEND_RECORD_STATE_IDLE == nvMExecSendRecordState ) { isPublishRecordRequested[ NV_DD_DATA_CAL_CONDUCTIVITY_SENSORS ] = TRUE; result = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_JOB_QUEUE_BUSY; sendMessage( MSG_ID_DD_UI_NVM_GET_CONDUCTIVITY_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_GET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T ) ); } return result; } BOOL handleDDSetConductivitySensorCalRecRequest( MESSAGE_T *message ) { BOOL result = FALSE; U08* payloadPtr = message->payload; U08 recordSize = sizeof( CONDUCTIVITY_COEFFICIENTS_T ) - sizeof( U16 ); // Data - CRC DD_NVM_SET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T response = { 0 }; CONDUCTIVITY_COEFFICIENTS_T record; // Calibration record can be updated only in service mode if ( DD_MODE_SERV == getCurrentOperationMode() ) { if ( message->hdr.payloadLen == recordSize ) { memcpy( &record, payloadPtr, recordSize ); record.crc = crc16( (U08*)&record, recordSize ); setNVMMRecord( NV_DD_DATA_CAL_CONDUCTIVITY_SENSORS, (U08*)&record, 0 ); result = enqueueEraseAndWriteSector( NVM_CALIBRATION_RECORD ); sendNVEvent( NVM_CALIBRATION_RECORD, 0, 0 ); response.accepted = TRUE; } else { response.rejectionReason = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; } } else { response.rejectionReason = REQUEST_REJECT_REASON_NVM_INVALID_OPERATION_MODE; } sendMessage( MSG_ID_DD_UI_NVM_SET_CONDUCTIVITY_SENSOR_CAL_RECORD_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08 *)&response, sizeof( DD_NVM_SET_CONDUCTIVITY_SENSOR_CAL_REC_PAYLOAD_T ) ); return result; } /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ /*********************************************************************//** * @brief * The testSetNVRecordCRCOverride function overrides the CRC value of * the selected non-volatile record and schedules it for writing. * @details \b Inputs: None * @details \b Outputs: None * @param job The job whose CRC needs to be overridden * @param crc The CRC value to be set * @return TRUE if the job was scheduled successfully otherwise FALSE *************************************************************************/ BOOL testSetNVRecordCRCOverride( MESSAGE_T *message ) { BOOL result = FALSE; U32 job = 0; U16 crc = 0; U08* payloadPtr = message->payload; U08 expectedPayloadLen = sizeof( U32 ) + sizeof( U16 ); if ( message->hdr.payloadLen >= expectedPayloadLen ) { memcpy( &job, payloadPtr, sizeof( U32 ) ); payloadPtr += sizeof( U32 ); memcpy( &crc, payloadPtr, sizeof( U16 ) ); result = updateNVRecordCRC( job, crc ); } return result; } /**@}*/