Index: firmware/App/Controllers/DialInFlow.c =================================================================== diff -u -r5a03bc5bd579bf84301d26d7b062c3cadd2068c5 -r60648d9085c200d4bb707341f9ee14dbbc5d4c4e --- firmware/App/Controllers/DialInFlow.c (.../DialInFlow.c) (revision 5a03bc5bd579bf84301d26d7b062c3cadd2068c5) +++ firmware/App/Controllers/DialInFlow.c (.../DialInFlow.c) (revision 60648d9085c200d4bb707341f9ee14dbbc5d4c4e) @@ -73,6 +73,7 @@ /// Persist time (task intervals) for flow vs. motor speed error condition. static const U32 DIP_FLOW_VS_SPEED_PERSIST = ((5 * MS_PER_SECOND) / TASK_PRIORITY_INTERVAL); +//static const U32 DIP_FLOW_VS_SPEED_PERSIST = ((60 * MS_PER_SECOND) / TASK_PRIORITY_INTERVAL); //DN-03NOV2022 - Make it 1 minutes for testing /// Persist time (task intervals) for motor off error condition. static const U32 DIP_OFF_ERROR_PERSIST = ((5 * MS_PER_SECOND) / TASK_PRIORITY_INTERVAL); /// Persist time (task intervals) motor speed error condition. Index: firmware/App/Drivers/Battery.c =================================================================== diff -u -rb71aca78afda3d5a827530a767935eb4a7de976a -r60648d9085c200d4bb707341f9ee14dbbc5d4c4e --- firmware/App/Drivers/Battery.c (.../Battery.c) (revision b71aca78afda3d5a827530a767935eb4a7de976a) +++ firmware/App/Drivers/Battery.c (.../Battery.c) (revision 60648d9085c200d4bb707341f9ee14dbbc5d4c4e) @@ -8,7 +8,7 @@ * @file Battery.c * * @author (last) Dara Navaei -* @date (last) 22-Sep-2022 +* @date (last) 18-Oct-2022 * * @author (original) Quang Nguyen * @date (original) 24-Feb-2021 @@ -20,8 +20,8 @@ #include "Battery.h" #include "PersistentAlarm.h" #include "SystemCommMessages.h" -#include "Timers.h" - +#include "Timers.h" + /** * @addtogroup Battery * @{ @@ -35,132 +35,167 @@ #define BATTERY_CHARGER_STATUS_CMD 0x13 ///< Command to get battery charger status. #define BATTERY_CHARGER_STATUS_AC_PRESENT_MASK 0x8000 ///< Battery charger status AC present bit mask. -#define BATTERY_PACK_REL_STATE_OF_CHARGE_CMD 0x0D ///< Command to get battery pack relative state of charge. -#define BATTERY_PACK_REM_CAPACITY_CMD 0x0F ///< Command to get battery pack remaining capacity (in mAh). -#define BATTERY_PACK_STATUS_CMD 0x16 ///< Command to get battery pack status. - #define BATTERY_PACK_ERROR_BITS 0x0F ///< Error codes are in the first byte. #define BATTERY_PACK_MIN_CHARGE_PCT 50 ///< Minimum battery pack state of charge in percentage. -#define BATTERY_COMM_TIME_OUT_MS 1 ///< Battery communication time out in ms. -#define BATTERY_MONITOR_INTERVAL_MS 750 ///< Battery monitor interval in ms. +#define BATTERY_COMM_TIME_OUT_MS 2 ///< Battery communication time out in ms. +#define BATTERY_MONITOR_INTERVAL_MS 247 ///< Battery monitor interval in ms. #define AC_POWER_LOST_PERSISTENT_COUNT 3 ///< AC power lost persistent count before alarming. #define BATTERY_COMM_FAULT_PERSISTENTCE_COUNT 5 ///< Battery communication fault persistent count before alarming. #define BATTERY_MAH_2_MWH_FACTOR 14.7F ///< Conversion factor for mAh to mWh. #define BATTERY_MIN_CAPACITY_MWH 5000.0F ///< Minimum battery capacity for starting a treatment is 10 minutes (5 Wh @ 30W). - + +// Battery logging +#define BATTERY_PACK_ADDR_REMAINING_CAPACITY_ALARM 0x01 ///< Battery pack address remaining capacity alarm. +#define BATTERY_PACK_ADDR_REMAINING_TIME_ALARM 0x02 ///< Battery pack address remaining time alarm. +#define BATTERY_PACK_ADDR_BATTERY_MODE 0x03 ///< Battery pack address battery mode. +#define BATTERY_PACK_ADDR_AT_RATE 0x04 ///< Battery pack address at rate. +#define BATTERY_PACK_ADDR_AT_RATE_TIME_TO_FULL 0x05 ///< Battery pack address at rate time to full. +#define BATTERY_PACK_ADDR_AT_RATE_TIME_TO_EMPTY 0x06 ///< Battery pack address at rate time to empty. +#define BATTERY_PACK_ADDR_AT_RATE_OK 0x07 ///< Battery pack address at rate ok. +#define BATTERY_PACK_ADDR_TEMPERATURE 0x08 ///< Battery pack address temperature. +#define BATTERY_PACK_ADDR_VOLTAGE 0x09 ///< Battery pack address voltage. +#define BATTERY_PACK_ADDR_CURRENT 0x0a ///< Battery pack address current. +#define BATTERY_PACK_ADDR_AVERAGE_CURRENT 0x0b ///< Battery pack address average current. +#define BATTERY_PACK_ADDR_MAX_ERROR 0x0c ///< Battery pack address max error. +#define BATTERY_PACK_ADDR_RELATIVE_STATE_OF_CHARGE 0x0d ///< Battery pack address relative state of charge. +#define BATTERY_PACK_ADDR_ABSOLUTE_STATE_OF_CHARGE 0x0e ///< Battery pack address absolute state of charge. +#define BATTERY_PACK_ADDR_REMAINING_CAPACITY 0x0f ///< Battery pack address remaining capacity. +#define BATTERY_PACK_ADDR_FULL_CHARGE_CAPACITY 0x10 ///< Battery pack address full charge capacity. +#define BATTERY_PACK_ADDR_RUN_TIME_TO_EMPTY 0x11 ///< Battery pack address run time to empty. +#define BATTERY_PACK_ADDR_AVERAGE_TIME_TO_EMPTY 0x12 ///< Battery pack address average time to empty. +#define BATTERY_PACK_ADDR_AVERAGE_TIME_TO_FULL 0x13 ///< Battery pack address average time full. +#define BATTERY_PACK_ADDR_CHARGING_CURRENT 0x14 ///< Battery pack address charging current. +#define BATTERY_PACK_ADDR_CHARGING_VOLTAGE 0x15 ///< Battery pack address charging voltage. +#define BATTERY_PACK_ADDR_BATTERY_STATUS 0x16 ///< Battery pack address battery status. +#define BATTERY_PACK_ADDR_CYCLE_COUNT 0x17 ///< Battery pack address cycle count. +#define BATTERY_PACK_ADDR_DESIGN_CAPACITY 0x18 ///< Battery pack address design capacity. +#define BATTERY_PACK_ADDR_DESIGN_VOLTAGE 0x19 ///< Battery pack address design voltage. +#define BATTERY_PACK_ADDR_SPECIFICATION_INFO 0x1a ///< Battery pack address specification information. +#define BATTERY_PACK_ADDR_MANUFACTURE_DATE 0x1b ///< Battery pack address manufacture date. +#define BATTERY_PACK_ADDR_SERIAL_NUMBER 0x1c ///< Battery pack address serial number. +#define BATTERY_PACK_ADDR_MANUFACTURER_NAME 0x20 ///< Battery pack address manufacture name. +#define BATTERY_PACK_ADDR_DEVICE_NAME 0x21 ///< Battery pack address device name. +#define BATTERY_PACK_ADDR_DEVICE_CHEMISTRY 0x22 ///< Battery pack address device chemistry. + /// Persist time (in ms) for battery pack status error condition. static const U32 BATT_STATUS_ERROR_PERSIST_MS = ( 5 * MS_PER_SECOND ); +/// Enumeration of battery data to be read from the battery pack or battery charger in a round-robin fashion. +typedef enum BatteryManagementEnum +{ + BEGINNING_OF_LIST = 0, ///< Start of battery data list + BATTERY_PACK_REMAINING_CAPACITY1, ///< Remaining battery capacity (in mWh) (first of 5 to increase frequency of reads) + BATTERY_PACK_BATTERY_STATUS1, ///< Battery pack status (first of 5 to increase frequency of reads) + BATTERY_CHARGER_STATUS1, ///< Battery charger status (first of 5 to increase frequency of reads) + BATTERY_PACK_REMAINING_CAPACITY_ALARM, ///< Remaining battery capacity alarm + BATTERY_PACK_REMAINING_TIME_ALARM, ///< Remaining battery time alarm + BATTERY_PACK_BATTERY_MODE, ///< Battery pack mode + BATTERY_PACK_AT_RATE, ///< Battery pack at rate + BATTERY_PACK_AT_RATE_TIME_TO_FULL, ///< Battery pack at rate time to full + BATTERY_PACK_REMAINING_CAPACITY2, ///< Remaining battery capacity (in mWh) (second of 5 to increase frequency of reads) + BATTERY_PACK_BATTERY_STATUS2, ///< Battery pack status (second of 5 to increase frequency of reads) + BATTERY_CHARGER_STATUS2, ///< Battery charger status (second of 5 to increase frequency of reads) + BATTERY_PACK_AT_RATE_TIME_TO_EMPTY, ///< Battery pack at rate time to empty + BATTERY_PACK_AT_RATE_OK, ///< Battery pack at rate ok (boolean) + BATTERY_PACK_TEMPERATURE, ///< Battery pack temperature (in deg K) + BATTERY_PACK_VOLTAGE, ///< Battery pack terminal voltage (in mV) + BATTERY_PACK_CURRENT, ///< Battery pack terminal current (in mA) + BATTERY_PACK_AVERAGE_CURRENT, ///< Battery pack average terminal current (in mA - 1 minute rolling avg) + BATTERY_PACK_REMAINING_CAPACITY3, ///< Remaining battery capacity (in mWh) (third of 5 to increase frequency of reads) + BATTERY_PACK_BATTERY_STATUS3, ///< Battery pack status (third of 5 to increase frequency of reads) + BATTERY_CHARGER_STATUS3, ///< Battery charger status (third of 5 to increase frequency of reads) + BATTERY_PACK_MAX_ERROR, ///< Battery pack expected margin of error (%) in the state of charge calculation + BATTERY_PACK_RELATIVE_STATE_OF_CHARGE, ///< Battery pack relative state of charge (%) (relative to full charge capacity) + BATTERY_PACK_ABSOLUTE_STATE_OF_CHARGE, ///< Battery pack absolute state of charge (%) (relative to design capacity) + BATTERY_PACK_FULL_CHARGE_CAPACITY, ///< Battery pack full charge capacity (in mWh) + BATTERY_PACK_RUN_TIME_TO_EMPTY, ///< Battery pack run time (in minutes) predicted based on present rate of discharge + BATTERY_PACK_AVERAGE_TIME_TO_EMPTY, ///< Battery pack average time to empty (in minutes - 1 minute rolling avg) + BATTERY_PACK_AVERAGE_TIME_TO_FULL, ///< Battery pack average time to full (in minutes - 1 minute rolling avg) + BATTERY_PACK_REMAINING_CAPACITY4, ///< Remaining battery capacity (in mWh) (fourth of 5 to increase frequency of reads) + BATTERY_PACK_BATTERY_STATUS4, ///< Battery pack status (fourth of 5 to increase frequency of reads) + BATTERY_CHARGER_STATUS4, ///< Battery charger status (fourth of 5 to increase frequency of reads) + BATTERY_PACK_CHARGING_CURRENT, ///< Battery pack desired charging current (in mA) + BATTERY_PACK_CHARGING_VOLTAGE, ///< Battery pack desired charging voltage (in mV) + BATTERY_PACK_CYCLE_COUNT, ///< Battery pack cycle count + BATTERY_PACK_DESIGN_CAPACITY, ///< Battery pack design capacity (in mWh) + BATTERY_PACK_DESIGN_VOLTAGE, ///< Battery pack design voltage (in mV) + BATTERY_PACK_SPECIFICATION_INFO, ///< Version number of the smart battery specification the battery pack supports + BATTERY_PACK_MANUFACTURE_DATE, ///< Battery pack mfg date ( [year - 1980] x 512 + month x 32 + day + BATTERY_PACK_REMAINING_CAPACITY5, ///< Remaining battery capacity (in mWh) (fifth of 5 to increase frequency of reads) + BATTERY_PACK_BATTERY_STATUS5, ///< Battery pack status (fifth of 5 to increase frequency of reads) + BATTERY_CHARGER_STATUS5, ///< Battery charger status (fifth of 5 to increase frequency of reads) + BATTERY_PACK_SERIAL_NUMBER, ///< Battery pack serial number + BATTERY_PACK_MANUFACTURER_NAME, ///< Battery pack mfg name + BATTERY_PACK_DEVICE_NAME, ///< Battery pack device name + BATTERY_PACK_DEVICE_CHEMISTRY, ///< Battery pack device chemistry + END_OF_LIST +} BATTERY_MANAGEMENT_ENUM_T; + // ********** private data ********** -static U16 batteryStatus = 0; ///< Battery current status. -static U32 batteryRelStateOfCharge_pct; ///< Battery pack relative state of charge. static OVERRIDE_F32_T batteryRemCapacity_mAh = { 0.0, 0.0, 0.0, 0 }; ///< Battery pack remaining capacity (in mAh). -static U16 batteryPackStatus = 0; ///< Battery pack current status. -static U32 lastBatteryMonitorTime = 0; ///< Previous battery monitor time. -static U32 lostACPowerPersistentCount = 0; ///< Persistent count for AC power lost alarm. -static BOOL hasBatteryChargerStatus = FALSE; ///< Flag indicates if battery charger status has been obtained. -static U32 commFaultPersistentCount = 0; ///< Persistence count for battery comm fault. +static U32 lastBatteryMonitorTime; ///< Previous battery monitor time. +static U32 commFaultPersistentCount; ///< Persistence count for battery comm fault. -// ********** private function prototypes ********** +static BATTERY_MANAGEMENT_ENUM_T current_BM_value; ///< Index for which battery data to read now. +static BATTERY_MANAGER_PAYLOAD_T BatteryManagerData; ///< Record with latest battery pack data updated at the slower frequency. +static BATTERY_STATUS_PAYLOAD_T BatteryStatusData; ///< Record with latest battery pack/charger status data updated at the faster frequency. +// ********** private function prototypes ********** + static F32 getBatteryRemainingCapacity_mWh( void ); static void setupI2CDriver( void ); static BOOL waitForTxReady( void ); static BOOL waitForRxReady( void ); static BOOL waitForAccessReady( void ); static void generateStopCondition( void ); -static BOOL getBatteryData( U32 slaveAddr, U08 command, U16 * dataPtr ); +static BOOL getBatteryData( U32 slaveAddr, U08 command, U32 * dataPtr ); static BOOL startCommTx( U32 slaveAddr ); static BOOL getData( U08 command, U16 * dataPtr ); - -/*********************************************************************//** - * @brief - * The initBattery function initializes the Battery module. - * @details Inputs: none - * @details Outputs: Battery module is initialized. - * @return none - *************************************************************************/ -void initBattery( void ) + +// For logging +static void getBatteryManagementData( void ); +static void publishBatteryManagementData( void ); +static void publishBatteryStatusData( void ); + +/*********************************************************************//** + * @brief + * The initBattery function initializes the Battery module. + * @details Inputs: none + * @details Outputs: Battery module is initialized. + * @return none + *************************************************************************/ +void initBattery( void ) { - batteryStatus = 0; - batteryRelStateOfCharge_pct = 0; - batteryPackStatus = 0; - lastBatteryMonitorTime = 0; - lostACPowerPersistentCount = 0; - hasBatteryChargerStatus = FALSE; + lastBatteryMonitorTime = 0; commFaultPersistentCount = 0; + current_BM_value = BEGINNING_OF_LIST; + memset( &BatteryStatusData, 0, sizeof( BATTERY_STATUS_PAYLOAD_T ) ); + memset( &BatteryManagerData, 0, sizeof( BATTERY_MANAGER_PAYLOAD_T ) ); + // Initialize persistent alarm for battery pack status error initPersistentAlarm( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, 0, BATT_STATUS_ERROR_PERSIST_MS ); setupI2CDriver(); -} - -/*********************************************************************//** - * @brief - * The execBatteryMonitor function monitors the battery status. - * @details Inputs: lastBatteryMonitorTime, hasBatteryChargerStatus, batteryStatus, - * batteryRelStateOfCharge_pct, batteryPackStatus, lostACPowerPersistentCount - * @details Outputs: lastBatteryMonitorTime, hasBatteryChargerStatus, - * lostACPowerPersistentCount, batteryRelStateOfCharge_pct, batteryRemCapacity_mAh - * @return none +} + +/*********************************************************************//** + * @brief + * The execBatteryMonitor function monitors the battery status. + * @details Inputs: lastBatteryMonitorTime + * @details Outputs: lastBatteryMonitorTime + * @return none *************************************************************************/ -void execBatteryMonitor( void ) +void execBatteryMonitor( void ) { - U16 relStateOfCharge_pct; - U16 remCapacity_mAh; - if ( TRUE == didTimeout( lastBatteryMonitorTime, BATTERY_MONITOR_INTERVAL_MS ) ) { lastBatteryMonitorTime = getMSTimerCount(); - if ( FALSE == hasBatteryChargerStatus ) - { - hasBatteryChargerStatus = TRUE; - - if ( TRUE == getBatteryData( BATTERY_CHARGER_SLAVE_ADDRESS, BATTERY_CHARGER_STATUS_CMD, &batteryStatus ) ) - { - if ( 0 == ( batteryStatus & BATTERY_CHARGER_STATUS_AC_PRESENT_MASK ) ) - { - if ( ++lostACPowerPersistentCount > AC_POWER_LOST_PERSISTENT_COUNT ) - { -#ifndef DISABLE_BATT_COMM - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_AC_POWER_LOST, batteryStatus ); -#endif - } - } - else - { - clearAlarmCondition( ALARM_ID_HD_AC_POWER_LOST ); - lostACPowerPersistentCount = 0; - } - } - } - else - { - hasBatteryChargerStatus = FALSE; - - if ( TRUE == getBatteryData( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_REL_STATE_OF_CHARGE_CMD, &relStateOfCharge_pct ) ) - { - batteryRelStateOfCharge_pct = (U32)relStateOfCharge_pct; - } - - if ( TRUE == getBatteryData( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_REM_CAPACITY_CMD, &remCapacity_mAh ) ) - { - batteryRemCapacity_mAh.data = (F32)remCapacity_mAh * BATTERY_MAH_2_MWH_FACTOR; - } - - if ( TRUE == getBatteryData( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_STATUS_CMD, &batteryPackStatus ) ) - { - if ( ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, ( batteryPackStatus & BATTERY_PACK_ERROR_BITS ) != 0 ) ) ) - { - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, batteryPackStatus ); - } - } - } + getBatteryManagementData(); } } @@ -304,14 +339,17 @@ * @param dataPtr data pointer to store command response data * @return none *************************************************************************/ -static BOOL getBatteryData( U32 slaveAddr, U08 command, U16 * dataPtr ) +static BOOL getBatteryData( U32 slaveAddr, U08 command, U32 * dataPtr ) { BOOL result = FALSE; if ( TRUE == startCommTx( slaveAddr ) ) { - if ( TRUE == getData( command, dataPtr ) ) + U16 data = (U16)( (*dataPtr) & MASK_OFF_MSW ); + + if ( TRUE == getData( command, &data ) ) { + *dataPtr = data; result = TRUE; } } @@ -408,10 +446,245 @@ } } + if ( FALSE == result ) + { + if ( ++commFaultPersistentCount > BATTERY_COMM_FAULT_PERSISTENTCE_COUNT ) + { +#ifndef DISABLE_BATT_COMM + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BATTERY_COMM_FAULT, dataPtr ); +#endif + commFaultPersistentCount = 0; + } + } + return result; } +/*********************************************************************//** + * @brief + * The getBatteryManagementData function accumulates the battery management + * and status data and publishes the two sets of values when complete. Also, + * the battery remaining capacity is stored, the battery status alarm is set + * if necessary, and the loss of AC power alarm is set if necessary. + * @details Inputs: current_BM_value, BatteryStatusData + * @details Outputs: batteryRemCapacity_mAh, BatteryManagerData + * @return none + *************************************************************************/ +static void getBatteryManagementData(void) +{ + HD_OP_MODE_T opMode = getCurrentOperationMode(); + // Increment the position in the enum. Starting value is BEGINNING_OF_LIST (0), so on the first + // cycle through this function it will be set to the first valid position (1) + current_BM_value += 1; + + switch( current_BM_value ) + { + case BATTERY_PACK_REMAINING_CAPACITY1: + case BATTERY_PACK_REMAINING_CAPACITY2: + case BATTERY_PACK_REMAINING_CAPACITY3: + case BATTERY_PACK_REMAINING_CAPACITY4: + case BATTERY_PACK_REMAINING_CAPACITY5: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_REMAINING_CAPACITY, &BatteryStatusData.RemainingCapacity ); + batteryRemCapacity_mAh.data = (F32)BatteryStatusData.RemainingCapacity * BATTERY_MAH_2_MWH_FACTOR; + break; + + case BATTERY_PACK_BATTERY_STATUS1: + case BATTERY_PACK_BATTERY_STATUS2: + case BATTERY_PACK_BATTERY_STATUS3: + case BATTERY_PACK_BATTERY_STATUS4: + case BATTERY_PACK_BATTERY_STATUS5: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_BATTERY_STATUS, &BatteryStatusData.BatteryStatus ); + if ( ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, ( BatteryStatusData.BatteryStatus & BATTERY_PACK_ERROR_BITS ) != 0 ) ) ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, BatteryStatusData.BatteryStatus ); + } + break; + + case BATTERY_PACK_REMAINING_CAPACITY_ALARM: + getBatteryData( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_REMAINING_CAPACITY_ALARM, &BatteryManagerData.RemainingCapacityAlarm ); + break; + + case BATTERY_PACK_REMAINING_TIME_ALARM: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_REMAINING_TIME_ALARM, &BatteryManagerData.RemainingTimeAlarm ); + break; + + case BATTERY_PACK_BATTERY_MODE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_BATTERY_MODE, &BatteryManagerData.BatteryMode ); + break; + + case BATTERY_PACK_AT_RATE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AT_RATE, &BatteryManagerData.AtRate ); + break; + + case BATTERY_PACK_AT_RATE_TIME_TO_FULL: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AT_RATE_TIME_TO_FULL, &BatteryManagerData.AtRateTimeToFull ); + break; + + case BATTERY_PACK_AT_RATE_TIME_TO_EMPTY: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AT_RATE_TIME_TO_EMPTY, &BatteryManagerData.AtRateTimeToEmpty ); + break; + + case BATTERY_PACK_AT_RATE_OK: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AT_RATE_OK, &BatteryManagerData.AtRateOK ); + break; + + case BATTERY_PACK_TEMPERATURE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_TEMPERATURE, &BatteryManagerData.Temperature ); + break; + + case BATTERY_PACK_VOLTAGE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_VOLTAGE, &BatteryManagerData.Voltage ); + break; + + case BATTERY_PACK_CURRENT: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_CURRENT, &BatteryManagerData.Current ); + break; + + case BATTERY_PACK_AVERAGE_CURRENT: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AVERAGE_CURRENT, &BatteryManagerData.AverageCurrent ); + break; + + case BATTERY_PACK_MAX_ERROR: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_MAX_ERROR, &BatteryManagerData.MaxError ); + break; + + case BATTERY_PACK_RELATIVE_STATE_OF_CHARGE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_RELATIVE_STATE_OF_CHARGE, &BatteryManagerData.RelativeStateOfCharge ); + break; + + case BATTERY_PACK_ABSOLUTE_STATE_OF_CHARGE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_ABSOLUTE_STATE_OF_CHARGE, &BatteryManagerData.AbsoluteStateOfCharge ); + break; + + case BATTERY_PACK_FULL_CHARGE_CAPACITY: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_FULL_CHARGE_CAPACITY, &BatteryManagerData.FullChargeCapacity ); + break; + + case BATTERY_PACK_RUN_TIME_TO_EMPTY: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_RUN_TIME_TO_EMPTY, &BatteryManagerData.RunTimeToEmpty ); + break; + + case BATTERY_PACK_AVERAGE_TIME_TO_EMPTY: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AVERAGE_TIME_TO_EMPTY, &BatteryManagerData.AverageTimeToEmpty ); + break; + + case BATTERY_PACK_AVERAGE_TIME_TO_FULL: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_AVERAGE_TIME_TO_FULL, &BatteryManagerData.AverageTimeToFull ); + break; + + case BATTERY_PACK_CHARGING_CURRENT: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_CHARGING_CURRENT, &BatteryManagerData.ChargingCurrent ); + break; + + case BATTERY_PACK_CHARGING_VOLTAGE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_CHARGING_VOLTAGE, &BatteryManagerData.ChargingVoltage ); + break; + + case BATTERY_PACK_CYCLE_COUNT: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_CYCLE_COUNT, &BatteryManagerData.CycleCount ); + break; + + case BATTERY_PACK_DESIGN_CAPACITY: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_DESIGN_CAPACITY, &BatteryManagerData.DesignCapacity ); + break; + + case BATTERY_PACK_DESIGN_VOLTAGE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_DESIGN_VOLTAGE, &BatteryManagerData.DesignVoltage ); + break; + + case BATTERY_PACK_SPECIFICATION_INFO: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_SPECIFICATION_INFO, &BatteryManagerData.SpecificationInfo ); + break; + + case BATTERY_PACK_MANUFACTURE_DATE: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_MANUFACTURE_DATE, &BatteryManagerData.ManufactureDate ); + break; + + case BATTERY_PACK_SERIAL_NUMBER: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_SERIAL_NUMBER, &BatteryManagerData.SerialNumber ); + break; + + case BATTERY_PACK_MANUFACTURER_NAME: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_MANUFACTURER_NAME, &BatteryManagerData.ManufacturerName ); + break; + + case BATTERY_PACK_DEVICE_NAME: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_DEVICE_NAME, &BatteryManagerData.DeviceName ); + break; + + case BATTERY_PACK_DEVICE_CHEMISTRY: + getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, BATTERY_PACK_ADDR_DEVICE_CHEMISTRY, &BatteryManagerData.DeviceChemistry ); + break; + + case BATTERY_CHARGER_STATUS1: + case BATTERY_CHARGER_STATUS2: + case BATTERY_CHARGER_STATUS3: + case BATTERY_CHARGER_STATUS4: + case BATTERY_CHARGER_STATUS5: + if ( TRUE == getBatteryData( BATTERY_CHARGER_SLAVE_ADDRESS, BATTERY_CHARGER_STATUS_CMD, &BatteryStatusData.BatteryChargerStatus ) ) + { // If A/C not present, trigger A/C lost alarm + if ( 0 == ( BatteryStatusData.BatteryChargerStatus & BATTERY_CHARGER_STATUS_AC_PRESENT_MASK ) ) + { +#ifndef DISABLE_BATT_COMM + // Pre-Treatment, Treatment, or Post-Treatment mode + if( opMode == MODE_PRET || opMode == MODE_TREA || opMode == MODE_POST ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_AC_POWER_LOST_IN_TREATMENT, BatteryStatusData.BatteryChargerStatus ); + } + // Standby, Service, or Treatment Parameters mode + else + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_AC_POWER_LOST, BatteryStatusData.BatteryChargerStatus ); + } +#endif + } + else + { + clearAlarmCondition( ALARM_ID_HD_AC_POWER_LOST ); + } + } + // Publish battery status data after reading battery charger status (last status read) + publishBatteryStatusData(); + break; + + case END_OF_LIST: + current_BM_value = BEGINNING_OF_LIST; + publishBatteryManagementData(); + break; + + default: + // TODO s/w fault + break; + } +} + +/*********************************************************************//** + * @brief + * The publishBatteryManagementData function publishes the battery management data + * @details Inputs: BatteryManagerData + * @details Outputs: send battery management data + * @return none + *************************************************************************/ +static void publishBatteryManagementData( void ) +{ + broadcastData( MSG_ID_HD_BATTERY_MANAGEMENT_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&BatteryManagerData, sizeof( BATTERY_MANAGER_PAYLOAD_T ) ); +} + +/*********************************************************************//** + * @brief + * The publishBatteryStatusData function publishes the battery status data + * @details Inputs: BatteryStatusData + * @details Outputs: none + * @return none + *************************************************************************/ +static void publishBatteryStatusData( void ) +{ + BatteryStatusData.RemainingCapacity = (U32)getBatteryRemainingCapacity_mWh(); + broadcastData( MSG_ID_HD_BATTERY_STATUS_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&BatteryStatusData, sizeof( BATTERY_STATUS_PAYLOAD_T ) ); +} + + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -426,7 +699,7 @@ * @param value override battery remaining percent * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testSetBatteryRemainingPercentOverride( U32 value ) // TODO - rename to capacity (instead of percent) + messaging + Dialin // TODO - add override of broadcast interval // TODO - broadcast battery data +BOOL testSetBatteryRemainingPercentOverride( F32 value ) // TODO - rename to capacity (instead of percent) + messaging + Dialin // TODO - add override of broadcast interval // TODO - broadcast battery data { BOOL result = FALSE; Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -rb71aca78afda3d5a827530a767935eb4a7de976a -r60648d9085c200d4bb707341f9ee14dbbc5d4c4e --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision b71aca78afda3d5a827530a767935eb4a7de976a) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 60648d9085c200d4bb707341f9ee14dbbc5d4c4e) @@ -8,7 +8,7 @@ * @file ModeStandby.c * * @author (last) Dara Navaei -* @date (last) 22-Sep-2022 +* @date (last) 24-Oct-2022 * * @author (original) Dara Navaei * @date (original) 05-Nov-2019 @@ -30,6 +30,7 @@ #include "ModeTreatment.h" #include "ModeTreatmentParams.h" #include "OperationModes.h" +#include "RTC.h" #include "Switches.h" #include "SyringePump.h" #include "SystemComm.h" @@ -46,7 +47,7 @@ // ********** private definitions ********** #define DISINFECTS_DATA_PUB_INTERVAL ( 1 * MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Disinfects data publish interval in counts. -#define SERVICE_TIME_INTERVAL_MS ( 6 * 30 * SECONDS_IN_A_DAY * MS_PER_SECOND ) ///< HD/DG 6-month service interval in milliseconds. +#define DISINFECTS_TIME_INTERVAL_S ( 2 * SECONDS_IN_A_DAY ) ///< HD/DG 2-day service interval in seconds. // ********** private data ********** @@ -56,14 +57,21 @@ static BOOL flushStartReqReceived; ///< Flag indicates user has requested initiation of flush mode. static BOOL heatDisinfectStartReqReceived; ///< Flag indicates user has requested initiation of heat disinfect mode. static BOOL chemDisinfectStartReqReceived; ///< Flag indicates user has requested initiation of chemical disinfect mode. +static GENERIC_CONFIRM_ID_T disinfectCancelReqID; ///< ID of requested cancel disinfect mode. static DG_DISINFECT_STATE_T dgDisinfectState; ///< DG disinfect state to be boadcast to UI. +static U32 dataPublishCounter; ///< Disinfects data publish counter. +static BOOL homingInitiated; ///< Boolean flag to indicate homing is initiated. -static U32 dataPublishCounter = 0; ///< Disinfects data publish counter. /// Interval (in task intervals) at which to publish standby mode data to CAN bus. static OVERRIDE_U32_T standbyModePublishInterval = { DISINFECTS_DATA_PUB_INTERVAL, DISINFECTS_DATA_PUB_INTERVAL, DISINFECTS_DATA_PUB_INTERVAL, 0 }; +static const U32 SERVICE_TIME_INTERVAL_S = (U32)( 365 * 0.5 * SECONDS_IN_A_DAY ); ///< HD/DG 6-month service interval in seconds. +static BOOL homingInitiated; ///< Flag indicates actuator homing has been initiated from standby mode. + // ********** private function prototypes ********** +static void handleDisinfectCancel( BOOL stop ); + static HD_STANDBY_STATE_T handleStandbyModeStartState( void ); static HD_STANDBY_STATE_T handleStandbyModeWaitForTreatmentState( void ); static HD_STANDBY_STATE_T handleStandbyModeWaitForDisinfectState( void ); @@ -80,6 +88,8 @@ static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectStartState( void ); static HD_STANDBY_STATE_T handleStandbyModeDGChemDisininfectInProgressState( void ); +static BOOL isDGDisinfectValid( void ); +static BOOL haveHDDGServicesBeenExpired( REQUEST_REJECT_REASON_CODE_T* rejReason ); static void publishDisinfectData( void ); /*********************************************************************//** @@ -88,7 +98,7 @@ * @details Inputs: none * @details Outputs: currentStandbyState, treatStartReqReceived, * flushStartReqReceived, dataPublishCounter, heatDisinfectStartReqReceived, - * chemDisinfectStartReqReceived, dgDisinfectState + * chemDisinfectStartReqReceived, dgDisinfectState, homingInitiated * @return none *************************************************************************/ void initStandbyMode( void ) @@ -99,7 +109,10 @@ dataPublishCounter = 0; heatDisinfectStartReqReceived = FALSE; chemDisinfectStartReqReceived = FALSE; + disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; + homingInitiated = FALSE; dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; + homingInitiated = FALSE; } /*********************************************************************//** @@ -145,6 +158,9 @@ { currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; } + // Request DG service record and usage information from DG + sendDGServiceRequestToDG(); + sendDGUsageInfoRequestToDG(); return currentStandbyState; } @@ -160,12 +176,14 @@ { BOOL stop = isStopButtonPressed(); + handleDisinfectCancel( stop ); + #ifndef RUN_WITHOUT_DG // State machine to get DG to prep a reservoir so we can start a treatment switch ( currentStandbyState ) { case STANDBY_START_STATE: - currentStandbyState = handleStandbyModeStartState();; + currentStandbyState = handleStandbyModeStartState(); break; case STANDBY_WAIT_FOR_TREATMENT_STATE: @@ -280,9 +298,22 @@ rejReason = REQUEST_REJECT_REASON_BATTERY_IS_NOT_CHARGED; } +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_SERVICE_AND_DISINFECT_CHECK ) != SW_CONFIG_ENABLE_VALUE ) +#endif + { + // This function checks both HD and DG service records and if any of them has failed, it fills the provided reject reason buffer + haveHDDGServicesBeenExpired( &rejReason ); + + if ( FALSE == isDGDisinfectValid() ) + { + rejReason = REQUEST_REJECT_REASON_DG_DISINFECT_HAS_BEEN_EXPIRED; + } + } + if ( REQUEST_REJECT_REASON_NONE == rejReason ) { - result = TRUE; + result = TRUE; treatStartReqReceived = TRUE; } @@ -470,6 +501,87 @@ /*********************************************************************//** * @brief + * The handleDisinfectCancel function handles + * DG disinfect cancel UI interaction. + * @details Inputs: none + * @details Outputs: none + * @param stop button status + * @return none + *************************************************************************/ +static void handleDisinfectCancel( BOOL stop ) +{ + CONFIRMATION_REQUEST_STATUS_T confirm_status; + GENERIC_CONFIRM_ID_T confirm_id; + + if ( ( STANDBY_DG_FLUSH_IN_PROGRESS_STATE == currentStandbyState ) || + ( STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) || + ( STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) ) + { + if ( ( TRUE == stop ) && ( GENERIC_CONFIRM_ID_NONE == disinfectCancelReqID ) ) + { + if ( STANDBY_DG_FLUSH_IN_PROGRESS_STATE == currentStandbyState ) + { + confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_WATERFLUSH; + } + else if ( STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) + { + confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_HEAT; + } + else if ( STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) + { + confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL; + } + // Send message to UI to indicate user request to cancel disinfect + disinfectCancelReqID = addConfirmationRequest( confirm_id, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); + } + else if ( GENERIC_CONFIRM_ID_NONE != disinfectCancelReqID ) + { + // Get the confirmation request. It consumes the request if completed and responds to UI. + confirm_status = getConfirmationRequestStatus( disinfectCancelReqID ); + switch ( confirm_status ) + { + case CONFIRMATION_REQUEST_STATUS_ACCEPTED : + // Clear request active status + disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; + + switch ( currentStandbyState ) + { + case STANDBY_DG_FLUSH_IN_PROGRESS_STATE: + cmdStopDGFlush(); + break; + + case STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE: + cmdStopDGHeatDisinfect(); + break; + + case STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE: + cmdStopDGChemicalDisinfect(); + break; + + default: + // UI Confirm already closed. Nothing to do. + break; + } + break; + + case CONFIRMATION_REQUEST_STATUS_TIMEOUT : + case CONFIRMATION_REQUEST_STATUS_REJECTED : + // Clear request active status + disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; + break; + + case CONFIRMATION_REQUEST_STATUS_PENDING: + case CONFIRMATION_REQUEST_STATUS_UNUSED: + default : + // Nothing to do + break; + } + } + } +} + +/*********************************************************************//** + * @brief * The handleStandbyModeStartState function handles the standby start state. * This state waits for the door to be closed and then initiates homing of * pumps and valves and transitions to the wait for treatment state. @@ -479,31 +591,33 @@ *************************************************************************/ static HD_STANDBY_STATE_T handleStandbyModeStartState( void ) { - static BOOL homingInitiated = FALSE; HD_STANDBY_STATE_T state = STANDBY_START_STATE; // Wait for door to be closed so we can home actuators - if ( ( homingInitiated != TRUE ) && ( STATE_CLOSED == getSwitchStatus( FRONT_DOOR ) ) ) + if ( STATE_CLOSED == getSwitchStatus( FRONT_DOOR ) ) { - VALVE_T valve; - - // Home pumps and valves - for ( valve = VDI; valve < NUM_OF_VALVES; ++valve ) + // If we haven't already initiated homing of actuators, initiate now + if ( homingInitiated != TRUE ) { - homeValve( valve ); - } - homeBloodPump(); - homeDialInPump(); - homeDialOutPump(); - retractSyringePump(); + VALVE_T valve; - homingInitiated = TRUE; + // Home pumps and valves + for ( valve = VDI; valve < NUM_OF_VALVES; ++valve ) + { + homeValve( valve ); + } + homeBloodPump(); + homeDialInPump(); + homeDialOutPump(); + retractSyringePump(); + + homingInitiated = TRUE; + } } else { // Trigger door open alarm to prompt user to close the door activateAlarmNoData( ALARM_ID_CARTRIDGE_DOOR_OPENED ); - homingInitiated = FALSE; } // If homing has been initiated, wait for syringe pump to home and the verify force sensor calibration @@ -536,7 +650,7 @@ *************************************************************************/ static HD_STANDBY_STATE_T handleStandbyModeWaitForTreatmentState( void ) { - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_TREATMENT_STATE; + HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_TREATMENT_STATE; DG_OP_MODE_T dgOperationMode = getDGOpMode(); // If DG is filling while we are in standby mode, abort the fill @@ -551,17 +665,22 @@ cmdStopDG(); } - // If treatment start is requested by user, initiate treatment workflow (transition to treatment params mode). TODO - check required conditions before allowing treatment start, reject if necessary. + // If treatment start is requested by user, initiate treatment workflow (transition to treatment params mode). if ( TRUE == treatStartReqReceived ) { - // Initialize treatment modes before starting a new treatment - initTreatParamsMode(); - initPreTreatmentMode(); - initTreatmentMode(); - initPostTreatmentMode(); - // Start treatment workflow with treatment parameters mode - requestNewOperationMode( MODE_TPAR ); - treatStartReqReceived = FALSE; + BOOL startTreatment = TRUE; + + if ( TRUE == startTreatment ) + { + // Initialize treatment modes before starting a new treatment + initTreatParamsMode(); + initPreTreatmentMode(); + initTreatmentMode(); + initPostTreatmentMode(); + // Start treatment workflow with treatment parameters mode + requestNewOperationMode( MODE_TPAR ); + treatStartReqReceived = FALSE; + } } return state; @@ -839,6 +958,85 @@ /*********************************************************************//** * @brief + * The isDGDisinfectValid function checks whether the DG disinfects is + * acceptable to start another treatment. + * @details Inputs: none + * @details Outputs: none + * @return TRUE if the disinfect is valid otherwise, FALSE + ***********************************************************************/ +static BOOL isDGDisinfectValid( void ) +{ + DG_SERVICE_AND_USAGE_DATA_T data; + BOOL status = TRUE; + + getHDVersionDGServiceAndUsageData( &data ); + + if ( TRUE == data.isDGUsageInfoAviable ) + { + if ( TRUE == data.dgUsageInfo.isDisinfected ) + { + U32 chemDisElapsedTimeS = getRTCTimestamp() - data.dgUsageInfo.lastChemicalDisDateEpoch; + BOOL hasChemDisBeenExpired = ( chemDisElapsedTimeS > DISINFECTS_TIME_INTERVAL_S ? TRUE : FALSE ); + U32 heatDisElapsedTimeS = getRTCTimestamp() - data.dgUsageInfo.lastHeatDisDateEpoch; + BOOL hasHeatDisBeenExpired = ( heatDisElapsedTimeS > DISINFECTS_TIME_INTERVAL_S ? TRUE : FALSE ); + + if ( ( TRUE == hasChemDisBeenExpired ) && ( TRUE == hasHeatDisBeenExpired ) ) + { + status = FALSE; + } + } + else + { + status = FALSE; + } + } + + return status; +} + +/*********************************************************************//** + * @brief + * The haveHDDGServicesBeenExpired function checks whether the last DG/HD + * service time is still within the interval or not. + * @details Inputs: none + * @details Outputs: none + * @param rejReason pointer to the provided reject reason buffer to be send to UI + * @return TRUE if the service time is still valid otherwise, FALSE + ***********************************************************************/ +static BOOL haveHDDGServicesBeenExpired( REQUEST_REJECT_REASON_CODE_T* rejReason ) +{ + BOOL status = TRUE; + DG_SERVICE_AND_USAGE_DATA_T dgData; + HD_SERVICE_RECORD_T hdServiceRecord; + + getHDVersionDGServiceAndUsageData( &dgData ); + getNVRecord2Driver( GET_SRV_RECORD, (U08*)&hdServiceRecord, sizeof( HD_SERVICE_RECORD_T ), 0, ALARM_ID_NO_ALARM ); + + if ( TRUE == dgData.isDGServiceRecordAvailable ) + { + U32 dgSrvcElapsedTimeS = getRTCTimestamp() - dgData.dgServiceRecord.lastServiceDateEpoch; + BOOL hasDGSrvcBeenExpired = ( dgSrvcElapsedTimeS > SERVICE_TIME_INTERVAL_S ? TRUE : FALSE ); + U32 hdSrvcElapsedTimeS = getRTCTimestamp() - hdServiceRecord.lastServiceEpochDate; + BOOL hasHDSrvcBeenExpied = ( hdSrvcElapsedTimeS > SERVICE_TIME_INTERVAL_S ? TRUE : FALSE ); + + if ( TRUE == hasDGSrvcBeenExpired ) + { + status = FALSE; + *rejReason = REQUEST_REJECT_REASON_DG_SERVICE_IS_DUE; + } + + if ( TRUE == hasHDSrvcBeenExpied ) + { + status = FALSE; + *rejReason = REQUEST_REJECT_REASON_HD_SERVICE_IS_DUE; + } + } + + return status; +} + +/*********************************************************************//** + * @brief * The publishDisinfectData function publishes disinfects data at * the set interval. * @details Inputs: dataPublishCounter