Index: firmware/App/Services/SystemCommMessages.c =================================================================== diff -u -r544e9782a1b8d444224f41efef38a5204c262722 -r3af0043d8e0fe972945a576db4e3de3b4f260f4c --- firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 544e9782a1b8d444224f41efef38a5204c262722) +++ firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 3af0043d8e0fe972945a576db4e3de3b4f260f4c) @@ -1,40 +1,45 @@ /************************************************************************** * -* Copyright (c) 2019-2022 Diality Inc. - All Rights Reserved. +* Copyright (c) 2019-2023 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file SystemCommMessages.c * * @author (last) Dara Navaei -* @date (last) 25-May-2022 +* @date (last) 28-Mar-2023 * * @author (original) Dara Navaei * @date (original) 05-Nov-2019 * ***************************************************************************/ -#include // for memcpy() +#include // for memcpy() #include "reg_system.h" #include "Accel.h" #include "Compatible.h" #include "ConcentratePumps.h" #include "ConductivitySensors.h" +#include "CPLD.h" #include "Fans.h" +#include "FlowSensors.h" #include "FPGA.h" #include "Heaters.h" +#include "ModeChemicalDisinfect.h" +#include "ModeChemicalDisinfectFlush.h" #include "ModeFill.h" #include "ModeFlush.h" #include "ModeGenIdle.h" +#include "ModeHeatDisinfect.h" +#include "ModeHeatDisinfectActiveCool.h" #include "ModeInitPOST.h" #include "ModeStandby.h" #include "MsgQueues.h" #include "NVDataMgmt.h" #include "OperationModes.h" -#include "DialysateFlow.h" #include "Pressures.h" #include "Reservoirs.h" #include "RTC.h" @@ -76,7 +81,8 @@ // ********** private function prototypes ********** static BOOL sendTestAckResponseMsg( MSG_ID_T msgID, BOOL ack ); -static BOOL sendAckResponseMsg( MSG_ID_T msgID, COMM_BUFFER_T buffer, BOOL ack ); +static BOOL sendAckResponseMsg( MSG_ID_T msgID, COMM_BUFFER_T buffer, BOOL ack ); +static BOOL sendUIResponseMsg( MSG_ID_T msgID, BOOL accepted, U32 reason ); /*********************************************************************//** * @brief @@ -217,7 +223,39 @@ return result; } +/*********************************************************************//** + * @brief + * The sendUIResponseMsg function constructs an UI response message for a + * handled UI message and queues it for transmit on the appropriate CAN channel. + * @details Inputs: none + * @details Outputs: response message constructed and queued for transmit. + * @param msgID ID of handled message that we are responding to + * @param accepted T/F - request accepted? + * @param reason reason code if rejected + * @return TRUE if response message successfully queued for transmit, FALSE if not + *************************************************************************/ +static BOOL sendUIResponseMsg( MSG_ID_T msgID, BOOL accepted, U32 reason ) +{ + BOOL result; + MESSAGE_T msg; + UI_RESPONSE_PAYLOAD_T cmd; + cmd.accepted = accepted; + cmd.rejectionReason = reason; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = msgID; + msg.hdr.payloadLen = sizeof( UI_RESPONSE_PAYLOAD_T ); + memcpy( &msg.payload, &cmd, sizeof( UI_RESPONSE_PAYLOAD_T ) ); + + // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer + result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_2_UI, ACK_REQUIRED ); + + return result; +} + + // *********************************************************************** // ***************** Message Sending Helper Functions ******************** // *********************************************************************** @@ -301,6 +339,9 @@ payloadPtr += sizeof( U32 ); data = almData2.data.uInt.data; memcpy( payloadPtr, &data, sizeof( U32 ) ); + // Pad with space for 3 U32s - set to zero - unused for DG + payloadPtr += ( sizeof( U32) * 3 ); + memset( payloadPtr, 0, sizeof( U32) * 3 ); // serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_ALARM, ACK_REQUIRED ); @@ -390,6 +431,30 @@ /*********************************************************************//** * @brief + * The handleRTCSyncFromHD function handles an HD date/time broadcast message + * from the HD. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleRTCSyncFromHD( MESSAGE_T *message ) +{ + // Only sync RTC to HD date/time when ... + if ( TRUE == syncDG2HDDateTime() ) + { + if ( sizeof( RTC_DATA_T ) == message->hdr.payloadLen ) + { + RTC_DATA_T epoch; + + memcpy( &epoch, message->payload, sizeof( RTC_DATA_T ) ); + setRTCEpoch( epoch.epochTime ); + } + } +} + +/*********************************************************************//** + * @brief * The handleAlarmClear function handles a clear alarm message from the HD. * @details Inputs: none * @details Outputs: message handled @@ -427,6 +492,7 @@ if ( message->hdr.payloadLen == sizeof( DG_CMD_DIALYSATE_HEATING_PARAMS_T ) ) { DG_CMD_DIALYSATE_HEATING_PARAMS_T payload; + result = TRUE; memcpy( &payload, message->payload, sizeof( DG_CMD_DIALYSATE_HEATING_PARAMS_T ) ); setDialysateHeatingParameters( payload ); @@ -449,6 +515,11 @@ DG_VERSIONS_T payload; U08 *payloadPtr = msg.payload; + // create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_DG_VERSION_REPONSE; + msg.hdr.payloadLen = sizeof( DG_VERSIONS_T ); + if ( message->hdr.payloadLen == sizeof( U08 ) + sizeof( U08 ) + sizeof( U08 ) + sizeof( U16 ) + sizeof( U32 ) ) { // populate payload @@ -459,17 +530,12 @@ payload.compatibilityRev = (U32)SW_COMPATIBILITY_REV; getFPGAVersions( &payload.fpgaId, &payload.fpgaMajor, &payload.fpgaMinor, &payload.fpgaLab ); - // create a message record - blankMessage( &msg ); - msg.hdr.msgID = MSG_ID_DG_VERSION; - msg.hdr.payloadLen = sizeof( DG_VERSIONS_T ); - // fill message payload memcpy( payloadPtr, &payload, sizeof( DG_VERSIONS_T ) ); } // serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer - serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_BROADCAST, ACK_NOT_REQUIRED ); + serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_BROADCAST, ACK_REQUIRED ); } /*********************************************************************//** @@ -493,7 +559,7 @@ // Create a message record blankMessage( &msg ); - msg.hdr.msgID = MSG_ID_DG_SERIAL_NUMBER; + msg.hdr.msgID = MSG_ID_DG_SERIAL_NUMBER_RESPONSE; // Add 1 byte for null terminator msg.hdr.payloadLen = MAX_TOP_LEVEL_SN_CHARS + 1; @@ -520,27 +586,27 @@ { MESSAGE_T msg; DG_SERVICE_RECORD_T service; + U08 *payloadPtr = msg.payload; // Get the service record. There are no arrays of service to check and also, raise no alarm since the service record // has been already checked in POST getNVRecord2Driver( GET_SRV_RECORD, (U08*)&service, sizeof( DG_SERVICE_RECORD_T ), 0, ALARM_ID_NO_ALARM ); - U08 *payloadPtr = msg.payload; - if ( message->hdr.payloadLen == sizeof( U32 ) + sizeof( U32 ) ) - { - // Create a message record - blankMessage( &msg ); - msg.hdr.msgID = MSG_ID_DG_SERVICE_SCHEDULE_DATA; - msg.hdr.payloadLen = sizeof( U32 ) + sizeof( U32 ); + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_DG_SERVICE_SCHEDULE_DATA; + msg.hdr.payloadLen = sizeof( U32 ) + sizeof( U32 ); + if ( 0 == message->hdr.payloadLen ) + { // Fill message payload memcpy( payloadPtr, &service.lastServiceEpochDate, sizeof( U32 ) ); payloadPtr += sizeof( U32 ); memcpy( payloadPtr, &service.serviceIntervalSeconds, sizeof( U32 ) ); } // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer - serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_2_UI, ACK_REQUIRED ); + serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_2_HD, ACK_REQUIRED ); } /*********************************************************************//** @@ -555,14 +621,15 @@ void handleDGSendConcentrateMixingRatios( MESSAGE_T *message ) { MESSAGE_T msg; - - DG_ACID_CONCENTRATES_RECORD_T acid = getAcidConcentrateCalRecord(); - DG_BICARB_CONCENTRATES_RECORD_T bicarb = getBicarbConcentrateCalRecord(); + DG_ACID_CONCENTRATES_RECORD_T acid; + DG_BICARB_CONCENTRATES_RECORD_T bicarb; // By the time these are requested, the prepare time is no longer needed since the concentrate lines are // primed before the actual treatment starts - U32 fillPrepTimeMS = 0; + U32 fillPrepTimeMS = 0; + U08 *payloadPtr = msg.payload; - U08 *payloadPtr = msg.payload; + getAcidConcentrateCalRecord( &acid ); + getBicarbConcentrateCalRecord( &bicarb ); // Create a message record blankMessage( &msg ); @@ -700,45 +767,6 @@ /*********************************************************************//** * @brief - * The sendDGServiceRecord function sends out the DG service record. - * @details Inputs: none - * @details Outputs: DG system record msg constructed and queued - * @param msgCurrNum: current payload number - * @param msgTotalNum: total number of payloads - * @param length: buffer length to be written - * @param scheduledRcrdAddress: start address of the scheduled runs record - * @return TRUE if msg successfully queued for transmit, FALSE if not - *************************************************************************/ -BOOL sendDGScheduledRunsRecord( U32 payloadCurrNum, U32 payloadTotalNum, U32 length, U08* scheduledRcrdAddress ) -{ - BOOL result; - MESSAGE_T msg; - U08 *payloadPtr = msg.payload; - - // Create a message record - blankMessage( &msg ); - msg.hdr.msgID = MSG_ID_DG_SEND_SCHEDULED_RUNS_RECORD; - msg.hdr.payloadLen = sizeof( U32 ) + sizeof( U32 ) + sizeof( U32 ) + length; - - memcpy( payloadPtr, &payloadCurrNum, sizeof( U32 ) ); - payloadPtr += sizeof( U32 ); - - memcpy( payloadPtr, &payloadTotalNum, sizeof( U32 ) ); - payloadPtr += sizeof( U32 ); - - memcpy( payloadPtr, &length, sizeof( U32 ) ); - payloadPtr += sizeof( U32 ); - - memcpy( payloadPtr, scheduledRcrdAddress, length ); - - // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer - result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_PC, ACK_NOT_REQUIRED ); - - return result; -} - -/*********************************************************************//** - * @brief * The sendPOSTTestResult function constructs an DG POST test result message * and queues the msg for transmit on the appropriate CAN channel. * @details Inputs: none @@ -855,8 +883,6 @@ // has been already checked in POST getNVRecord2Driver( GET_SRR_RECORD, (U08*)&scheduledService, sizeof( DG_SCHEDULED_RUN_RECORD_T ), 0, ALARM_ID_NO_ALARM ); - U08 *payloadPtr = msg.payload; - // Create a message record blankMessage( &msg ); msg.hdr.msgID = MSG_ID_DG_SCHEDULED_RUNS_DATA; @@ -940,15 +966,16 @@ { BOOL result = FALSE; - if ( message->hdr.payloadLen == sizeof( U32 ) ) + if ( message->hdr.payloadLen == sizeof( DG_SWITCH_RSRVRS_CMD_T ) ) { - DG_RESERVOIR_ID_T reservoirID; - U32 resID; + DG_SWITCH_RSRVRS_CMD_T cmd; + memcpy( &cmd, message->payload, sizeof( DG_SWITCH_RSRVRS_CMD_T ) ); + + setActiveReservoirCmd( (DG_RESERVOIR_ID_T)cmd.reservoirID ); + setTrimmerHeaterUseLastDutyCycleStatus( cmd.useLastTrimmerHeaterDC ); + result = TRUE; - memcpy( &resID, message->payload, sizeof( U32 ) ); - reservoirID = (DG_RESERVOIR_ID_T)resID; - setActiveReservoirCmd( reservoirID ); } sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_HD, result ); @@ -969,11 +996,11 @@ if ( message->hdr.payloadLen == sizeof( U32 ) ) { - DG_VALVE_SETTING_ID_T valveSettingID; + U32 valveSettingID; result = TRUE; memcpy( &valveSettingID, message->payload, sizeof( U32 ) ); - changeValveSettingCmd( valveSettingID ); + changeValveSettingCmd( (DG_VALVE_SETTING_ID_T)valveSettingID ); } sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_HD, result ); @@ -1056,18 +1083,20 @@ { BOOL result = FALSE; - if ( message->hdr.payloadLen == sizeof( BOOL ) ) + if ( message->hdr.payloadLen == sizeof( DG_START_STOP_CMD_T ) ) { - BOOL startingTreatment; + DG_START_STOP_CMD_T startingTreatment; DG_OP_MODE_T dgMode = getCurrentOperationMode(); - memcpy( &startingTreatment, message->payload, sizeof( BOOL ) ); + memcpy( &startingTreatment, message->payload, sizeof( DG_START_STOP_CMD_T ) ); - if ( ( DG_MODE_STAN == dgMode ) && ( TRUE == startingTreatment ) ) + if ( ( DG_MODE_STAN == dgMode ) && ( TRUE == startingTreatment.startDG ) ) { + // If the command is start DG, set the acid and bicarb types to be used, otherwise in the stop command it does not matter + setAcidAndBicarbType( startingTreatment.acidType, startingTreatment.bicarbType ); result = requestDGStart(); } - else if ( ( dgMode >= DG_MODE_GENE ) && ( dgMode <= DG_MODE_DRAI ) && ( FALSE == startingTreatment ) ) + else if ( ( dgMode >= DG_MODE_GENE ) && ( dgMode <= DG_MODE_DRAI ) && ( FALSE == startingTreatment.startDG ) ) { result = requestDGStop(); } @@ -1085,7 +1114,7 @@ * @param message a pointer to the message to handle * @return none *************************************************************************/ -void handleStartStopTrimmerHeaterCmd( MESSAGE_T *message ) +void handleHDStartStopTrimmerHeaterCmd( MESSAGE_T *message ) { BOOL result = FALSE; @@ -1106,12 +1135,7 @@ if ( TRUE == isSet ) { -#ifndef _RELEASE_ - if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_TRIMMER_HEATER ) != SW_CONFIG_ENABLE_VALUE ) -#endif - { - startHeater( DG_TRIMMER_HEATER ); - } + startHeater( DG_TRIMMER_HEATER ); } else { @@ -1328,6 +1352,41 @@ } /*********************************************************************//** + * @brief + * The handleDGStartStopTrimmerHeater function handles a request start or + * stop the trimmer heater + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return result + *************************************************************************/ +BOOL handleDGStartStopTrimmerHeater( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( message->hdr.payloadLen == sizeof( BOOL ) ) + { + BOOL startingHeater; + + memcpy( &startingHeater, message->payload, sizeof( BOOL ) ); + + if ( TRUE == startingHeater ) + { + result = startHeater( DG_TRIMMER_HEATER ); + } + else + { + stopHeater( DG_TRIMMER_HEATER ); + result = TRUE; + } + } + + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_HD, result ); + + return result; +} + +/*********************************************************************//** * @brief * The handleStartStopDGChemicalDisinfect function handles a request to start * or stop DG chemical disinfect mode. @@ -1363,7 +1422,92 @@ } /*********************************************************************//** +* @brief +* The handleStartStopDGChemicalDisinfectFlush function handles a request to start +* or stop DG chemical disinfect flush mode. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +BOOL handleStartStopDGChemicalDisinfectFlush( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( message->hdr.payloadLen == sizeof(BOOL) ) + { + BOOL startingDGChemicalDisinfectFlush; + + memcpy( &startingDGChemicalDisinfectFlush, message->payload, sizeof(BOOL) ); + + if ( TRUE == startingDGChemicalDisinfectFlush ) + { + result = startDGChemicalDisinfectFlush(); + } + else + { + result = stopChemicalDisinfectFlush(); + } + } + + // Respond to request + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_HD, result ); + + return result; +} + +/*********************************************************************//** * @brief + * The handleTestSetOpModeRequest function handles a request to set the + * DG operation mode. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestSetOpModeRequest( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( message->hdr.payloadLen == sizeof(U32) ) + { + U32 mode; + + memcpy( &mode, message->payload, sizeof(U32) ); + result = testSetOperationMode( (DG_OP_MODE_T)mode ); + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestTareReservoirRequest function handles a request to tare a + * given reservoir's weight. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestTareReservoirRequest( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( message->hdr.payloadLen == sizeof(U32) ) + { + U32 res; + + memcpy( &res, message->payload, sizeof(U32) ); + result = testTareReservoir( res ); + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief * The handleSetHDOperationMode function receives the HD operation modes data * publish message. * @details Inputs: none @@ -1379,20 +1523,273 @@ // HD mode broadcast is operations mode and submode so 8 bytes if ( message->hdr.payloadLen == sizeof( U32 ) + sizeof( U32 ) ) { - U32 mode; + U32 mode = 0; + U32 subMode = 0; - // NOTE: the HD operations modes broadcast message contains the mode and submode states - // In this case, only the mode is needed. The mode is received to check if HD is in treatment - // and therefore, DG can void the last disinfect. memcpy( payloadPtr, &mode, sizeof( U32 ) ); - setHDOperationMode( mode ); + payloadPtr += sizeof( U32 ); + memcpy( payloadPtr, &subMode, sizeof( U32 ) ); + + setHDOperationMode( mode, subMode ); status = TRUE; } return status; } +/*********************************************************************//** +* @brief +* The handleServiceModeRequest function handles a request to enter service +* mode. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleServiceModeRequest( MESSAGE_T *message ) +{ + BOOL status = FALSE; + DG_OP_MODE_T currentMode = getCurrentOperationMode(); + REQUEST_REJECT_REASON_CODE_T reject; + if ( 0 == message->hdr.payloadLen ) + { + if ( ( DG_MODE_STAN == currentMode ) || ( DG_MODE_FAUL == currentMode ) ) + { + status = TRUE; + requestNewOperationMode( DG_MODE_SERV ); + reject = REQUEST_REJECT_REASON_NONE; + } + else + { + reject = REQUEST_REJECT_REASON_DG_NOT_IN_STANDBY_IDLE_STATE; + } + } + else + { + reject = REQUEST_REJECT_REASON_INVALID_REQUEST_FORMAT; + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); + sendServiceModeResponse( status, (U32)reject ); +} + +/*********************************************************************//** + * @brief + * The handleHDRequestDGUsageInfo function handles a request for DG + * usage information. + * @details Inputs: none + * @details Outputs: message handled, response constructed and queued for + * transmit. + * @return none + *************************************************************************/ +void handleHDRequestDGUsageInfo( MESSAGE_T * message ) +{ + MESSAGE_T msg; + DG_USAGE_INFO_RECORD_T usageInfo; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_DG_USAGE_DATA; + msg.hdr.payloadLen = sizeof( DG_USAGE_INFO_RECORD_T ); + + // Get the service record. There are no arrays of service to check and also, raise no alarm since the service record + // has been already checked in POST + getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DG_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); + + if ( 0 == message->hdr.payloadLen ) + { + // Fill message payload + memcpy( payloadPtr, &usageInfo, sizeof( DG_USAGE_INFO_RECORD_T ) ); + } + + // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer + serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_2_HD, ACK_REQUIRED ); +} + +/*********************************************************************//** + * @brief + * The sendServiceModeResponse function sends out the DG response to a + * UI request to go to service mode. + * @details Inputs: none + * @details Outputs: Service mode request response msg constructed and queued + * @param accepted TRUE if request was accepted, FALSE if not + * @param rejCode Reject reason code explaining why request was rejected + * @return none + *************************************************************************/ +BOOL sendServiceModeResponse( BOOL accepted, U32 rejCode ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_DG_RESPONSE_SERVICE_MODE_REQUEST; + msg.hdr.payloadLen = sizeof( BOOL ) + sizeof( U32 ); + + memcpy( payloadPtr, &accepted, sizeof( BOOL ) ); + payloadPtr += sizeof( BOOL ); + memcpy( payloadPtr, &rejCode, sizeof( U32 ) ); + + // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer + result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_2_HD, ACK_REQUIRED ); + + return result; +} + +/*********************************************************************//** + * @brief + * The handleSetDGServiceTime function sets the DG service time once the + * command is received from UI + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleSetDGServiceTime( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( 0 == message->hdr.payloadLen ) + { + result = setServiceTime(); + } + + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_UI, result ); +} + +/************************************************************************* + * @brief + * The handleStartStopDGHeatDisinfectActiveCool function handles a request + * start or stop DG heat disinfect active cool mode. + * @details Inputs: none + * @details Outputs: message handled + * @param message: a pointer to the message to handle + * @return result + *************************************************************************/ +void handleStartStopDGHeatDisinfectActiveCool( MESSAGE_T* message ) +{ + BOOL status = FALSE; + + if ( message->hdr.payloadLen == sizeof(U32) ) + { + BOOL startingDGHeatDisinfectActiveCool; + + memcpy( &startingDGHeatDisinfectActiveCool, message->payload, sizeof(U32) ); + + if ( TRUE == startingDGHeatDisinfectActiveCool ) + { + status = startDGHeatDisinfectActiveCool(); + } + else + { + status = stopDGHeatDisinfectActiveCool(); + } + } + + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_HD, status ); +} + +/*********************************************************************//** + * @brief + * The handleReceiveChemFlushSampleResultsFromHD function handles receiving + * the chemical disinfect sample flush results from HD. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleReceiveChemFlushSampleResultsFromHD( MESSAGE_T *message ) +{ + BOOL status = FALSE; + + if ( message->hdr.payloadLen == sizeof(U32) ) + { + U32 result; + + memcpy( &result, message->payload, sizeof(U32) ); + + setChemicalDisinfectFlushSampleResult( result ); + + status = TRUE; + } + + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_DG_2_HD, status ); +} + +/*********************************************************************//** + * @brief + * The handleSetROOnlyMode function handles the setting of the RO mode only. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleSetROOnlyMode( MESSAGE_T* message ) +{ + REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_DG_RO_ONLY_MODE_INVALID_PAYLOAD_LENGTH; + BOOL accepted = FALSE; + + if ( message->hdr.payloadLen == sizeof(U32) ) + { + BOOL result; + + rejReason = REQUEST_REJECT_REASON_NONE; + + memcpy( &result, message->payload, sizeof(BOOL) ); + + if ( ( FALSE == result ) || ( TRUE == result ) ) + { + switch ( getCurrentOperationMode() ) + { + case DG_MODE_FAUL: + case DG_MODE_SERV: + case DG_MODE_INIT: + case DG_MODE_STAN: + case DG_MODE_SOLO: + setROMode( result ); + accepted = TRUE; + break; + + default: + rejReason = REQUEST_REJECT_REASON_DG_RO_ONLY_MODE_DG_BUSY; + break; + } + } + else + { + rejReason = REQUEST_REJECT_REASON_DG_RO_ONLY_MODE_INVALID_PARAMETER; + } + } + + sendUIResponseMsg( MSG_ID_DG_RO_ONLY_MODE_STATUS_RESPONSE, accepted, rejReason ); +} + +/*********************************************************************//** + * @brief + * The requestROOnlyModeStatusFromUI function handles the request + * the RO only mode status from UI. + * @details Inputs: none + * @details Outputs: message handled + * @return none + *************************************************************************/ +void requestROOnlyModeStatusFromUI( void ) +{ + MESSAGE_T msg; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_DG_RO_ONLY_MODE_STATUS_REQUEST; + msg.hdr.payloadLen = 0; + + // Serialize the message (w/ sync, CRC, and appropriate CAN padding) and add serialized message data to appropriate comm buffer + serializeMessage( msg, COMM_BUFFER_OUT_CAN_DG_2_UI, ACK_REQUIRED ); +} + + // *********************************************************************** // **************** Message Handling Helper Functions ******************** // *********************************************************************** @@ -1542,20 +1939,26 @@ *************************************************************************/ void handleTestLoadCellOverrideRequest( MESSAGE_T *message ) { - TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + typedef struct + { + TEST_OVERRIDE_ARRAY_PAYLOAD_T ovRecord; + BOOL flag; + } LC_OVERRIDE_PAYLOAD_T; + + LC_OVERRIDE_PAYLOAD_T payload; BOOL result = FALSE; // verify payload length - if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) + if ( sizeof( LC_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) { - memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); - if ( FALSE == payload.reset ) + memcpy( &payload, message->payload, sizeof( LC_OVERRIDE_PAYLOAD_T ) ); + if ( FALSE == payload.ovRecord.reset ) { - result = testSetLoadCellOverride( payload.index, payload.state.f32 ); + result = testSetLoadCellOverride( payload.ovRecord.index, payload.ovRecord.state.f32, payload.flag ); } else { - result = testResetLoadCellOverride( payload.index ); + result = testResetLoadCellOverride( payload.ovRecord.index, payload.flag ); } } @@ -1756,32 +2159,31 @@ sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); } - /*********************************************************************//** * @brief - * The handleTestROMeasuredFlowOverrideRequest function handles a request to - * override the RO flow rate. + * The handleTestMeasuredFlowOverrideRequest function handles a request to + * override the measured flow sensor rate. * @details Inputs: none * @details Outputs: message handled * @param message a pointer to the message to handle * @return none *************************************************************************/ -void handleTestROMeasuredFlowOverrideRequest( MESSAGE_T *message ) +void handleTestMeasuredFlowOverrideRequest( MESSAGE_T *message ) { - TEST_OVERRIDE_PAYLOAD_T payload; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; BOOL result = FALSE; // verify payload length - if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) { - memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); if ( FALSE == payload.reset ) { - result = testSetMeasuredROFlowRateOverride( payload.state.f32 ); + result = testSetMeasuredFlowRateOverride( payload.index, payload.state.f32 ); } else { - result = testResetMeasuredROFlowRateOverride(); + result = testResetMeasuredFlowRateOverride( payload.index ); } } @@ -1791,38 +2193,6 @@ /*********************************************************************//** * @brief - * The handleTestDialysateMeasuredFlowOverrideRequest function handles a request to - * override the Dialysate flow rate. - * @details Inputs: none - * @details Outputs: message handled - * @param message a pointer to the message to handle - * @return none - *************************************************************************/ -void handleTestDialysateMeasuredFlowOverrideRequest( MESSAGE_T *message ) -{ - TEST_OVERRIDE_PAYLOAD_T payload; - BOOL result = FALSE; - - // verify payload length - if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) - { - memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); - if ( FALSE == payload.reset ) - { - result = testSetMeasuredDialysateFlowRateOverride( payload.state.f32 ); - } - else - { - result = testResetMeasuredDialysateFlowRateOverride(); - } - } - - // respond to request - sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); -} - -/*********************************************************************//** - * @brief * The handleTestROPumpDataBroadcastIntervalOverrideRequest function handles * a request to override the broadcast interval for RO pump data. * @details Inputs: none @@ -1855,14 +2225,14 @@ /*********************************************************************//** * @brief - * The handleTestDialysateFlowDataBroadcastIntervalOverrideRequest function handles - * a request to override the broadcast interval for dialysate flow data. + * The handleTestFlowSensorsDataBroadcastIntervalOverrideRequest function handles + * a request to override the broadcast interval for the flow sensors data. * @details Inputs: none * @details Outputs: message handled * @param message a pointer to the message to handle * @return none *************************************************************************/ -void handleTestDialysateFlowDataBroadcastIntervalOverrideRequest( MESSAGE_T *message ) +void handleTestFlowSensorsDataBroadcastIntervalOverrideRequest( MESSAGE_T *message ) { TEST_OVERRIDE_PAYLOAD_T payload; BOOL result = FALSE; @@ -1873,11 +2243,11 @@ memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); if ( FALSE == payload.reset ) { - result = testSetDialysateFlowDataPublishIntervalOverride( payload.state.u32 ); + result = testSetFlowDataPublishIntervalOverride( payload.state.u32 ); } else { - result = testResetDialysateFlowDataPublishIntervalOverride(); + result = testResetFlowDataPublishIntervalOverride(); } } @@ -2044,14 +2414,14 @@ /************************************************************************* * @brief - * The handleSetDrainPumpTargetOutletPressure function handles a - * request to set the drain pump outlet pressure. + * The handleSetDrainPumpTargetOutletFlowLPM function handles a + * request to set the drain pump outlet flow in L/min. * @details Inputs: none * @details Outputs: message handled * @param message a pointer to the message to handle * @return none *************************************************************************/ -void handleSetDrainPumpTargetOutletPressure( MESSAGE_T *message ) +void handleSetDrainPumpTargetOutletFlowLPM( MESSAGE_T *message ) { BOOL result = 0; @@ -2062,7 +2432,7 @@ memcpy( &payLoad, message->payload, sizeof( F32 ) ); - result = testSetTargetDrainPumpOutletPressure( payLoad ); + result = testSetTargetDrainPumpOutletFlowLPM( payLoad ); } /* respond to request */ sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); @@ -2626,13 +2996,13 @@ result = TRUE; memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); - if ( ( BOOL )payload.state.u32 ) + if ( TRUE == ( BOOL )payload.state.u32 ) { requestConcentratePumpOn( ( CONCENTRATE_PUMPS_T )payload.index ); } else { - requestConcentratePumpOff( ( CONCENTRATE_PUMPS_T )payload.index ); + requestConcentratePumpOff( ( CONCENTRATE_PUMPS_T )payload.index, NO_PARK_CONC_PUMPS ); } } @@ -2898,23 +3268,24 @@ U32 totalMessages; U32 payloadLength; - memcpy(¤tMessage, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + if ( message->hdr.payloadLen >= ( sizeof(currentMessage) + sizeof(totalMessages) + sizeof(payloadLength) ) ) + { + memcpy(¤tMessage, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - memcpy(&totalMessages, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + memcpy(&totalMessages, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - memcpy(&payloadLength, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + memcpy(&payloadLength, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - status = receiveRecordFromDialin( NVDATAMGMT_CALIBRATION_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); + status = receiveRecordFromDialin( NVDATAMGMT_CALIBRATION_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); + } // Respond to request sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); } - - /*********************************************************************//** * @brief * The handleGetDGCalibrationRecord function handles a request to get the DG @@ -2959,16 +3330,19 @@ U32 totalMessages; U32 payloadLength; - memcpy(¤tMessage, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + if ( message->hdr.payloadLen >= ( sizeof(currentMessage) + sizeof(totalMessages) + sizeof(payloadLength) ) ) + { + memcpy(¤tMessage, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - memcpy(&totalMessages, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + memcpy(&totalMessages, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - memcpy(&payloadLength, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + memcpy(&payloadLength, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - status = receiveRecordFromDialin( NVDATAMGMT_SYSTEM_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); + status = receiveRecordFromDialin( NVDATAMGMT_SYSTEM_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); + } // Respond to request sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); @@ -3045,76 +3419,20 @@ U32 totalMessages; U32 payloadLength; - memcpy(¤tMessage, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + if ( message->hdr.payloadLen >= ( sizeof(currentMessage) + sizeof(totalMessages) + sizeof(payloadLength) ) ) + { + memcpy(¤tMessage, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - memcpy(&totalMessages, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + memcpy(&totalMessages, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - memcpy(&payloadLength, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); + memcpy(&payloadLength, payloadPtr, sizeof(U32)); + payloadPtr += sizeof(U32); - status = receiveRecordFromDialin( NVDATAMGMT_SERVICE_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); - - // Respond to request - sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); -} - -/*********************************************************************//** -* @brief -* The handleGetDGServiceRecord function handles a request to get the DG -* scheduled runs data record. -* @details Inputs: none -* @details Outputs: message handled -* @param message a pointer to the message to handle -* @return none -*************************************************************************/ -void handleGetDGScheduledRunsRecord( MESSAGE_T *message ) -{ - BOOL result = FALSE; - - // verify payload length - if ( 0 == message->hdr.payloadLen ) - { - // Tester must be logged in - if ( TRUE == isTestingActivated() ) - { - result = sendRecordToDialin( NVDATAMGMT_SCHEDULED_RUNS_RECORD ); - } + status = receiveRecordFromDialin( NVDATAMGMT_SERVICE_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); } - // respond to request - sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); -} - -/*********************************************************************//** -* @brief -* The handleSetDGScheduledRunsRecord function handles a request to set the DG -* scheduled runs data record. -* @details Inputs: none -* @details Outputs: message handled -* @param message a pointer to the message to handle -* @return none -*************************************************************************/ -void handleSetDGScheduledRunsRecord( MESSAGE_T *message ) -{ - BOOL status = FALSE; - U08* payloadPtr = message->payload; - U32 currentMessage; - U32 totalMessages; - U32 payloadLength; - - memcpy(¤tMessage, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); - - memcpy(&totalMessages, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); - - memcpy(&payloadLength, payloadPtr, sizeof(U32)); - payloadPtr += sizeof(U32); - - status = receiveRecordFromDialin( NVDATAMGMT_SCHEDULED_RUNS_RECORD, currentMessage, totalMessages, payloadLength, payloadPtr ); - // Respond to request sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); } @@ -3377,6 +3695,7 @@ // Respond to request sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); } + /*********************************************************************//** * The handleSetFansDutyCycleOverrideRequest function handles a * request to override the fans duty cycle. @@ -3513,7 +3832,7 @@ * @param message a pointer to the message to handle * @return none *************************************************************************/ -void handleTestHDCommunicationStatusOverrideRequest(MESSAGE_T *message) +void handleTestHDCommunicationStatusOverrideRequest( MESSAGE_T *message ) { TEST_OVERRIDE_PAYLOAD_T payload; BOOL result = FALSE; @@ -3524,7 +3843,7 @@ memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); if ( FALSE == payload.reset ) { - result = testSetHDCommunicationStatus(payload.state.u32); + result = testSetHDCommunicationStatus( payload.state.u32 ); } else { @@ -3537,6 +3856,134 @@ } /*********************************************************************//** + * @brief + * The handleSetPrimaryAndTrimmerHeatersTargetTemperature function handles + * setting primary and trimmer heaters target temperature. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleSetPrimaryAndTrimmerHeatersTargetTemperature( MESSAGE_T *message ) +{ + BOOL status = FALSE; + U08* payloadPtr = message->payload; + + if ( message->hdr.payloadLen >= ( sizeof( F32 ) + sizeof( F32 ) ) ) + { + F32 primaryTargetTemp = 0.0F; + F32 trimmerTargetTemp = 0.0F; + status = TRUE; + + memcpy( &primaryTargetTemp, payloadPtr, sizeof( F32 ) ); + payloadPtr += sizeof( F32 ); + + memcpy( &trimmerTargetTemp, payloadPtr, sizeof( F32 ) ); + + setHeaterTargetTemperature( DG_PRIMARY_HEATER, primaryTargetTemp ); + setHeaterTargetTemperature( DG_TRIMMER_HEATER, trimmerTargetTemp ); + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); +} + +/*********************************************************************//** +* The handleTestDGDrainPumpCurrentOverrideRequest function handles a +* request to override the drain pump measured current. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGDrainPumpCurrentOverrideRequest( MESSAGE_T *message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + + if ( FALSE == payload.reset ) + { + result = testSetDrainPumpMeasuredCurrentOverride( payload.state.f32 ); + } + else + { + result = testResetDrainPumpMeasuredCurrentOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** +* The handleTestDGDrainPumpDirectionOverrideRequest function handles a +* request to override the drain pump measured direction. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGDrainPumpDirectionOverrideRequest( MESSAGE_T *message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + + if ( FALSE == payload.reset ) + { + result = testSetDrainPumpMeasuredDirectionOverride( payload.state.u32 ); + } + else + { + result = testResetDrainPumpMeasuredDirectionOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** +* The handleTestDGValvesSensedStateOverrideRequest function handles a +* request to override the valves sensed state. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGValvesSensedStateOverrideRequest( MESSAGE_T *message ) +{ + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetValveSensedStateOverride( payload.index, payload.state.u32 ); + } + else + { + result = testResetValveSensedStateOverride( payload.index ); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** * @brief * The handleGetDGUsageInfoRecord function handles a request to get the DG * usage information record. @@ -3638,4 +4085,489 @@ return result; } +/*********************************************************************//** +* @brief +* The handleResendAllAlarmsCommand function handles a request to re-send +* all active DG alarms. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleResendAllAlarmsCommand( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + // verify payload length + if ( 0 == message->hdr.payloadLen ) + { + handleResendActiveAlarmsRequest(); + result = TRUE; + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** +* @brief +* The handleTestDGNVRecordCRCOverride function handles a request to override +* the selected NV record's CRC. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGNVRecordCRCOverride( MESSAGE_T *message ) +{ + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); + result = testSetNVRecordCRCOverride( payload.index, (U16)payload.state.u32 ); + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** +* The handleTestDGConcPumpParkStatusOverrideRequest function handles a +* request to override the parked status of a given concentrate pump. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGConcPumpParkStatusOverrideRequest( MESSAGE_T *message ) +{ + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); + + if ( FALSE == payload.reset ) + { + result = testSetConcentratePumpParkedOverride( payload.index, (U16)payload.state.u32 ); + } + else + { + result = testResetConcentratePumpParkedOverride( payload.index ); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** +* The handleTestDGConcPumpParkFaultStatusOverrideRequest function handles a +* request to override the park faulted status of a given concentrate pump. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGConcPumpParkFaultStatusOverrideRequest( MESSAGE_T *message ) +{ + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); + + if ( FALSE == payload.reset ) + { + result = testSetConcentratePumpParkCmdFaultedOverride( payload.index, (U16)payload.state.u32 ); + } + else + { + result = testResetConcentratePumpParkCmdFaultedOverride( payload.index ); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** +* The handleTestDGConcPumpParkCommandRequest function handles a command +* to park a given concentrate pump. +* @details Inputs: none +* @details Outputs: message handled +* @param message a pointer to the message to handle +* @return none +*************************************************************************/ +void handleTestDGConcPumpParkCommandRequest( MESSAGE_T *message ) +{ + U32 pumpIdx; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( U32 ) == message->hdr.payloadLen ) + { + memcpy( &pumpIdx, message->payload, sizeof( U32 ) ); + + result = testSetConcentratePumpParkCommand( pumpIdx ); + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestDrainPumpMeasuredCurrentOverride function handles a request + * to override the drain pump measured current + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDrainPumpMeasuredCurrentOverride( MESSAGE_T *message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetDrainPumpMeasuredCurrentOverride( payload.state.f32 ); + } + else + { + result = testResetDrainPumpMeasuredCurrentOverride(); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestGenIdlePublishIntervalOverride function handles a request + * to override the gen idle state publish interval + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestGenIdlePublishIntervalOverride( MESSAGE_T * message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetGenIdleSubstatesPublishIntervalOverride( payload.state.u32 ); + } + else + { + result = testResetGenIdleSubstatesPublishIntervalOverride(); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestDGROPumpFeedbackVoltageOverrideRequest function handles a request + * to override the gen idle state publish interval + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDGROPumpFeedbackVoltageOverrideRequest( MESSAGE_T * message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetROPumpMeasuredFeedbackDutyCycleOverride( payload.state.f32 ); + } + else + { + result = testResetROPumpMeasuredFeedbackDutyCycleOverride(); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestDGFillModeBroadcastOverrideRequest function handles a request + * to override the gen idle state publish interval + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDGFillModeBroadcastOverrideRequest( MESSAGE_T * message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetFillModeDataPublishIntervalOverride( payload.state.u32 ); + } + else + { + result = testResetFillModeDataPublishIntervalOverride(); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestDGFillIntegratedVolumeOverrideRequest function handles a request + * to override the gen idle state publish interval + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDGFillIntegratedVolumeOverrideRequest( MESSAGE_T * message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetIntegratedVolumeOverride( payload.state.f32 ); + } + else + { + result = testResetIntegratedVolumeOverride(); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestDGHeatersDutyCycleOverrideRequest function handles a request + * to override the heaters duty cycle + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDGHeatersDutyCycleOverrideRequest( MESSAGE_T *message ) +{ + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + BOOL result = FALSE; + + // verify payload length + if ( sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof( TEST_OVERRIDE_ARRAY_PAYLOAD_T ) ); + if ( FALSE == payload.reset ) + { + result = testSetHeaterDutyCycleOverride( payload.index, payload.state.f32 ); + } + else + { + result = testResetHeaterDutyCycleOverride( payload.index ); + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleDGRTCControlReg1StatusOverrideRequest function handles a + * request to override RTC control register 1. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleDGRTCControlReg1StatusOverrideRequest( MESSAGE_T * message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // Verify payload length + if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) ); + if ( FALSE == payload.reset ) + { + result = testSetRTCCtlReg1Status( payload.state.u32 ); + } + else + { + result = testResetRTCCtlReg1Status(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleDGRTCControlReg1StatusOverrideRequest function handles a + * request to override RTC control register 3. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleDGRTCControlReg3StatusOverrideRequest( MESSAGE_T * message ) +{ + TEST_OVERRIDE_PAYLOAD_T payload; + BOOL result = FALSE; + + // Verify payload length + if ( sizeof(TEST_OVERRIDE_PAYLOAD_T) == message->hdr.payloadLen ) + { + memcpy( &payload, message->payload, sizeof(TEST_OVERRIDE_PAYLOAD_T) ); + if ( FALSE == payload.reset ) + { + result = testSetRTCCtlReg3Status( payload.state.u32 ); + } + else + { + result = testResetRTCCtlReg3Status(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +#ifndef _RELEASE_ +/*********************************************************************//** + * @brief + * The handleTestDGNelsonDisinfectSupport function handles a request + * to set the Nelson disinfect support mode. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDGNelsonDisinfectSupport( MESSAGE_T *message ) +{ + U32 payload; + BOOL result = FALSE; + + // verify payload length + if ( ( sizeof( U32 ) == message->hdr.payloadLen ) && + ( ( DG_MODE_STAN == getCurrentOperationMode() ) || ( DG_MODE_SOLO == getCurrentOperationMode() ) ) ) + { + NELSON_SUPPORT_T nelson; + + memcpy( &payload, message->payload, sizeof( U32 ) ); + + nelson = (NELSON_SUPPORT_T)payload; + result = TRUE; + + switch( nelson ) + { + case NELSON_INOCULATE: + setHeatNelsonSupportMode( nelson ); + requestNewOperationMode( DG_MODE_HEAT ); + break; + + case NELSON_HEAT_DISINFECT: + setHeatNelsonSupportMode( nelson ); + requestNewOperationMode( DG_MODE_HEAT ); + break; + + case NELSON_POS_CONTROL_HEAT_DISINFECT: + setHeatNelsonSupportMode( nelson ); + requestNewOperationMode( DG_MODE_HEAT ); + break; + + case NELSON_CHEM_DISINFECT: + setChemNelsonSupportMode( nelson ); + requestNewOperationMode( DG_MODE_CHEM ); + break; + + case NELSON_DRAIN_SAMPLES: + setHeatNelsonSupportMode( nelson ); + requestNewOperationMode( DG_MODE_HEAT ); + break; + } + } + + // respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} +#endif + +/*********************************************************************//** + * @brief + * The handleTestDGSetDialysateMixingRatios function handles a request + * to set the dialysate mixing ratios. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestDGSetDialysateMixingRatios( MESSAGE_T *message ) +{ + BOOL status = FALSE; + U08* payloadPtr = message->payload; + + if ( message->hdr.payloadLen >= ( 2 * sizeof(F32) ) ) + { + F32 acidMixingRatio = 0.0F; + F32 bicarbMixingRatio = 0.0F; + + memcpy(&acidMixingRatio, payloadPtr, sizeof(F32)); + payloadPtr += sizeof(F32); + + memcpy(&bicarbMixingRatio, payloadPtr, sizeof(F32)); + + status = testSetDialysateMixingRatios( acidMixingRatio, bicarbMixingRatio ); + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, status ); +} + /**@}*/