/************************************************************************** * * Copyright (c) 2021-2022 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * * @file Battery.c * * @author (last) Dara Navaei * @date (last) 22-Sep-2022 * * @author (original) Quang Nguyen * @date (original) 24-Feb-2021 * ***************************************************************************/ #include "i2c.h" #include "Battery.h" #include "PersistentAlarm.h" #include "SystemCommMessages.h" #include "Timers.h" /** * @addtogroup Battery * @{ */ // ********** private definitions ********** #define BATTERY_CHARGER_SLAVE_ADDRESS 0x09 ///< Battery charger controller device address. #define BATTERY_PACK_SLAVE_ADDRESS 0x0B ///< Battery pack device address. #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_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 250 ///< 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 ADDR_REMAININGCAPACITYALARM 0x01 // SN - Use "_" between words, add prefix BATTERY_PACK_ to each #define ADDR_REMAININGTIMEALARM 0x02 #define ADDR_BATTERYMODE 0x03 #define ADDR_ATRATE 0x04 #define ADDR_ATRATETIMETOFULL 0x05 #define ADDR_ATRATETIMETOEMPTY 0x06 #define ADDR_ATRATEOK 0x07 #define ADDR_TEMPERATURE 0x08 #define ADDR_VOLTAGE 0x09 #define ADDR_CURRENT 0x0a #define ADDR_AVERAGECURRENT 0x0b #define ADDR_MAXERROR 0x0c #define ADDR_RELATIVESTATEOFCHARGE 0x0d #define ADDR_ABSOLUTESTATEOFCHARGE 0x0e #define ADDR_REMAININGCAPACITY 0x0f #define ADDR_FULLCHARGECAPACITY 0x10 #define ADDR_RUNTIMETOEMPTY 0x11 #define ADDR_AVERAGETIMETOEMPTY 0x12 #define ADDR_AVERAGETIMETOFULL 0x13 #define ADDR_CHARGINGCURRENT 0x14 #define ADDR_CHARGINGVOLTAGE 0x15 #define ADDR_BATTERYSTATUS 0x16 #define ADDR_CYCLECOUNT 0x17 #define ADDR_DESIGNCAPACITY 0x18 #define ADDR_DESIGNVOLTAGE 0x19 #define ADDR_SPECIFICATIONINFO 0x1a #define ADDR_MANUFACTUREDATE 0x1b #define ADDR_SERIALNUMBER 0x1c #define ADDR_MANUFACTURERNAME 0x20 #define ADDR_DEVICENAME 0x21 #define ADDR_DEVICECHEMISTRY 0x22 /// Persist time (in ms) for battery pack status error condition. static const U32 BATT_STATUS_ERROR_PERSIST_MS = ( 5 * MS_PER_SECOND ); // ENUM of battery management values for iterating typedef enum BatteryManagementEnum // SN - Add "_" between words in enums with prefix BATTERY_PACK_ or BATTERY_CHARGER_. { BEGINNING_OF_LIST = 0, REMAININGCAPACITY1 = BEGINNING_OF_LIST, BATTERYSTATUS1, REMAININGCAPACITYALARM, REMAININGTIMEALARM, BATTERYMODE, ATRATE, ATRATETIMETOFULL, REMAININGCAPACITY2, BATTERYSTATUS2, ATRATETIMETOEMPTY, ATRATEOK, TEMPERATURE, VOLTAGE, CURRENT, AVERAGECURRENT, REMAININGCAPACITY3, BATTERYSTATUS3, MAXERROR, RELATIVESTATEOFCHARGE, ABSOLUTESTATEOFCHARGE, FULLCHARGECAPACITY, RUNTIMETOEMPTY, AVERAGETIMETOEMPTY, AVERAGETIMETOFULL, REMAININGCAPACITY4, BATTERYSTATUS4, CHARGINGCURRENT, CHARGINGVOLTAGE, CYCLECOUNT, DESIGNCAPACITY, DESIGNVOLTAGE, SPECIFICATIONINFO, MANUFACTUREDATE, REMAININGCAPACITY5, BATTERYSTATUS5, SERIALNUMBER, MANUFACTURERNAME, DEVICENAME, DEVICECHEMISTRY, BATTERY_CHARGER_STATUS, END_OF_LIST } BATTERY_MANAGEMENT_ENUM_T; // ********** private data ********** static OVERRIDE_F32_T batteryRemCapacity_mAh = { 0.0, 0.0, 0.0, 0 }; ///< Battery pack remaining capacity (in mAh). static U32 lastBatteryMonitorTime = 0; ///< Previous battery monitor time. static U32 lastBatteryGetDataTime = 0; ///< Previous battery data get time. static U32 lostACPowerPersistentCount = 0; ///< Persistent count for AC power lost alarm. static U32 commFaultPersistentCount = 0; ///< Persistence count for battery comm fault. static BATTERY_MANAGEMENT_ENUM_T current_BM_value; static BATTERY_MANAGER_PAYLOAD_T BatteryLoggingData; // ********** 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, U32 * dataPtr ); static BOOL startCommTx( U32 slaveAddr ); static BOOL getData( U08 command, U16 * dataPtr ); // For logging static void getBatteryManagementData( void ); static void publishBatteryManagementData( void ); /*********************************************************************//** * @brief * The initBattery function initializes the Battery module. * @details Inputs: none * @details Outputs: Battery module is initialized. * @return none *************************************************************************/ void initBattery( void ) { lastBatteryMonitorTime = 0; lostACPowerPersistentCount = 0; commFaultPersistentCount = 0; lastBatteryGetDataTime = 0; current_BM_value = BEGINNING_OF_LIST; lastBatteryGetDataTime = getMSTimerCount(); memset( &BatteryLoggingData, 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 *************************************************************************/ void execBatteryMonitor( void ) { if ( TRUE == didTimeout( lastBatteryMonitorTime, BATTERY_MONITOR_INTERVAL_MS ) ) { lastBatteryMonitorTime = getMSTimerCount(); getBatteryManagementData(); } } /*********************************************************************//** * @brief * The isBatteryCharged function checks if the battery is charged. * @details Inputs: batteryRelStateOfCharge_pct * @details Outputs: none * @return TRUE if battery is charged, otherwise FALSE *************************************************************************/ BOOL isBatteryCharged( void ) { return TRUE; // TODO - restore when I2C issue(s) resolved. ( getBatteryRemainingCapacity_mWh() > BATTERY_MIN_CAPACITY_MWH ? TRUE : FALSE ); } /*********************************************************************//** * @brief * The getBatteryRemainingCapacity_mWh function returns the latest battery * remaining capacity (in mWh). * @details Inputs: batteryRemCapacity_mAh * @details Outputs: none * @return battery remaining capacity (in mWh). *************************************************************************/ static F32 getBatteryRemainingCapacity_mWh( void ) { F32 result = batteryRemCapacity_mAh.data; if ( OVERRIDE_KEY == batteryRemCapacity_mAh.override ) { result = batteryRemCapacity_mAh.ovData; } return result; } /*********************************************************************//** * @brief * The setupI2CDriver function setups i2c driver in repeat mode to be * compatible with SMBus protocol. * @details Inputs: none * @details Outputs: setup i2c driver in repeat mode * @return none *************************************************************************/ static void setupI2CDriver( void ) { i2cREG1->MDR = (U32)I2C_RESET_IN; i2cREG1->MDR = (U32)( I2C_MASTER | I2C_TRANSMITTER | I2C_7BIT_AMODE | I2C_REPEATMODE | I2C_8_BIT ); i2cREG1->MDR |= (U32)I2C_RESET_OUT; } /*********************************************************************//** * @brief * The waitForTxReady function checks for transmit ready status from i2c * driver with a timeout. * @details Inputs: none * @details Outputs: checked i2c transmit ready status * @return TRUE if i2c driver ready to transmit data, otherwise FALSE *************************************************************************/ static BOOL waitForTxReady( void ) { U32 const startTime = getMSTimerCount(); BOOL timeout = FALSE; while ( ( 0 == i2cIsTxReady( i2cREG1 ) ) && ( FALSE == timeout ) ) { timeout = didTimeout( startTime, BATTERY_COMM_TIME_OUT_MS ); } return ( TRUE == timeout ? FALSE : TRUE ); } /*********************************************************************//** * @brief * The waitForRxReady function checks for receive ready status from i2c * driver with a timeout. * @details Inputs: none * @details Outputs: checked i2c receive ready status * @return TRUE if i2c driver ready to receive data, otherwise FALSE *************************************************************************/ static BOOL waitForRxReady( void ) { U32 const startTime = getMSTimerCount(); BOOL timeout = FALSE; while ( ( 0 == i2cIsRxReady( i2cREG1 ) ) && ( FALSE == timeout ) ) { timeout = didTimeout( startTime, BATTERY_COMM_TIME_OUT_MS ); } return ( TRUE == timeout ? FALSE : TRUE ); } /*********************************************************************//** * @brief * The waitForAccessReady function checks if i2c registers are ready to be accessed. * @details Inputs: none * @details Outputs: checked i2c registers access ready status * @return TRUE if i2c driver registers are ready to be accessed, otherwise FALSE *************************************************************************/ static BOOL waitForAccessReady( void ) { U32 const startTime = getMSTimerCount(); BOOL timeout = FALSE; while ( ( 0 == ( i2cREG1->STR & (U32)I2C_ARDY ) ) && ( FALSE == timeout ) ) { timeout = didTimeout( startTime, BATTERY_COMM_TIME_OUT_MS ); } return ( TRUE == timeout ? FALSE : TRUE ); } /*********************************************************************//** * @brief * The generateStopCondition function generates a i2c stop condition and * waits until the stop condition is detected or timed out. * @details Inputs: none * @details Outputs: generated i2c stop condition * @return none *************************************************************************/ static void generateStopCondition( void ) { U32 const startTime = getMSTimerCount(); BOOL timeout = FALSE; i2cSetStop( i2cREG1 ); while ( ( 0 == i2cIsStopDetected( i2cREG1 ) ) && ( FALSE == timeout ) ) { timeout = didTimeout( startTime, BATTERY_COMM_TIME_OUT_MS ); } } /*********************************************************************//** * @brief * The getBatteryData function starts i2c communication with battery device * and get data based on given command. * @details Inputs: none * @details Outputs: get data from battery device * @param slaveAddr battery slave device address * @param command command to send to the slave device * @param dataPtr data pointer to store command response data * @return none *************************************************************************/ static BOOL getBatteryData( U32 slaveAddr, U08 command, U32 * dataPtr ) { BOOL result = FALSE; if ( TRUE == startCommTx( slaveAddr ) ) { U16 data = (U16)( *dataPtr & MASK_OFF_MSW ); if ( TRUE == getData( command, &data ) ) { result = TRUE; } } return result; } /*********************************************************************//** * @brief * The startCommTx function starts i2c communication and verifies slave devices ack. * @details Inputs: i2cREG1 * @details Outputs: starts i2c comm in master transmit mode * @param slaveAddr slave device address * @return TRUE if start communication successful, otherwise FALSE *************************************************************************/ static BOOL startCommTx( U32 slaveAddr ) { BOOL result = FALSE; i2cSetSlaveAdd( i2cREG1, slaveAddr ); if ( FALSE == i2cIsBusBusy( i2cREG1 ) ) { i2cSetDirection( i2cREG1, I2C_TRANSMITTER ); i2cSetMode( i2cREG1, I2C_MASTER ); i2cSetStart( i2cREG1 ); if ( TRUE == waitForAccessReady() ) { if ( 0 == ( i2cREG1->STR & ( (U32)I2C_NACK | (U32)I2C_AL ) ) ) { commFaultPersistentCount = 0; result = TRUE; } else { generateStopCondition(); if ( ++commFaultPersistentCount > BATTERY_COMM_FAULT_PERSISTENTCE_COUNT ) { #ifndef DISABLE_BATT_COMM SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BATTERY_COMM_FAULT, slaveAddr ); #endif } } } } if ( FALSE == result ) { // Reset i2c bus if cannot communicate with battery slave devices setupI2CDriver(); } return result; } /*********************************************************************//** * @brief * The getData function send command to battery interface to get data. * @details Inputs: none * @details Outputs: get the battery data based on given command * @param command command to send to the slave device * @param dataPtr data pointer to store command response data * @return TRUE if received battery data, otherwise FALSE *************************************************************************/ static BOOL getData( U08 command, U16 * dataPtr ) { BOOL result = FALSE; U16 batteryData = 0; if ( TRUE == waitForTxReady() ) { i2cSendByte( i2cREG1, command ); } // Wait until command has been transmitted before start receiving command response if ( TRUE == waitForTxReady() ) { i2cSetDirection( i2cREG1, I2C_RECEIVER ); i2cSetStart( i2cREG1 ); if ( TRUE == waitForRxReady() ) { // Due to the double buffer, the master must generate the stop condition after the (message size - 1)th data i2cSetStop( i2cREG1 ); batteryData = i2cReceiveByte( i2cREG1); if ( TRUE == waitForRxReady() ) { batteryData = ( batteryData | ( i2cReceiveByte( i2cREG1) << 8 ) ); *dataPtr = batteryData; result = TRUE; } } } return result; } /*********************************************************************//** * @brief * The getBatteryManagementData function accumulates the battery management data and publishes when complete * @details Inputs: * @details Outputs: * @return none *************************************************************************/ static void getBatteryManagementData(void) { switch( current_BM_value ) { case REMAININGCAPACITY1: case REMAININGCAPACITY2: case REMAININGCAPACITY3: case REMAININGCAPACITY4: case REMAININGCAPACITY5: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_REMAININGCAPACITY, &BatteryLoggingData.RemainingCapacity); batteryRemCapacity_mAh.data = (F32)BatteryLoggingData.RemainingCapacity * BATTERY_MAH_2_MWH_FACTOR; break; case BATTERYSTATUS1: case BATTERYSTATUS2: case BATTERYSTATUS3: case BATTERYSTATUS4: case BATTERYSTATUS5: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_BATTERYSTATUS, &BatteryLoggingData.BatteryStatus); if ( ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, ( BatteryLoggingData.BatteryStatus & BATTERY_PACK_ERROR_BITS ) != 0 ) ) ) { SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BATTERY_PACK_ERROR_DETECTED, BatteryLoggingData.BatteryStatus ); } break; case REMAININGCAPACITYALARM: getBatteryData( BATTERY_PACK_SLAVE_ADDRESS, ADDR_REMAININGCAPACITYALARM, &BatteryLoggingData.RemainingCapacityAlarm ); break; case REMAININGTIMEALARM: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_REMAININGTIMEALARM, &BatteryLoggingData.RemainingTimeAlarm); break; case BATTERYMODE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_BATTERYMODE, &BatteryLoggingData.BatteryMode); break; case ATRATE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_ATRATE, &BatteryLoggingData.AtRate); break; case ATRATETIMETOFULL: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_ATRATETIMETOFULL, &BatteryLoggingData.AtRateTimeToFull); break; case ATRATETIMETOEMPTY: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_ATRATETIMETOEMPTY, &BatteryLoggingData.AtRateTimeToEmpty); break; case ATRATEOK: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_ATRATEOK, &BatteryLoggingData.AtRateOK); break; case TEMPERATURE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_TEMPERATURE, &BatteryLoggingData.Temperature); break; case VOLTAGE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_VOLTAGE, &BatteryLoggingData.Voltage); break; case CURRENT: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_CURRENT, &BatteryLoggingData.Current); break; case AVERAGECURRENT: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_AVERAGECURRENT, &BatteryLoggingData.AverageCurrent); break; case MAXERROR: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_MAXERROR, &BatteryLoggingData.MaxError); break; case RELATIVESTATEOFCHARGE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_RELATIVESTATEOFCHARGE, &BatteryLoggingData.RelativeStateOfCharge); break; case ABSOLUTESTATEOFCHARGE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_ABSOLUTESTATEOFCHARGE, &BatteryLoggingData.AbsoluteStateOfCharge); break; case FULLCHARGECAPACITY: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_FULLCHARGECAPACITY, &BatteryLoggingData.FullChargeCapacity); break; case RUNTIMETOEMPTY: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_RUNTIMETOEMPTY, &BatteryLoggingData.RunTimeToEmpty); break; case AVERAGETIMETOEMPTY: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_AVERAGETIMETOEMPTY, &BatteryLoggingData.AverageTimeToEmpty); break; case AVERAGETIMETOFULL: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_AVERAGETIMETOFULL, &BatteryLoggingData.AverageTimeToFull); break; case CHARGINGCURRENT: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_CHARGINGCURRENT, &BatteryLoggingData.ChargingCurrent); break; case CHARGINGVOLTAGE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_CHARGINGVOLTAGE, &BatteryLoggingData.ChargingVoltage); break; case CYCLECOUNT: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_CYCLECOUNT, &BatteryLoggingData.CycleCount); break; case DESIGNCAPACITY: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_DESIGNCAPACITY, &BatteryLoggingData.DesignCapacity); break; case DESIGNVOLTAGE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_DESIGNVOLTAGE, &BatteryLoggingData.DesignVoltage); break; case SPECIFICATIONINFO: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_SPECIFICATIONINFO, &BatteryLoggingData.SpecificationInfo); break; case MANUFACTUREDATE: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_MANUFACTUREDATE, &BatteryLoggingData.ManufactureDate); break; case SERIALNUMBER: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_SERIALNUMBER, &BatteryLoggingData.SerialNumber); break; case MANUFACTURERNAME: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_MANUFACTURERNAME, &BatteryLoggingData.ManufacturerName); break; case DEVICENAME: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_DEVICENAME, &BatteryLoggingData.DeviceName); break; case DEVICECHEMISTRY: getBatteryData ( BATTERY_PACK_SLAVE_ADDRESS, ADDR_DEVICECHEMISTRY, &BatteryLoggingData.DeviceChemistry); break; case BATTERY_CHARGER_STATUS: /* TODO: Uncomment when battery charger is installed. if ( TRUE == getBatteryData( BATTERY_CHARGER_SLAVE_ADDRESS, BATTERY_CHARGER_STATUS_CMD, &BatteryLoggingData.BatteryChargerStatus ) ) { if ( 0 == ( BatteryLoggingData.BatteryChargerStatus & 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, BatteryLoggingData.BatteryChargerStatus ); #endif } } else { clearAlarmCondition( ALARM_ID_HD_AC_POWER_LOST ); lostACPowerPersistentCount = 0; } } */ break; case END_OF_LIST: current_BM_value = BEGINNING_OF_LIST; publishBatteryManagementData(); break; default: // TODO s/w fault break; } // Go to next value for next time current_BM_value += 1; } /*********************************************************************//** * @brief * The publishBatteryManagementData function publishes the accumulated battery management data * @details Inputs: * @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*)&BatteryLoggingData, sizeof( BATTERY_MANAGER_PAYLOAD_T ) ); } /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ /*********************************************************************//** * @brief * The testSetBatteryRemainingPercentOverride function overrides the battery * remaining percent value. * @details Inputs: none * @details Outputs: batteryRemCapacity_mAh * @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 result = FALSE; if ( TRUE == isTestingActivated() ) { result = TRUE; batteryRemCapacity_mAh.ovData = value; batteryRemCapacity_mAh.override = OVERRIDE_KEY; } return result; } /*********************************************************************//** * @brief * The testResetSetBatteryRemainingPercentOverride function resets the * override of the battery remaining percent value. * @details Inputs: none * @details Outputs: batteryRemCapacity_mAh * @return TRUE if reset successful, FALSE if not *************************************************************************/ BOOL testResetSetBatteryRemainingPercentOverride( void ) { BOOL result = FALSE; if ( TRUE == isTestingActivated() ) { result = TRUE; batteryRemCapacity_mAh.override = OVERRIDE_RESET; batteryRemCapacity_mAh.ovData = batteryRemCapacity_mAh.ovInitData; } return result; } /**@}*/