Index: firmware/App/Controllers/PresOccl.c =================================================================== diff -u -rb4bc2e0337b358ee180650101d98e18346bf7c22 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision b4bc2e0337b358ee180650101d98e18346bf7c22) +++ firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -50,15 +50,16 @@ #define VENOUS_PRESSURE_SELF_TEST_MIN ( -100.0 ) ///< Minimum self-test value for venous pressure sensor reading (in mmHg). #define VENOUS_PRESSURE_SELF_TEST_MAX ( 600.0 ) ///< Maximum self-test value for venous pressure sensor reading (in mmHg). +#define VENOUS_PRESSURE_MIN_TEMP ( 0.0 ) ///< Minimum venous pressure sensor temperature. TODO - get from Systems +#define VENOUS_PRESSURE_MAX_TEMP ( 50.0 ) ///< Maximum venous pressure sensor temperature. TODO - get from Systems + #define PSI_TO_MMHG ( 51.7149 ) ///< Conversion factor for converting PSI to mmHg. #define VENOUS_PRESSURE_NORMAL_OP 0 ///< Venous pressure status bits indicate normal operation. #define VENOUS_PRESSURE_CMD_MODE 1 ///< Venous pressure status bits indicate sensor in command mode. #define VENOUS_PRESSURE_STALE_DATA 2 ///< Venous pressure status bits indicate data is stale (no new data since last fpga read). #define VENOUS_PRESSURE_DIAG_CONDITION 3 ///< Venous pressure status bits diagnostic condition (alarm). -static const U32 MAX_TIME_BETWEEN_VENOUS_READINGS = ( 500 / TASK_GENERAL_INTERVAL ); ///< Maximum time without fresh inline venous pressure reading. - #define OCCLUSION_THRESHOLD 25000 ///< Threshold above which an occlusion is detected. #define CARTRIDGE_LOADED_THRESHOLD 5000 ///< Threshold above which a cartridge is considered loaded. @@ -101,8 +102,12 @@ static OVERRIDE_U32_T dialInPumpOcclusion = {0, 0, 0, 0 }; ///< Measured dialysate inlet pump occlusion pressure. static OVERRIDE_U32_T dialOutPumpOcclusion = {0, 0, 0, 0 }; ///< Measured dialysate outlet pump occlusion pressure. -static U32 staleVenousPressureCtr = 0; ///< Timer counter for stale venous pressure reading. static U32 emptySalineBagCtr = 0; ///< Timer counter for empty bag detection. + +static U08 lastVenousPressureReadCtr; ///< Previous venous pressure read counter. +static U08 lastBPOcclReadCtr; ///< Previous BP occlusion read counter. +static U08 lastDPiOcclReadCtr; ///< Previous DPi occlusion read counter. +static U08 lastDPoOcclReadCtr; ///< Previous DPo occlusion read counter. // ********** private function prototypes ********** @@ -129,6 +134,16 @@ initPersistentAlarm( ALARM_ID_ARTERIAL_PRESSURE_HIGH, PRES_ALARM_PERSISTENCE, PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_VENOUS_PRESSURE_LOW, PRES_ALARM_PERSISTENCE, PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_VENOUS_PRESSURE_HIGH, PRES_ALARM_PERSISTENCE, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_VENOUS_PRESSURE_READ_TIMEOUT_ERROR, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_VENOUS_PRESSURE_SENSOR_TEMP_OUT_OF_RANGE, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_BP_OCCLUSION_READ_TIMEOUT_ERROR, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_DPI_OCCLUSON_READ_TIMEOUT_ERROR, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_DPO_OCCLUSION_READ_TIMEOUT_ERROR, 0, PRES_ALARM_PERSISTENCE ); + + lastVenousPressureReadCtr = 0; + lastBPOcclReadCtr = 0; + lastDPiOcclReadCtr = 0; + lastDPoOcclReadCtr = 0; } /*********************************************************************//** @@ -270,15 +285,17 @@ { U32 fpgaArtPres = getFPGAArterialPressure(); S32 artPres = (S32)( fpgaArtPres & MASK_OFF_U32_MSB ) - 0x800000; // Subtract 2^23 from low 24 bits to get signed reading - U08 artPresAlarm = (U08)( fpgaArtPres >> 24 ); // High byte is alarm code for arterial pressure + U08 artPresAlarm = (U08)( fpgaArtPres >> SHIFT_24_BITS ); // High byte is alarm code for arterial pressure U16 fpgaVenPres = getFPGAVenousPressure(); U16 venPres = fpgaVenPres & 0x3FFF; // 14-bit data U08 venPresStatus = (U08)( fpgaVenPres >> 14 ); // High 2 bits is status code for venous pressure F32 venPresPSI; + F32 venTemp = getFPGAVenousPressureTemperature(); + U08 venReadCtr = getFPGAVenousPressureReadCounter(); // TODO - any filtering required??? - // Convert arterial pressure to mmHg if no alarm + // Convert arterial pressure to mmHg if no fault if ( 0 == artPresAlarm ) { arterialPressure.data = ARTERIAL_PRESSURE_V_PER_BIT * ( (F32)(artPres) / ( ARTERIAL_PRESSURE_SENSITIVITY * ARTERIAL_PRESSURE_V_BIAS ) ); @@ -290,31 +307,33 @@ #endif } - // Convert venous pressure to PSI + // Check for stale venous pressure reading + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_READ_TIMEOUT_ERROR, ( lastVenousPressureReadCtr == venReadCtr ) ) ) + { + activateAlarmNoData( ALARM_ID_HD_VENOUS_PRESSURE_READ_TIMEOUT_ERROR ); + } + // Record venous read counter for next time around + lastVenousPressureReadCtr = venReadCtr; + // Convert venous pressure to PSI and then mmHg venPresPSI = ( (F32)(venPres - VENOUS_PRESSURE_OFFSET) * (VENOUS_PRESSURE_MAX - VENOUS_PRESSURE_MIN) / (F32)VENOUS_PRESSURE_SCALE ) + VENOUS_PRESSURE_MIN; // Convert venous pressure from PSI to mmHg if sensor status is normal if ( VENOUS_PRESSURE_NORMAL_OP == venPresStatus ) { venousPressure.data = venPresPSI * PSI_TO_MMHG; - staleVenousPressureCtr = 0; } - // If venous pressure sensor status is not normal or reading is stale for too long, fault + // If venous pressure sensor status is not normal, fault else { - if ( ++staleVenousPressureCtr > MAX_TIME_BETWEEN_VENOUS_READINGS ) - { #ifndef DISABLE_PRESSURE_CHECKS - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_VENOUS_PRESSURE_SENSOR_FAULT, VENOUS_PRESSURE_STALE_DATA ) + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_VENOUS_PRESSURE_SENSOR_FAULT, (U32)venPresStatus ) // TODO - persistence? #endif - } } - // Check for venous pressure sensor alarm or in wrong (cmd) mode - if ( ( VENOUS_PRESSURE_DIAG_CONDITION == venPresStatus ) || ( VENOUS_PRESSURE_CMD_MODE == venPresStatus ) ) + // Check venous pressure sensor temperature + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_SENSOR_TEMP_OUT_OF_RANGE, + ( venTemp > VENOUS_PRESSURE_MAX_TEMP || venTemp < VENOUS_PRESSURE_MIN_TEMP ) ) ) { -#ifndef DISABLE_PRESSURE_CHECKS - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_VENOUS_PRESSURE_SENSOR_FAULT, (U32)venPresStatus ) -#endif + SET_ALARM_WITH_1_F32_DATA( ALARM_ID_VENOUS_PRESSURE_SENSOR_FAULT, venTemp ) } } @@ -327,10 +346,52 @@ *************************************************************************/ static void convertOcclusionPressures( void ) { - // Occlusion sensor values have no unit - take as is + U08 bpReadCtr = getFPGABloodPumpOcclusionReadCounter(); + U08 dpiReadCtr = getFPGADialInPumpOcclusionReadCounter(); + U08 dpoReadCtr = getFPGADialOutPumpOcclusionReadCounter(); + U08 bpErrorCtr = getFPGABloodPumpOcclusionErrorCounter(); + U08 dpiErrorCtr = getFPGADialInPumpOcclusionErrorCounter(); + U08 dpoErrorCtr = getFPGADialOutPumpOcclusionErrorCounter(); + +#ifndef DISABLE_FPGA_COUNTER_CHECKS + // Check for sensor errors + if ( bpErrorCtr > 0 ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BP_OCCLUSION_SENSOR_ERROR, (U32)bpErrorCtr ) + } + if ( dpiErrorCtr > 0 ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DPI_OCCLUSION_SENSOR_ERROR, (U32)dpiErrorCtr ) + } + if ( dpoErrorCtr > 0 ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DPO_OCCLUSION_SENSOR_ERROR, (U32)dpoErrorCtr ) + } + + // Check for stale occlusion reads + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_BP_OCCLUSION_READ_TIMEOUT_ERROR, ( bpReadCtr == lastBPOcclReadCtr ) ) ) + { + activateAlarmNoData( ALARM_ID_HD_BP_OCCLUSION_READ_TIMEOUT_ERROR ); + } + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_BP_OCCLUSION_READ_TIMEOUT_ERROR, ( dpiReadCtr == lastDPiOcclReadCtr ) ) ) + { + activateAlarmNoData( ALARM_ID_HD_DPI_OCCLUSON_READ_TIMEOUT_ERROR ); + } + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_BP_OCCLUSION_READ_TIMEOUT_ERROR, ( dpoReadCtr == lastDPoOcclReadCtr ) ) ) + { + activateAlarmNoData( ALARM_ID_HD_DPO_OCCLUSION_READ_TIMEOUT_ERROR ); + } +#endif + + // Record occlusion sensor readings bloodPumpOcclusion.data = (U32)getFPGABloodPumpOcclusion(); dialInPumpOcclusion.data = (U32)getFPGADialInPumpOcclusion(); dialOutPumpOcclusion.data = (U32)getFPGADialOutPumpOcclusion(); + + // Record occlusion read counters for next time around + lastBPOcclReadCtr = bpReadCtr; + lastDPiOcclReadCtr = dpiReadCtr; + lastDPoOcclReadCtr = dpoReadCtr; } /*********************************************************************//** Index: firmware/App/HDCommon.h =================================================================== diff -u -ra97fcffbe7b7b2d9543358ac06868829d41cf173 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/HDCommon.h (.../HDCommon.h) (revision a97fcffbe7b7b2d9543358ac06868829d41cf173) +++ firmware/App/HDCommon.h (.../HDCommon.h) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -25,20 +25,21 @@ #define HD_VERSION_MAJOR 0 #define HD_VERSION_MINOR 5 #define HD_VERSION_MICRO 0 -#define HD_VERSION_BUILD 0 +#define HD_VERSION_BUILD 9035 // ********** development build switches ********** // TODO - remove build switches before release #ifndef _RELEASE_ #ifndef _VECTORCAST_ -// #define BOARD_WITH_NO_HARDWARE 1 +// #define USING_DEBUGGER 1 // Want to be able to use the debugger and have break points +// #define BOARD_WITH_NO_HARDWARE 1 // Target is a PCB w/ no hardware // #define RUN_WITHOUT_DG 1 // Run HD w/o DG // #define SIMULATE_UI 1 // Build w/o requirement that UI be there // #define TASK_TIMING_OUTPUT_ENABLED 1 // Re-purposes alarm lamp pins for task timing // #define DISABLE_ALARM_AUDIO 1 // Disable alarm audio - #define SKIP_POST 1 // Skip POST tests - all pass - #define DONT_SKIP_NV_POST 1 +// #define SKIP_POST 1 // Skip POST tests - all pass +// #define DONT_SKIP_NV_POST 1 // Do not skip NV Data POST #define DISABLE_AIR_TRAP_LEVELING 1 // Disable air trap level control // #define DISABLE_3WAY_VALVES 1 // Disable 3-way valves // #define TST_3WAY_VALVES_ALWAYS_OPEN 1 // After POST and homing, open all 4 valves @@ -49,19 +50,23 @@ #define DISABLE_PUMP_FLOW_CHECKS 1 // Do not error on HD pump flow checks #define DISABLE_PUMP_SPEED_CHECKS 1 // Do not error on HD pump speed checks #define DISABLE_PUMP_DIRECTION_CHECKS 1 // Do not error on HD pump direction checks - #define DISABLE_SYRINGE_PUMP 1 // Disable syringe pump functionality +// #define DISABLE_SYRINGE_PUMP 1 // Disable syringe pump functionality + #define ALWAYS_ALLOW_SYRINGE_PUMP_CMDS 1 // Allow syringe pump commands at any time except when pump is busy #define DISABLE_PRESSURE_CHECKS 1 // Do not error on HD pressure checks // #define DISABLE_UF_ALARMS 1 // Do not error on HD ultrafiltration checks // #define DISABLE_VALVE_ALARMS 1 // Do not error on HD valve position - #define DISABLE_CAL_CHECK 1 + #define DISABLE_CAL_CHECK 1 // Disable calibration checks // #define RUN_PUMPS_OPEN_LOOP 1 // BP and DPi pumps will be run open loop (no flow sensor feedback) // #define RAW_FLOW_SENSOR_DATA 1 // Test build will not filter flow sensor data // #define READ_FPGA_ASYNC_DATA 1 // Test build reads non-priority register page every other time // #define EMC_TEST_BUILD 1 // EMC test build - HD/DG run separately but connected, HD pumps toggle on/off w/ stop button #define ALARMS_DEBUG 1 // Triggered alarms sent to debug UART + #define ALARM_VOLUME_DEFAULT_LOW 1 // Set default alarm volume to lowest + #define TEMP_UI_ALARM_SILENCE_FIX 1 // Temporary UI fix for handling alarm silence request msg #define SKIP_PRIMING 1 // Skip Pre-treatment Prime #define SKIP_WET_SELF_TESTS 1 // Skip Pre-treatment prime wet self-tests // #define V1_5_SYSTEM 1 // Build for v1.5 system +// #define V2_0_SYSTEM 1 // Build for v2.0 system #define SKIP_SAMPLE_WATER 1 // Skip pre-treatment sample water #define SKIP_CONSUMABLE_TESTS 1 // Skip pre-treatment consumable Self-tests #define SKIP_DRY_SELF_TESTS 1 // Skip pre-treatment dry self-tests @@ -71,6 +76,7 @@ #define DISABLE_OCCLUSION_SELF_TEST 1 // Skip occlusion sensor self-test. #define SKIP_CARTRIDGE_REMOVAL 1 // Skip cartridge removal check #define SKIP_EMPTY_RES_CHECK 1 // Skip reservoir empty check + #define DISABLE_FPGA_COUNTER_CHECKS 1 // Disable alarms associated with FPGA read/error counters #include Index: firmware/App/Modes/SelfTests.c =================================================================== diff -u -r108a0285f895e26bb037f3472bb05962ea3c4941 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Modes/SelfTests.c (.../SelfTests.c) (revision 108a0285f895e26bb037f3472bb05962ea3c4941) +++ firmware/App/Modes/SelfTests.c (.../SelfTests.c) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -212,10 +212,10 @@ void transitionToNoCartSelfTests( void ) { F32 const bolusVol = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ); - F32 const hepRate = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ); + F32 const hepRate = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_DISPENSE_RATE ); #ifndef DISABLE_SYRINGE_PUMP - useHeparin = ( ( bolusVol > 0.0 ) || ( hepRate > 0.0 ) ); + useHeparin = ( ( bolusVol > 0.0 ) || ( hepRate > 0.0 ) ? TRUE : FALSE ); #else useHeparin = FALSE; #endif @@ -334,14 +334,6 @@ *************************************************************************/ void transitionToDrySelfTests() { - F32 const bolusVol = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ); - F32 const hepRate = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ); - -#ifndef DISABLE_SYRINGE_PUMP - useHeparin = ( ( bolusVol > 0.0 ) || ( hepRate > 0.0 ) ); -#else - useHeparin = FALSE; -#endif currentDrySelfTestsState = DRY_SELF_TESTS_START_STATE; pressureSelfTestBloodPumpRunStartTime = 0; pressureSelfTestNormalizedStartTime = 0; @@ -637,7 +629,7 @@ if ( TRUE == useHeparin ) { - if ( ( FALSE == isSyringePumpHome() ) && ( TRUE == isSyringePumpStopped() ) ) + if ( TRUE == isSyringePumpStopped() ) { retractSyringePump(); } @@ -797,10 +789,6 @@ { state = DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE; } - else - { - activateAlarmNoData( ALARM_ID_INSTALL_NEW_CARTRIDGE ); - } if ( TRUE == doesAlarmStatusIndicateStop() ) { Index: firmware/App/Services/AlarmMgmt.h =================================================================== diff -u -r5b6e7cedbfced5d5ceff8d49fca6aacd04d7e037 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Services/AlarmMgmt.h (.../AlarmMgmt.h) (revision 5b6e7cedbfced5d5ceff8d49fca6aacd04d7e037) +++ firmware/App/Services/AlarmMgmt.h (.../AlarmMgmt.h) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -51,7 +51,7 @@ ALARM_ACTION_ACK, ///< User selected Ack from alarm recovery options NUMBER_OF_ALARM_ACTIONS ///< Number of alarm actions } ALARM_ACTION_T; - + #pragma pack(push, 4) /// Record structure for detailing the properties of the current composite alarm status. typedef struct @@ -63,7 +63,7 @@ BOOL alarmsToEscalate; ///< Are any active alarms due to escalate (should UI show count down timer?) U32 alarmsEscalatesIn; ///< Time until alarm will escalate (seconds) ALARM_ID_T alarmTop; ///< ID of current top alarm that will drive lamp/audio and UI should be displaying right now - BOOL topAlarmConditionnDetected; ///< Condition for top alarm is still being detected + BOOL topAlarmConditionDetected; ///< Condition for top alarm is still being detected BOOL systemFault; ///< A system fault is active? BOOL stop; ///< We should be in controlled stop right now BOOL noClear; ///< No recovery will be possible @@ -73,6 +73,7 @@ BOOL noNewTreatment; ///< No new treatments may be started even if current treatment is ended BOOL noDialRecirc; ///< No dialysate re-circulation allowed at this time BOOL usrACKRequired; ///< The user must acknowledge top alarm + BOOL noMinimize; ///< Prevent user from minimizing the alarm window BOOL lampOn; ///< The alarm lamp is on } COMP_ALARM_STATUS_T; @@ -115,6 +116,17 @@ ALARM_DATA_TYPES_T dataType; ///< The type of alarm data provided. ALARM_DATAS_T data; ///< The alarm data of specified type. } ALARM_DATA_T; + +/// Payload record structure for the alarm info message. +typedef struct +{ + U32 audioVolume; ///< Audio volume level (1..5) + F32 audioCurrHG; ///< Primary alarm audio current - high gain (mA) + F32 audioCurrLG; ///< Primary alarm audio current - low gain (mA) + F32 backupAudioCurr; ///< Backup alarm audio current (mA) + BOOL safetyShutdown; ///< Safety shutdown activated? (T/F) +} ALARM_INFO_PAYLOAD_T; + #pragma pack(pop) #pragma pack(push, 2) @@ -271,13 +283,27 @@ BOOL doesAlarmStatusIndicateStop( void ); ALARM_PRIORITY_T getCurrentAlarmStatePriority( void ); BOOL isAlarmRecoverable( ALARM_ID_T alarm ); -void setAlarmAudioVolume( U32 volumeLevel ); +void setAlarmAudioVolume( U32 volumeLevel ); +U32 getAlarmAudioVolume( void ); +F32 getAlarmAudioPrimaryHighGainCurrent( void ); +F32 getAlarmAudioPrimaryLowGainCurrent( void ); +F32 getAlarmAudioBackupCurrent( void ); BOOL testSetAlarmStateOverride( U32 alarmID, BOOL value ); BOOL testResetAlarmStateOverride( U32 alarmID ); BOOL testSetAlarmStartOverride( U32 alarmID, U32 value ); BOOL testResetAlarmStartOverride( U32 alarmID ); -BOOL testClearAllAlarms( U32 key ); +BOOL testClearAllAlarms( U32 key ); +BOOL testSetAlarmInfoPublishIntervalOverride( U32 ms ); +BOOL testResetAlarmInfoPublishIntervalOverride( void ); +BOOL testSetAlarmAudioVolumeLevelOverride( U32 volume ); +BOOL testResetAlarmAudioVolumeLevelOverride( void ); +BOOL testSetPrimaryAlarmAudioCurrentHGOverride( F32 mA ); +BOOL testResetPrimaryAlarmAudioCurrentHGOverride( void ); +BOOL testSetPrimaryAlarmAudioCurrentLGOverride( F32 mA ); +BOOL testResetPrimaryAlarmAudioCurrentLGOverride( void ); +BOOL testSetBackupAlarmAudioCurrentOverride( F32 mA ); +BOOL testResetBackupAlarmAudioCurrentOverride( void ); /**@}*/ Index: firmware/App/Services/FPGA.c =================================================================== diff -u -r3956c379375c22a95accfd791245e32e0782705a -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Services/FPGA.c (.../FPGA.c) (revision 3956c379375c22a95accfd791245e32e0782705a) +++ firmware/App/Services/FPGA.c (.../FPGA.c) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -82,10 +82,15 @@ #define FPGA_AIRTRAP_LEVEL_LOW_MASK 0x0008 ///< Bit mask for air trap lower level sensor. #define FPGA_AIRTRAP_LEVEL_HIGH_MASK 0x0004 ///< Bit mask for air trap upper level sensor. -#define FPGA_FLUIDLEAK_STATE_MASK 0x0040 ///< Bit mask for fluid leak detector. +#define FPGA_FLUID_LEAK_STATE_MASK 0x0040 ///< Bit mask for fluid leak detector. +#define FPGA_BLOOD_LEAK_STATUS_MASK 0x1000 ///< Bit mask for blood leak detector. +#define FPGA_BLOOD_LEAK_ZERO_STATE_MASK 0x2000 ///< Bit mask for blood leak detector zero. + +#define FPGA_BLOOD_LEAK_ZERO_CMD 0x02 ///< Bit for blood leak detector zero command. +#define FPGA_BLOOD_LEAK_SELF_TEST_CMD 0x01 ///< Bit for blood leak detector self test command. + #define FPGA_ADA_INPUT_STATUS_MASK 0x0001 ///< Bit mask for arterial air bubble detector input status. #define FPGA_ADV_INPUT_STATUS_MASK 0x0002 ///< Bit mask for venous air bubble detector input status. -#define FPGA_BLOOD_LEAK_STATUS_MASK 0x1000 ///< Bit mask for blood leak detector status. #define FPGA_PBO_TEMP_DIVISOR 2047.0 ///< Used in conversion of PBo temperature reading to deg C. #define FPGA_PBO_TEMP_GAIN 200.0 ///< Used in conversion of PBo temperature reading to deg C. @@ -1845,34 +1850,6 @@ /*********************************************************************//** * @brief - * The setFPGASensorTest function sets the sensor test output. - * @details Inputs: fpgaActuatorSetPoints - * @details Outputs: fpgaActuatorSetPoints - * @param sensorTest - * @return none - *************************************************************************/ -void setFPGASensorTest( U08 sensorTest ) -{ - fpgaActuatorSetPoints.fpgaSensorTest = sensorTest; -} - -/*********************************************************************//** - * @brief - * The getFPGABloodLeakDetectorStatus function gets the latest blood leak - * detector status. - * @details Inputs: fpgaSensorReadings - * @details Outputs: none - * @return TRUE if blood leak is detected, otherwise FALSE - *************************************************************************/ -BOOL getFPGABloodLeakDetectorStatus( void ) -{ - U16 const status = fpgaSensorReadings.fpgaGPIO & FPGA_BLOOD_LEAK_STATUS_MASK; - - return ( 0 == status ? FALSE : TRUE ); -} - -/*********************************************************************//** - * @brief * The getDoorState function gets the current state of door switch. * @details Inputs: none * @details Outputs: none @@ -1913,21 +1890,103 @@ /*********************************************************************//** * @brief - * The noFluidLeakDetected function returns TRUE if no fluid leak has been + * The noFPGAFluidLeakDetected function returns TRUE if no fluid leak has been * detected (dry) and FALSE if a fluid leak has been detected (wet). * @details Inputs: fpgaSensorReadings * @details Outputs: none - * @return noFluidLeakDetected + * @return noFPGAFluidLeakDetected *************************************************************************/ BOOL noFPGAFluidLeakDetected( void ) { - U16 noFluidLeakDetected = fpgaSensorReadings.fpgaGPIO & FPGA_FLUIDLEAK_STATE_MASK; + U16 noFPGAFluidLeakDetected = fpgaSensorReadings.fpgaGPIO & FPGA_FLUID_LEAK_STATE_MASK; - return ( 0 == noFluidLeakDetected ? FALSE : TRUE ); + return ( 0 == noFPGAFluidLeakDetected ? FALSE : TRUE ); } /*********************************************************************//** * @brief + * The noFPGABloodLeakDetected function returns TRUE if no blood leak has been + * detected and FALSE if a blood leak has been detected. + * @details Inputs: fpgaSensorReadings + * @details Outputs: none + * @return noFPGABloodLeakDetected + *************************************************************************/ +BOOL noFPGABloodLeakDetected( void ) +{ + U16 noFPGABloodLeakDetected = fpgaSensorReadings.fpgaGPIO & FPGA_BLOOD_LEAK_STATUS_MASK; + + return ( 0 == noFPGABloodLeakDetected ? TRUE : FALSE ); +} + +/*********************************************************************//** + * @brief + * The FPGABloodLeakZeroDetected function returns TRUE if blood leak zeroing has + * been detected and FALSE if no blood leak zeroing has been detected. + * @details Inputs: fpgaSensorReadings + * @details Outputs: none + * @return FPGABloodLeakZeroDetected + *************************************************************************/ +BOOL FPGABloodLeakZeroDetected( void ) +{ + U16 FPGABloodLeakZeroDetected = fpgaSensorReadings.fpgaGPIO & FPGA_BLOOD_LEAK_ZERO_STATE_MASK; + + return ( 0 == FPGABloodLeakZeroDetected ? FALSE : TRUE ); +} + +/*********************************************************************//** + * @brief + * The setFPGABloodLeakZero function sets the Blood Leak detector into + * zeroing mode via the FPGA. + * @details Inputs: fpgaSensorReadings + * @details Outputs: none + * @return FPGABloodLeakZeroDetected + *************************************************************************/ +void setFPGABloodLeakZero( void ) +{ + fpgaActuatorSetPoints.fpgaSensorTest |= FPGA_BLOOD_LEAK_ZERO_CMD; +} + +/*********************************************************************//** + * @brief + * The clearFPGABloodLeakZero function clears the Blood Leak detector from + * zeroing mode via the FPGA. + * @details Inputs: fpgaSensorReadings + * @details Outputs: none + * @return none + *************************************************************************/ +void clearFPGABloodLeakZero( void ) +{ + fpgaActuatorSetPoints.fpgaSensorTest &= ~FPGA_BLOOD_LEAK_ZERO_CMD; +} + +/*********************************************************************//** + * @brief + * The setFPGABloodLeakSelfTest function sets the Blood Leak detector into + * self-test mode via the FPGA. + * @details Inputs: fpgaSensorReadings + * @details Outputs: none + * @return FPGABloodLeakZeroDetected + *************************************************************************/ +void setFPGABloodLeakSelfTest( void ) +{ + fpgaActuatorSetPoints.fpgaSensorTest |= FPGA_BLOOD_LEAK_SELF_TEST_CMD; +} + +/*********************************************************************//** + * @brief + * The clearFPGABloodLeakSelfTest function clears the Blood Leak detector from + * self-test mode via the FPGA. + * @details Inputs: fpgaSensorReadings + * @details Outputs: none + * @return none + *************************************************************************/ +void clearFPGABloodLeakSelfTest( void ) +{ + fpgaActuatorSetPoints.fpgaSensorTest &= ~FPGA_BLOOD_LEAK_SELF_TEST_CMD; +} + +/*********************************************************************//** + * @brief * The setValveDialyzerInletPosition function sets the position of VDi * in counts * @details Inputs: fpgaActuatorSetPoints Index: firmware/App/Services/FPGA.h =================================================================== diff -u -r04f033af4174bf41a7aa0ff9ccaae45b77472e01 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Services/FPGA.h (.../FPGA.h) (revision 04f033af4174bf41a7aa0ff9ccaae45b77472e01) +++ firmware/App/Services/FPGA.h (.../FPGA.h) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -58,10 +58,18 @@ F32 getFPGADialysateFlowSignalStrength( void ); F32 getFPGABloodFlow( void ); -F32 getFPGADialysateFlow( void ); - U08 getFPGABloodFlowMeterStatus( void ); +U08 getFPGABloodFlowFastPacketReadCounter( void ); +U08 getFPGABloodFlowSlowPacketReadCounter( void ); +U08 getFPGABloodFlowStatusPacketReadCounter( void ); +U08 getFPGABloodFlowErrorCounter( void ); + +F32 getFPGADialysateFlow( void ); U08 getFPGADialysateFlowMeterStatus( void ); +U08 getFPGADialysateFlowFastPacketReadCounter( void ); +U08 getFPGADialysateFlowSlowPacketReadCounter( void ); +U08 getFPGADialysateFlowStatusPacketReadCounter( void ); +U08 getFPGADialysateFlowErrorCounter( void ); U16 getFPGABloodPumpHallSensorCount( void ); U08 getFPGABloodPumpHallSensorStatus( void ); @@ -72,9 +80,17 @@ U32 getFPGAArterialPressure( void ); U16 getFPGAVenousPressure( void ); +F32 getFPGAVenousPressureTemperature( void ); +U08 getFPGAVenousPressureReadCounter( void ); U16 getFPGABloodPumpOcclusion( void ); U16 getFPGADialInPumpOcclusion( void ); U16 getFPGADialOutPumpOcclusion( void ); +U08 getFPGABloodPumpOcclusionReadCounter( void ); +U08 getFPGADialInPumpOcclusionReadCounter( void ); +U08 getFPGADialOutPumpOcclusionReadCounter( void ); +U08 getFPGABloodPumpOcclusionErrorCounter( void ); +U08 getFPGADialInPumpOcclusionErrorCounter( void ); +U08 getFPGADialOutPumpOcclusionErrorCounter( void ); void setFPGASyringePumpControlFlags( U08 bitFlags ); void setFPGASyringePumpADCandDACControlFlags( U08 bitFlags ); Index: firmware/App/Services/SystemComm.c =================================================================== diff -u -ra97fcffbe7b7b2d9543358ac06868829d41cf173 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Services/SystemComm.c (.../SystemComm.c) (revision a97fcffbe7b7b2d9543358ac06868829d41cf173) +++ firmware/App/Services/SystemComm.c (.../SystemComm.c) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -943,8 +943,10 @@ if ( TRUE == didTimeout( timeOfLastDGCheckIn, DG_COMM_TIMEOUT_IN_MS ) ) { +#ifndef RUN_WITHOUT_DG activateAlarmNoData( ALARM_ID_DG_COMM_TIMEOUT ); dgIsCommunicating = FALSE; +#endif } } } @@ -1207,6 +1209,10 @@ handleHeparinCommandRequest( message ); break; + case MSG_ID_UI_SET_ALARM_AUDIO_VOLUME_LEVEL_CMD: + handleAlarmAudioVolumeSetCmd( message ); + break; + case MSG_ID_UI_SET_UF_VOLUME_PARAMETER: handleUFVolumeSetRequest( message ); break; @@ -1535,6 +1541,10 @@ handleSetFluidLeakBroadcastIntervalOverrideRequest( message ); break; + case MSG_ID_HD_BLOOD_LEAK_STATUS_OVERRIDE: + handleSetFluidLeakStateDetectorOverrideRequest( message ); + break; + case MSG_ID_HD_FLUID_LEAK_STATE_OVERRIDE: handleSetFluidLeakStateOverrideRequest( message ); break; @@ -1543,10 +1553,6 @@ handleSetBloodLeakDataBroadcastIntervalOverrideRequest( message ); break; - case MSG_ID_HD_BLOOD_LEAK_STATUS_OVERRIDE: - handleSetBloodLeakStatusOverrideRequest( message ); - break; - case MSG_ID_HD_BLOOD_LEAK_ZERO_REQUEST: handleBloodLeakZeroRequest( message ); break; @@ -1591,6 +1597,50 @@ handleTestSyringePumpMeasuredVolumeOverrideRequest( message ); break; + case MSG_ID_HD_MONITORED_VOLTAGES_SEND_INTERVAL_OVERRIDE: + handleTestMonitoredVoltagesSendIntervalOverrideRequest( message ); + break; + + case MSG_ID_HD_MONITORED_VOLTAGES_OVERRIDE: + handleTestMonitoredVoltageOverrideRequest( message ); + break; + + case MSG_ID_HD_ALARM_INFO_SEND_INTERVAL_OVERRIDE: + handleTestAlarmInfoSendIntervalOverrideRequest( message ); + break; + + case MSG_ID_HD_ALARM_AUDIO_VOLUME_LEVEL_OVERRIDE: + handleTestAlarmAudioVolumeOverrideRequest( message ); + break; + + case MSG_ID_HD_ALARM_AUDIO_CURRENT_HG_OVERRIDE: + handleTestAlarmAudioCurrentHgOverrideRequest( message ); + break; + + case MSG_ID_HD_ALARM_AUDIO_CURRENT_LG_OVERRIDE: + handleTestAlarmAudioCurrentLgOverrideRequest( message ); + break; + + case MSG_ID_HD_ALARM_BACKUP_AUDIO_CURRENT_OVERRIDE: + handleTestAlarmBackupAudioCurrentOverrideRequest( message ); + break; + + case MSG_ID_HD_SYRINGE_PUMP_STATUS_OVERRIDE: + handleTestSyringePumpStatusOverrideRequest( message ); + break; + + case MSG_ID_HD_SYRINGE_PUMP_ENCODER_STATUS_OVERRIDE: + handleTestSyringePumpEncoderStatusOverrideRequest( message ); + break; + + case MSG_ID_HD_SYRINGE_PUMP_ADC_DAC_STATUS_OVERRIDE: + handleTestSyringePumpADCandDACStatusOverrideRequest( message ); + break; + + case MSG_ID_HD_SYRINGE_PUMP_ADC_READ_COUNTER_OVERRIDE: + handleTestSyringePumpADCReadCtrOverrideRequest( message ); + break; + case MSG_ID_HD_VALVES_CURRENT_OVERRIDE: handleTestValvesCurrentOverrideRequest( message ); break; Index: firmware/App/Services/SystemCommMessages.c =================================================================== diff -u -ra97fcffbe7b7b2d9543358ac06868829d41cf173 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision a97fcffbe7b7b2d9543358ac06868829d41cf173) +++ firmware/App/Services/SystemCommMessages.c (.../SystemCommMessages.c) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -497,6 +497,38 @@ return result; } +/*********************************************************************//** + * @brief + * The sendAlarmAudioVolumeSetResponse function constructs an alarm audio + * volume set request response to the UI and queues the msg for transmit on the + * appropriate CAN channel. + * @details Inputs: none + * @details Outputs: Alarm audio volume set. + * @param accepted flag indicating whether request was accepted + * @param rejReason rejection reason code + * @return TRUE if msg successfully queued for transmit, FALSE if not + *************************************************************************/ +BOOL sendAlarmAudioVolumeSetResponse( U32 accepted, U32 rejReason ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_HD_ALARM_AUDIO_VOLUME_SET_RESPONSE; + msg.hdr.payloadLen = sizeof( U32 ) * 2; + + memcpy( payloadPtr, &accepted, sizeof( U32 ) ); + payloadPtr += sizeof( U32 ); + memcpy( payloadPtr, &rejReason, 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_HD_2_UI, ACK_REQUIRED ); + + return result; +} + /*********************************************************************//** * @brief * The sendTreatmentParamsRangesToUI function constructs a treatment parameter @@ -1236,14 +1268,43 @@ payload.alarmsFlags |= ( almStatus.alarmsToEscalate ? BIT_BY_POS(ALARM_STATE_FLAG_BIT_POS_ALARMS_TO_ESCALATE) : 0 ); payload.alarmsFlags |= ( almStatus.alarmsSilenced ? BIT_BY_POS(ALARM_STATE_FLAG_BIT_POS_ALARMS_SILENCED) : 0 ); payload.alarmsFlags |= ( almStatus.lampOn ? BIT_BY_POS(ALARM_STATE_FLAG_BIT_POS_LAMP_ON) : 0 ); - payload.alarmsFlags |= ( almStatus.topAlarmConditionnDetected ? BIT_BY_POS(ALARM_STATE_FLAG_BIT_POS_TOP_CONDITION) : 0 ); + payload.alarmsFlags |= ( almStatus.noMinimize ? BIT_BY_POS(ALARM_STATE_FLAG_BIT_POS_NO_MINIMIZE) : 0 ); + payload.alarmsFlags |= ( almStatus.topAlarmConditionDetected ? BIT_BY_POS(ALARM_STATE_FLAG_BIT_POS_TOP_CONDITION) : 0 ); memcpy( payloadPtr, &payload, sizeof( ALARM_COMP_STATUS_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_HD_ALARM, ACK_NOT_REQUIRED ); return result; +} + +/*********************************************************************//** + * @brief + * The broadcastAlarmInfo function constructs an alarm information msg to + * be broadcast and queues the msg for transmit on the appropriate CAN channel. + * @details Inputs: none + * @details Outputs: alarm information msg constructed and queued. + * @param data alarm information record + * @return TRUE if msg successfully queued for transmit, FALSE if not + *************************************************************************/ +BOOL broadcastAlarmInfo( ALARM_INFO_PAYLOAD_T data ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_HD_ALARM_INFORMATION; + msg.hdr.payloadLen = sizeof( ALARM_INFO_PAYLOAD_T ); + + memcpy( payloadPtr, &data, sizeof( ALARM_INFO_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_HD_BROADCAST, ACK_NOT_REQUIRED ); + + return result; } /*********************************************************************//** @@ -1507,6 +1568,34 @@ result = serializeMessage( msg, COMM_BUFFER_OUT_CAN_HD_BROADCAST, ACK_NOT_REQUIRED ); return result; +} + +/*********************************************************************//** + * @brief + * The broadcastVoltagesData function constructs a monitored voltages data msg to + * be broadcast and queues the msg for transmit on the appropriate CAN channel. + * @details Inputs: none + * @details Outputs: monitored voltages data msg constructed and queued. + * @param data Latest monitored voltage values. + * @return TRUE if msg successfully queued for transmit, FALSE if not + *************************************************************************/ +BOOL broadcastVoltagesData( VOLTAGES_DATA_PAYLOAD_T data ) +{ + BOOL result; + MESSAGE_T msg; + U08 *payloadPtr = msg.payload; + + // Create a message record + blankMessage( &msg ); + msg.hdr.msgID = MSG_ID_HD_VOLTAGES_DATA; + msg.hdr.payloadLen = sizeof( VOLTAGES_DATA_PAYLOAD_T ); + + memcpy( payloadPtr, &data, sizeof( VOLTAGES_DATA_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_HD_BROADCAST, ACK_NOT_REQUIRED ); + + return result; } /*********************************************************************//** @@ -2300,14 +2389,24 @@ *************************************************************************/ void handleUIAlarmSilenceRequest( MESSAGE_T *message ) { +#ifndef TEMP_UI_ALARM_SILENCE_FIX if ( message->hdr.payloadLen == sizeof( U32 ) ) +#else + if ( message->hdr.payloadLen == sizeof( U08 ) ) +#endif { U08 *payloadPtr = message->payload; +#ifndef TEMP_UI_ALARM_SILENCE_FIX U32 cmd; memcpy( &cmd, payloadPtr, sizeof( U32 ) ); + signalAlarmSilence( (ALARM_SILENCE_CMD_T)cmd ); +#else + U08 cmd; + memcpy( &cmd, payloadPtr, sizeof( U08 ) ); signalAlarmSilence( (ALARM_SILENCE_CMD_T)cmd ); +#endif } else { @@ -2903,6 +3002,31 @@ /*********************************************************************//** * @brief + * The handleAlarmAudioVolumeSetCmd function handles a alarm audio volume + * set request message from the UI. + * @details Inputs: none + * @details Outputs: message handled + * @param message a pointer to the message to handle + * @return none + *************************************************************************/ +void handleAlarmAudioVolumeSetCmd( MESSAGE_T *message ) +{ + if ( sizeof( U32 ) == message->hdr.payloadLen ) + { + U32 payload; + + memcpy( &payload, &message->payload[0], sizeof( U32 ) ); + + setAlarmAudioVolume( payload ); + } + else + { + sendAckResponseMsg( (MSG_ID_T)message->hdr.msgID, COMM_BUFFER_OUT_CAN_HD_2_UI, FALSE ); + } +} + +/*********************************************************************//** + * @brief * The handleSalineBolusRequest function handles a saline bolus request * message from the UI. * @details Inputs: none @@ -5611,6 +5735,70 @@ /*********************************************************************//** * @brief + * The handleTestMonitoredVoltagesSendIntervalOverrideRequest function handles a + * request to override the monitored HD voltages data publication interval. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestMonitoredVoltagesSendIntervalOverrideRequest( 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 = testSetVoltagesDataPublishIntervalOverride( payload.state.u32 ); + } + else + { + result = testResetVoltagesDataPublishIntervalOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestMonitoredVoltageOverrideRequest function handles a + * request to override the monitored HD voltage override. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestMonitoredVoltageOverrideRequest( 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 = testSetLineLevelOverride( payload.index, payload.state.f32 ); + } + else + { + result = testResetLineLevelOverride( payload.index ); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief * The handleTestValvesCurrentOverrideRequest function handles a * request to override HD valves' current. * @details Inputs: none @@ -5635,6 +5823,8 @@ { result = testResetValvesCurrentOverride( payload.index ); } + + result = testSetValvesCurrentOverride( payload.index, payload.state.f32 ); } // Respond to request @@ -5643,6 +5833,291 @@ /*********************************************************************//** * @brief + * The handleTestAlarmInfoSendIntervalOverrideRequest function handles a + * request to override the HD alarm information broadcast interval. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestAlarmInfoSendIntervalOverrideRequest( 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 = testSetAlarmInfoPublishIntervalOverride( payload.state.u32 ); + } + else + { + result = testResetAlarmInfoPublishIntervalOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestAlarmAudioVolumeOverrideRequest function handles a + * request to override the alarm audio volume level. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestAlarmAudioVolumeOverrideRequest( 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 = testSetAlarmAudioVolumeLevelOverride( payload.state.u32 ); + } + else + { + result = testResetAlarmAudioVolumeLevelOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestAlarmAudioCurrentHgOverrideRequest function handles a + * request to override the alarm audio (high gain) current. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestAlarmAudioCurrentHgOverrideRequest( 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 = testSetPrimaryAlarmAudioCurrentHGOverride( payload.state.f32 ); + } + else + { + result = testResetPrimaryAlarmAudioCurrentHGOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestAlarmAudioCurrentLgOverrideRequest function handles a + * request to override the alarm audio (low gain) current. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestAlarmAudioCurrentLgOverrideRequest( 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 = testSetPrimaryAlarmAudioCurrentLGOverride( payload.state.f32 ); + } + else + { + result = testResetPrimaryAlarmAudioCurrentLGOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestAlarmBackupAudioCurrentOverrideRequest function handles a + * request to override the backup alarm audio current. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestAlarmBackupAudioCurrentOverrideRequest( 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 = testSetBackupAlarmAudioCurrentOverride( payload.state.f32 ); + } + else + { + result = testResetBackupAlarmAudioCurrentOverride(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestSyringePumpStatusOverrideRequest function handles a + * request to override the syringe pump status. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestSyringePumpStatusOverrideRequest( 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 = testSetSyringePumpStatus( payload.state.u32 ); + } + else + { + result = testResetSyringePumpStatus(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestSyringePumpEncoderStatusOverrideRequest function handles a + * request to override the syringe pump encoder status. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestSyringePumpEncoderStatusOverrideRequest( 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 = testSetSyringePumpEncoderStatus( payload.state.u32 ); + } + else + { + result = testResetSyringePumpEncoderStatus(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestSyringePumpADCandDACStatusOverrideRequest function handles a + * request to override the syringe pump ADC & DAC status. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestSyringePumpADCandDACStatusOverrideRequest( 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 = testSetSyringePumpADCandDACStatus( payload.state.u32 ); + } + else + { + result = testResetSyringePumpADCandDACStatus(); + } + } + + // Respond to request + sendTestAckResponseMsg( (MSG_ID_T)message->hdr.msgID, result ); +} + +/*********************************************************************//** + * @brief + * The handleTestSyringePumpADCReadCtrOverrideRequest function handles a + * request to override the syringe pump ADC read counter. + * @details Inputs: none + * @details Outputs: message handled + * @param message : a pointer to the message to handle + * @return none + *************************************************************************/ +void handleTestSyringePumpADCReadCtrOverrideRequest( 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 = testSetSyringePumpADCReadCounter( payload.state.u32 ); + } + else + { + result = testResetSyringePumpADCReadCounter(); + } + } +} + +/*********************************************************************//** + * @brief * The handleTestValvesPositionCountOverrideRequest function handles a * request to override HD valves' position in counts. * @details Inputs: none Index: firmware/App/Services/SystemCommMessages.h =================================================================== diff -u -ra97fcffbe7b7b2d9543358ac06868829d41cf173 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/App/Services/SystemCommMessages.h (.../SystemCommMessages.h) (revision a97fcffbe7b7b2d9543358ac06868829d41cf173) +++ firmware/App/Services/SystemCommMessages.h (.../SystemCommMessages.h) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -38,6 +38,7 @@ #include "Rinseback.h" #include "SyringePump.h" #include "Valves.h" +#include "Voltages.h" /** * @defgroup SystemCommMessages SystemCommMessages @@ -173,6 +174,12 @@ // MSG_ID_HD_HEPARIN_PAUSE_RESUME_RESPONSE BOOL sendHeparinCommandResponse( U32 accepted, U32 rejReason ); +// MSG_ID_UI_SET_ALARM_AUDIO_VOLUME_LEVEL_CMD +void handleAlarmAudioVolumeSetCmd( MESSAGE_T *message ); + +// MSG_ID_HD_ALARM_AUDIO_VOLUME_SET_RESPONSE +BOOL sendAlarmAudioVolumeSetResponse( U32 accepted, U32 rejReason ); + // MSG_ID_UI_SAMPLE_WATER_CMD void handleSampleWaterCmd( MESSAGE_T *message ); @@ -283,7 +290,10 @@ BOOL broadcastAccelData( F32 x, F32 y, F32 z, F32 xm, F32 ym, F32 zm, F32 xt, F32 yt, F32 zt ); // MSG_ID_ALARM_STATUS -BOOL broadcastAlarmStatus( COMP_ALARM_STATUS_T almStatus ); +BOOL broadcastAlarmStatus( COMP_ALARM_STATUS_T almStatus ); + +// MSG_ID_HD_ALARM_INFORMATION +BOOL broadcastAlarmInfo( ALARM_INFO_PAYLOAD_T data ); // MSG_ID_ALARM_TRIGGERED BOOL broadcastAlarmTriggered( U32 alarm, ALARM_DATA_T almData1, ALARM_DATA_T almData2 ); @@ -314,6 +324,9 @@ // MSG_ID_PRESSURE_OCCLUSION_DATA BOOL broadcastPresOcclData( PRESSURE_OCCLUSION_DATA_T data ); + +// MSG_ID_HD_VOLTAGES_DATA +BOOL broadcastVoltagesData( VOLTAGES_DATA_PAYLOAD_T data ); // MSG_ID_RTC_EPOCH BOOL broadcastRTCEpoch( U32 epoch ); @@ -546,9 +559,6 @@ void handleSetHDValvePWMOverrideRequest( MESSAGE_T *message ); #endif -// MSG_ID_HD_SET_PARAMETER_TREATMENT_PARAMETER -void handleTestSetTreatmentParameter( MESSAGE_T *message ); - // MSG_ID_HD_SOFTWARE_RESET_REQUEST void handleHDSoftwareResetRequest( MESSAGE_T *message ); @@ -633,6 +643,39 @@ // MSG_ID_HD_SYRINGE_PUMP_MEASURED_VOLUME_OVERRIDE: void handleTestSyringePumpMeasuredVolumeOverrideRequest( MESSAGE_T *message ); +// MSG_ID_HD_MONITORED_VOLTAGES_SEND_INTERVAL_OVERRIDE +void handleTestMonitoredVoltagesSendIntervalOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_MONITORED_VOLTAGES_OVERRIDE +void handleTestMonitoredVoltageOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_ALARM_INFO_SEND_INTERVAL_OVERRIDE +void handleTestAlarmInfoSendIntervalOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_ALARM_AUDIO_VOLUME_LEVEL_OVERRIDE +void handleTestAlarmAudioVolumeOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_ALARM_AUDIO_CURRENT_HG_OVERRIDE +void handleTestAlarmAudioCurrentHgOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_ALARM_AUDIO_CURRENT_LG_OVERRIDE +void handleTestAlarmAudioCurrentLgOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_ALARM_BACKUP_AUDIO_CURRENT_OVERRIDE +void handleTestAlarmBackupAudioCurrentOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_SYRINGE_PUMP_STATUS_OVERRIDE +void handleTestSyringePumpStatusOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_SYRINGE_PUMP_ENCODER_STATUS_OVERRIDE +void handleTestSyringePumpEncoderStatusOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_SYRINGE_PUMP_ADC_DAC_STATUS_OVERRIDE +void handleTestSyringePumpADCandDACStatusOverrideRequest( MESSAGE_T *message ); + +// MSG_ID_HD_SYRINGE_PUMP_ADC_READ_COUNTER_OVERRIDE +void handleTestSyringePumpADCReadCtrOverrideRequest( MESSAGE_T *message ); + // MSG_ID_HD_VALVES_CURRENT_OVERRIDE void handleTestValvesCurrentOverrideRequest( MESSAGE_T *message ); Index: firmware/source/sys_main.c =================================================================== diff -u -r9f2e4e5933d2e418b75f91e3db5df69c71878d43 -r1467e388082a0d4c9e4b7e03b689a70ba42862db --- firmware/source/sys_main.c (.../sys_main.c) (revision 9f2e4e5933d2e418b75f91e3db5df69c71878d43) +++ firmware/source/sys_main.c (.../sys_main.c) (revision 1467e388082a0d4c9e4b7e03b689a70ba42862db) @@ -68,6 +68,7 @@ #include "AlarmLamp.h" #include "Battery.h" #include "BloodFlow.h" +#include "BloodLeak.h" #include "Buttons.h" #include "CommBuffers.h" #include "CPLD.h" @@ -187,7 +188,9 @@ initWatchdogMgmt(); // Initialize monitors initAccel(); + initBloodLeak(); initButtons(); + initFluidLeak(); initPresOccl(); initVoltagesMonitor(); // Initialize controllers @@ -198,7 +201,6 @@ initDialOutFlow(); initSyringePump(); initValves(); - initFluidLeak(); // Initialize modes initOperationModes(); // Initialize async interrupt handlers