Index: firmware/App/Services/Messaging.c =================================================================== diff -u -r4fb1e15d35f6b968bab5620909c30baec98bfd4e -r25dbc6221b63e20fe61b2af0ce9c9f56bf13e807 --- firmware/App/Services/Messaging.c (.../Messaging.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) +++ firmware/App/Services/Messaging.c (.../Messaging.c) (revision 25dbc6221b63e20fe61b2af0ce9c9f56bf13e807) @@ -18,13 +18,35 @@ #include // for memcpy() #include "reg_system.h" +#include "BalancingChamber.h" +#include "Conductivity.h" #include "Compatible.h" +#include "ConcentratePumps.h" +#include "DialysatePumps.h" +#include "Heaters.h" +#include "FpgaDD.h" +#include "Level.h" #include "Messaging.h" +#include "MessagePayloads.h" +#include "ModeGenDialysate.h" +#include "ModePreGenDialysate.h" +#include "ModePostGenDialysate.h" +#include "ModeStandby.h" #include "OperationModes.h" -#include "Utilities.h" -#include "SystemCommDD.h" #include "PAL.h" +#ifdef __PUMPTEST__ +#include "PistonPumpControl.h" +#endif +#include "Pressure.h" +#include "SafetyShutdown.h" +#include "SystemCommDD.h" +#include "Temperature.h" +#include "TDInterface.h" +#include "Utilities.h" +#include "Ultrafiltration.h" +#include "Valves.h" + /** * @addtogroup Messaging * @{ @@ -63,122 +85,191 @@ COMM_BUFFER_NOT_USED, ///< Buffer for outgoing HD to PC messages so no response buffer }; - typedef BOOL (*MsgFuncPtr)( MESSAGE_T* ); +/// Message handling look-up table record type. +typedef struct +{ + U16 msgID; ///< ID of received message to handle. + MsgFuncPtr msgHandler; ///< Pointer to message handling function associated with a message ID. +} MSG_HANDLER_LOOKUP_T; + /// Message handling function lookup table -static const U16 MSG_FUNCTION_HANDLER_LOOKUP[] = { - MSG_ID_TESTER_LOGIN_REQUEST, - MSG_ID_DD_SOFTWARE_RESET_REQUEST, - MSG_ID_TD_OP_MODE_DATA +static const MSG_HANDLER_LOOKUP_T MSG_FUNCTION_HANDLER_LOOKUP[] = { + { MSG_ID_DD_TESTER_LOGIN_REQUEST, &handleTesterLogInRequest }, + { MSG_ID_DD_SOFTWARE_RESET_REQUEST, &handleDDSoftwareResetRequest }, + { MSG_ID_TD_OP_MODE_DATA, &handleSetTDOperationMode }, + { MSG_ID_DD_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testValvesStatesPublishIntervalOverride }, + { MSG_ID_DD_VALVE_STATE_OVERRIDE_REQUEST, &testValveStateOverride }, + { MSG_ID_DD_VALVE_SENSED_STATE_OVERRIDE_REQUEST, &testValveSensedStateOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_READINGS_OVERRIDE_REQUEST, &testPressureSensorReadingsOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_TEMPERATURE_OVERRIDE_REQUEST, &testPressureSensorTemperatureReadingsOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_READ_COUNTER_OVERRIDE_REQUEST, &testPressureSensorReadCounterOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_ERROR_COUNTER_OVERRIDE_REQUEST, &testPressureSensorErrorCounterOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testPressureSensorDataPublishIntervalOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_FILTER_READINGS_OVERRIDE_REQUEST, &testPressureSensorFilteredReadingsOverride }, + { MSG_ID_DD_PRESSURE_SENSOR_FILTER_TEMPERATURE_OVERRIDE_REQUEST, &testPressureSensorFilteredTemperatureReadingsOverride }, + { MSG_ID_DD_CONDUCTIVITY_SENSOR_READINGS_OVERRIDE_REQUEST, &testConductivitySensorReadingsOverride }, + { MSG_ID_DD_CONDUCTIVITY_SENSOR_TEMPERATURE_OVERRIDE_REQUEST, &testConductivitySensorTemperatureReadingsOverride }, + { MSG_ID_DD_CONDUCTIVITY_SENSOR_READ_COUNTER_OVERRIDE_REQUEST, &testConductivitySensorReadCounterOverride }, + { MSG_ID_DD_CONDUCTIVITY_SENSOR_ERROR_COUNTER_OVERRIDE_REQUEST, &testConductivitySensorErrorCounterOverride }, + { MSG_ID_DD_CONDUCTIVITY_SENSOR_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testConductivitySensorDataPublishIntervalOverride }, + { MSG_ID_DD_CONCENTRATE_PUMP_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testConcentratePumpDataPublishIntervalOverride }, + { MSG_ID_DD_CONCENTRATE_PUMP_TARGET_SPEED_OVERRIDE_REQUEST, &testConcentratePumpTargetSpeedOverride }, + { MSG_ID_DD_CONCENTRATE_PUMP_MEASURED_SPEED_OVERRIDE_REQUEST, &testConcentratePumpMeasuredSpeedOverride }, + { MSG_ID_DD_CONCENTRATE_PUMP_PARKED_OVERRIDE_REQUEST, &testConcentratePumpParkedOverride }, + { MSG_ID_DD_CONCENTRATE_PUMP_PARK_FAULT_OVERRIDE_REQUEST, &testConcentratePumpParkCmdFaultedOverride }, + { MSG_ID_DD_CONCENTRATE_PUMP_PARK_REQUEST_OVERRIDE_REQUEST, &testConcentratePumpParkRequestOverride }, + { MSG_ID_DD_TEMPERATURE_SENSOR_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testTemperatureSensorsDataPublishIntervalOverride }, + { MSG_ID_DD_TEMPERATURE_SENSOR_MEASURED_TEMPERATURE_OVERRIDE_REQUEST, &testMeasuredTemperatureOverride }, + { MSG_ID_DD_TEMPERATURE_SENSOR_READ_COUNTER_OVERRIDE_REQUEST, &testTemperatureReadCounterOverride }, + { MSG_ID_DD_TEMPERATURE_SENSOR_BARO_READ_COUNTER_OVERRIDE_REQUEST, &testBaroTemperatureReadCounterOverride }, + { MSG_ID_DD_TEMPERATURE_SENSOR_BARO_CRC_OVERRIDE_REQUEST, &testBaroTemperatureCRCOverride }, + { MSG_ID_DD_DIALYSATE_PUMPS_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testDialysatePumpsDataPublishIntervalOverride }, + { MSG_ID_DD_DIALYSATE_PUMPS_TARGET_SPEED_OVERRIDE_REQUEST, &testDialysatePumpTargetSpeedOverride }, + { MSG_ID_DD_DIALYSATE_PUMPS_MEASURED_SPEED_OVERRIDE_REQUEST, &testDialysatePumpMeasuredSpeedOverride }, + { MSG_ID_DD_DIALYSATE_PUMPS_TARGET_PRESSURE_OVERRIDE_REQUEST, &testDialysatePumpTargetPressureOverride }, + { MSG_ID_DD_DIALYSATE_PUMPS_MEASURED_CURRENT_OVERRIDE_REQUEST, &testDialysatePumpMeasuredCurrentOverride }, + { MSG_ID_DD_DIALYSATE_PUMPS_MEASURED_DIRECTION_OVERRIDE_REQUEST, &testDialysatePumpMeasuredDirectionOverride }, + { MSG_ID_DD_HEATERS_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testHeatersDataPublishIntervalOverride }, + { MSG_ID_DD_HEATERS_DUTY_CYCLE_OVERRIDE_REQUEST, &testHeaterDutyCycleOverride }, + { MSG_ID_DD_LEVELS_PUBLISH_INTERVAL_OVERRIDE_REQUEST, &testLevelsDataPublishIntervalOverride }, + { MSG_ID_DD_LEVELS_STATUS_OVERRIDE_REQUEST, &testLevelStatusOverride }, + { MSD_ID_DD_TD_COMMUNICATION_STATUS_OVERRIDE_REQUEST, &testTDCommunicationStatusOverride }, + { MSG_ID_DD_OP_MODE_STATUS_OVERRIDE_REQUEST, &testDDOpModePublishIntervalOverride }, + { MSG_ID_DD_SET_OPERATION_MODE_OVERRIDE_REQUEST, &testSetOperationMode }, + { MSG_ID_DD_DIALYSATE_PUMPS_START_STOP_OVERRIDE_REQUEST, &testDialysatePumpStartStopOverride }, + { MSG_ID_DD_GEND_MODE_DATA_PUBLISH_OVERRIDE_REQUEST, &testDDGenDialysateDataPublishIntervalOverride }, + { MSG_ID_DD_CONCENTRATE_PUMPS_START_STOP_OVERRIDE_REQUEST, &testConcentratePumpStartStopOverride }, + { MSG_ID_DD_HEATERS_START_STOP_OVERRIDE_REQUEST, &testHeaterStartStopOverride }, + { MSG_ID_DD_VALVES_OPEN_CLOSE_STATE_OVERRIDE_REQUEST, &testValveOpenCloseStateOverride }, + { MSG_ID_DD_GEN_DIALYSATE_REQUEST_DATA, &handleDialysateDeliveryRequestMsg }, + { MSD_ID_DD_FP_COMMUNICATION_STATUS_OVERRIDE_REQUEST, &testROCommunicationStatusOverride }, + { MSG_ID_DD_BAL_CHAMBER_DATA_PUBLISH_OVERRIDE_REQUEST, &testDDBalChamberDataPublishIntervalOverride }, + { MSG_ID_DD_BAL_CHAMBER_SWITCH_FREQ_OVERRIDE_REQUEST, &testBalChamberSwFreqOverride }, + { MSG_ID_DD_DIAL_DELIVERY_IN_PROGRESS_OVERRIDE_REQUEST, &testDialDeliveryInProgressOverride }, + { MSG_ID_DD_DIAL_DELIVERY_GOOD_TO_DELIVER_OVERRIDE_REQUEST, &testDialGoodToDeliverStatusOverride }, + { MSG_ID_DD_HEATERS_TARGET_TEMPERATURE_OVERRIDE_REQUEST, &testHeaterTargetTemperatureOverride }, + { MSG_ID_DD_BC_VALVE_STATES_OVERRIDE_REQUEST, &testBCValveStatesOverride }, + { MSG_ID_DD_BC_SWITCH_ONLY_START_STOP_OVERRIDE_REQUEST, &testBCSwitchOnlyStartStopOverride }, + { MSG_ID_DD_HYD_CHAMBER_TARGET_TEMP_OVERRIDE_REQUEST, &testGenDHydChamberFluidTempOverride }, + { MSG_ID_DD_ACID_DOSING_VOLUME_OVERRIDE_REQUEST, &testAcidDoseVolumeOverride }, + { MSG_ID_DD_BICARB_DOSING_VOLUME_OVERRIDE_REQUEST, &testBicarbDoseVolumeOverride }, + { MSG_ID_DD_GEND_EXEC_STATE_OVERRIDE_REQUEST, &testGenDExecStateOverride }, + { MSG_ID_DD_HEATERS_PWM_PERIOD_OVERIDE_REQUEST, &testHeaterPWMPeriodOverride }, + { MSG_ID_DD_PRE_GEND_MODE_DATA_PUBLISH_OVERRIDE_REQUEST, &testDDPreGenDialysateDataPublishIntervalOverride }, + { MSG_ID_DD_POST_GEND_MODE_DATA_PUBLISH_OVERRIDE_REQUEST, &testDDPostGenDialysateDataPublishIntervalOverride }, + { MSG_ID_DD_PRE_GEN_DIALYSATE_REQUEST_DATA, &handlePreGenDialysateRequestMsg }, + { MSG_ID_FW_VERSIONS_REQUEST, &handleVersionRequestMessage }, + { MSG_ID_DD_SAFETY_SHUTDOWN_OVERRIDE_REQUEST, &testSetResetSafetyShutdownOverride }, + { MSG_ID_DD_UF_DATA_PUBLISH_OVERRIDE_REQUEST, &testDDUFDataPublishIntervalOverride }, +#ifdef __PUMPTEST__ + { MSG_ID_DD_PISTON_PUMP_DATA_PUBLISH_OVERRIDE_REQUEST, &testDDPistonPumpControlDataPublishIntervalOverride }, + { MSG_ID_DD_PISTON_PUMP_START_STOP_OVERRIDE_REQUEST, &testDDPistonPumpStartStopOverride }, + { MSG_ID_DD_PISTON_PUMP_FILL_AFTER_DISPENSE_OVERRIDE_REQUEST, &testDDPistonPumpFillAfterDispenseOverride }, +#endif }; -/// Message handling function table -static const MsgFuncPtr MSG_FUNCTION_HANDLERS[] = { - &handleTesterLogInRequest, - &handleDDSoftwareResetRequest, - &handleSetTDOperationMode -}; +#define NUM_OF_FUNCTION_HANDLERS (sizeof(MSG_FUNCTION_HANDLER_LOOKUP) / sizeof(MSG_HANDLER_LOOKUP_T)) -#define NUM_OF_FUNCTION_HANDLERS (sizeof(MSG_FUNCTION_HANDLERS) / sizeof(MsgFuncPtr)) - - // ********** private data ********** static BOOL testerLoggedIn = FALSE; ///< Flag indicates whether tester logged in or not. static volatile U16 nextSeqNo = 1; ///< Next sequence number. /// List of message IDs that are requested not to be transmitted. //static BLOCKED_MSGS_DATA_T blockedMessagesForXmit = { 0, 0, 0, 0, 0, 0, 0, 0 }; - -// ********** 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 ); - -/*********************************************************************//** - * @brief - * The serializeMessage function serializes a given message into a given - * array of bytes. A sequence # is added to the message here and the ACK - * bit of the sequence # is set if ACK is required per parameter. A sync byte - * is inserted at the beginning of the message and an 8-bit CRC is appended to - * the end of the message. The message is queued for transmission in the given buffer. - * @details \b Inputs: none + +/// UI version information +static UI_VERSIONS_T uiVersionRecord = { 0, 0, 0, 0, 0 }; + +// ********** private function prototypes ********** + +static BOOL sendTestAckResponseMsg( MSG_ID_T msgID, BOOL ack ); + +/*********************************************************************//** + * @brief + * The serializeMessage function serializes a given message into a given + * array of bytes. A sequence # is added to the message here and the ACK + * bit of the sequence # is set if ACK is required per parameter. A sync byte + * is inserted at the beginning of the message and an 8-bit CRC is appended to + * the end of the message. The message is queued for transmission in the given buffer. + * @details \b Inputs: none * @details \b Outputs: given data array populated with serialized message data and * queued for transmit. - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when pending ACK list is full. - * @param msg message to serialize - * @param buffer outgoing buffer that message should be queued in - * @param ackReq is an acknowledgement from receiver required? - * @return size (in bytes) of serialized message populated in given data array. - *************************************************************************/ -U32 serializeMessage( MESSAGE_T msg, COMM_BUFFER_T buffer, BOOL ackReq ) -{ - BOOL result = FALSE; - BOOL error = FALSE; - U32 msgSize = 0; - U32 sizeMod, sizePad; - U32 i; - U08 crc; - U08 data[ MAX_ACK_MSG_SIZE ]; // byte array to populate with message data - - // prefix data with message sync byte - data[ msgSize++ ] = MESSAGE_SYNC_BYTE; - - // set sequence # and ACK bit (unless this is an ACK to a received message) - if ( msg.hdr.msgID != MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK ) - { - // thread protect next sequence # access & increment - _disable_IRQ(); - msg.hdr.seqNo = nextSeqNo; - nextSeqNo = INC_WRAP( nextSeqNo, MIN_MSG_SEQ_NO, MAX_MSG_SEQ_NO ); - _enable_IRQ(); - if ( TRUE == ackReq ) - { - msg.hdr.seqNo *= -1; - } - } - - // calculate message CRC - crc = crc8( (U08*)(&msg), sizeof( MESSAGE_HEADER_T ) + msg.hdr.payloadLen ); - - // serialize message header data - memcpy( &data[ msgSize ], &( msg.hdr ), sizeof( MESSAGE_HEADER_T ) ); - msgSize += sizeof( MESSAGE_HEADER_T ); - - // serialize message payload (only used bytes per payloadLen field) - memcpy( &data[ msgSize ], &( msg.payload ), msg.hdr.payloadLen ); - msgSize += msg.hdr.payloadLen; - - // add 8-bit CRC - data[ msgSize++ ] = crc; - - // pad with zero bytes to get length a multiple of CAN_FRAME_PAYLOAD_SIZE (8) - sizeMod = msgSize % CAN_FRAME_PAYLOAD_SIZE; - sizePad = ( sizeMod == 0 ? 0 : CAN_FRAME_PAYLOAD_SIZE - sizeMod ); - for ( i = 0; i < sizePad; i++ ) - { - data[ msgSize++ ] = 0; - } - - // if ACK required, add to pending ACK list - if ( TRUE == ackReq ) - { - if ( FALSE == addMsgToPendingACKList( &msg, buffer, data, msgSize ) ) - { - error = TRUE; - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_MSG_PENDING_ACK_LIST_FULL ) - } - } - - if ( FALSE == error ) - { - // add serialized message data to appropriate out-going comm buffer - result = addToCommBuffer( buffer, data, msgSize ); - } - - return result; -} + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when pending ACK list is full. + * @param msg message to serialize + * @param buffer outgoing buffer that message should be queued in + * @param ackReq is an acknowledgement from receiver required? + * @return size (in bytes) of serialized message populated in given data array. + *************************************************************************/ +U32 serializeMessage( MESSAGE_T msg, COMM_BUFFER_T buffer, BOOL ackReq ) +{ + BOOL result = FALSE; + BOOL error = FALSE; + U32 msgSize = 0; + U32 sizeMod, sizePad; + U32 i; + U08 crc; + U08 data[ MAX_ACK_MSG_SIZE ]; // byte array to populate with message data + // prefix data with message sync byte + data[ msgSize++ ] = MESSAGE_SYNC_BYTE; + + // set sequence # and ACK bit (unless this is an ACK to a received message) + if ( msg.hdr.msgID != MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK ) + { + // thread protect next sequence # access & increment + _disable_IRQ(); + msg.hdr.seqNo = nextSeqNo; + nextSeqNo = INC_WRAP( nextSeqNo, MIN_MSG_SEQ_NO, MAX_MSG_SEQ_NO ); + _enable_IRQ(); + if ( TRUE == ackReq ) + { + msg.hdr.seqNo *= -1; + } + } + + // calculate message CRC + crc = crc8( (U08*)(&msg), sizeof( MESSAGE_HEADER_T ) + msg.hdr.payloadLen ); + + // serialize message header data + memcpy( &data[ msgSize ], &( msg.hdr ), sizeof( MESSAGE_HEADER_T ) ); + msgSize += sizeof( MESSAGE_HEADER_T ); + + // serialize message payload (only used bytes per payloadLen field) + memcpy( &data[ msgSize ], &( msg.payload ), msg.hdr.payloadLen ); + msgSize += msg.hdr.payloadLen; + + // add 8-bit CRC + data[ msgSize++ ] = crc; + + // pad with zero bytes to get length a multiple of CAN_FRAME_PAYLOAD_SIZE (8) + sizeMod = msgSize % CAN_FRAME_PAYLOAD_SIZE; + sizePad = ( sizeMod == 0 ? 0 : CAN_FRAME_PAYLOAD_SIZE - sizeMod ); + for ( i = 0; i < sizePad; i++ ) + { + data[ msgSize++ ] = 0; + } + + // if ACK required, add to pending ACK list + if ( TRUE == ackReq ) + { + if ( FALSE == addMsgToPendingACKList( &msg, buffer, data, msgSize ) ) + { + error = TRUE; + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_MSG_PENDING_ACK_LIST_FULL ) + } + } + + if ( FALSE == error ) + { + // add serialized message data to appropriate out-going comm buffer + result = addToCommBuffer( buffer, data, msgSize ); + } + + return result; +} + /*********************************************************************//** * @brief * The sendACKMsg function constructs and queues for transmit an ACK message @@ -219,7 +310,7 @@ * @param ack TRUE if test message was handled successfully, FALSE if not * @return TRUE if response message successfully queued for transmit, FALSE if not *************************************************************************/ -static BOOL sendAckResponseMsg( MSG_ID_T msgID, COMM_BUFFER_T buffer, BOOL ack ) +BOOL sendAckResponseMsg( MSG_ID_T msgID, COMM_BUFFER_T buffer, BOOL ack ) { BOOL result; MESSAGE_T msg; @@ -253,9 +344,9 @@ // Search for the index associated with the given override command message ID and then use index to get the handling function for ( i = 0; i < NUM_OF_FUNCTION_HANDLERS; i++ ) { - if ( MSG_FUNCTION_HANDLER_LOOKUP[i] == msgID ) + if ( MSG_FUNCTION_HANDLER_LOOKUP[i].msgID == msgID ) { - func = MSG_FUNCTION_HANDLERS[i]; + func = MSG_FUNCTION_HANDLER_LOOKUP[i].msgHandler; break; } } @@ -277,7 +368,8 @@ COMM_BUFFER_T respBuffer = tdResponseBuffers[ message->in_buffer ]; // if Dialin message, ensure Dialin is logged in before processing it - if ( ( message->hdr.msgID <= MSG_ID_FIRST_DD_TESTER_MESSAGE ) || + if ( ( message->hdr.msgID < MSG_ID_FIRST_TD_TESTER_MESSAGE ) || + ( MSG_ID_FIRST_DD_TESTER_MESSAGE == message->hdr.msgID ) || ( TRUE == isTestingActivated() ) ) { MsgFuncPtr msgFuncPtr; @@ -291,12 +383,12 @@ } } // ACK/NAK request - if ( message->hdr.msgID < MSG_ID_FIRST_DD_TESTER_MESSAGE ) + if ( message->hdr.msgID < MSG_ID_FIRST_TD_TESTER_MESSAGE ) { - if ( respBuffer != COMM_BUFFER_NOT_USED ) - { - sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, respBuffer, ack ); - } +// if ( respBuffer != COMM_BUFFER_NOT_USED ) +// { +// sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, respBuffer, ack ); +// } } else { @@ -310,10 +402,10 @@ /*********************************************************************//** * @brief - * The sendEvent function constructs an DG event message to the UI and + * The sendEvent function constructs an DD event message to the UI and * queues the msg for transmit on the appropriate CAN channel. * @details \b Inputs: none - * @details \b Outputs: DG event msg constructed and queued. + * @details \b Outputs: DD event msg constructed and queued. * @param event Enumeration of event type that occurred * @param dat1 First data associated with event * @param dat2 Second data associated with event @@ -381,7 +473,7 @@ 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 + // Pad with space for 3 U32s - set to zero - unused for DD payloadPtr += ( sizeof( U32) * 3 ); memset( payloadPtr, 0, sizeof( U32) * 3 ); @@ -483,6 +575,43 @@ return status; } +/*********************************************************************//** + * @brief + * The handleVersionRequestMessage function handles a UI request for DD + * version information. + * @details \b Message \b Sent: MSG_ID_DD_VERSION_REPONSE + * @details \b Inputs: none + * @details \b Outputs: UI version info. + * @param message Pointer to the UI version request message which contains + * the UI version information as well. + * @return TRUE if request handled successfully, FALSE if not + *************************************************************************/ +BOOL handleVersionRequestMessage( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + if ( message->hdr.payloadLen == sizeof( UI_VERSIONS_T ) ) + { + DD_VERSIONS_T ddVersionRecord; + + // Record UI version information + memcpy( (U08*)(&uiVersionRecord), &message->payload, sizeof( UI_VERSIONS_T ) ); + + // Build DD version record + ddVersionRecord.major = DD_VERSION_MAJOR; + ddVersionRecord.minor = DD_VERSION_MINOR; + ddVersionRecord.micro = DD_VERSION_MICRO; + ddVersionRecord.build = DD_VERSION_BUILD; + getFPGAVersions( &ddVersionRecord.fpgaId, &ddVersionRecord.fpgaMajor, &ddVersionRecord.fpgaMinor, &ddVersionRecord.fpgaLab ); + ddVersionRecord.compatibilityRev = SW_COMPATIBILITY_REV; + + // Send DD version information + result = sendMessage( MSG_ID_DD_VERSION_RESPONSE, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&ddVersionRecord, sizeof( DD_VERSIONS_T ) ); + } + + return result; +} + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -563,8 +692,6 @@ { testerLoggedIn = FALSE; } - // respond to would be tester - sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, testerLoggedIn ); return testerLoggedIn; }