DK1DA/FreeTRX
1
0
Fork 0
Code Issues Pull requests Projects Releases 13 Packages Wiki Activity Actions
FreeTRX/MDUV380_firmware/application/source/interfaces/batteryAndPowerManagement.c
Marcus Kida 01467e5913 Initial Commit
2026-07-06 08:45:33 +02:00

866 lines
25 KiB
C
Raw Blame History

/*
* Copyright (C) 2021-2025 Roger Clark, VK3KYY / G4KYF
* Daniel Caujolle-Bert, F1RMB
*
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* 4. Use of this source code or binary releases for commercial purposes is strictly forbidden. This includes, without limitation,
* incorporation in a commercial product or incorporation into a product or project which allows commercial use.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "main.h"
#include "usb_device.h"
#include "interfaces/batteryAndPowerManagement.h"
#include "user_interface/uiGlobals.h"
#include "user_interface/uiLocalisation.h"
#include "user_interface/menuSystem.h"
#include "user_interface/uiUtilities.h"
#include "hardware/HR-C6000.h"
#include "usb/usb_com.h"
#include "functions/ticks.h"
#include "interfaces/clockManager.h"
#include "functions/codeplug.h"
#include "hardware/radioHardwareInterface.h"
#include "interfaces/gps.h"
#include "interfaces/settingsStorage.h"
//#define DEBUG_HARDWARE_SCREEN 1
static uint32_t lowBatteryCount = 0;
#define LOW_BATTERY_INTERVAL ((1000 * 60) * 5) // 5 minute;
#define LOW_BATTERY_WARNING_VOLTAGE_DIFFERENTIAL 6 // Offset between the minimum voltage and when the battery warning audio starts. 6 = 0.6V
#define LOW_BATTERY_VOLTAGE_RECOVERY_TIME 30000 // 30 seconds
#define SUSPEND_LOW_BATTERY_RATE 1000 // 1 second
#define BATTERY_VOLTAGE_TICK_RELOAD 100
#define BATTERY_VOLTAGE_CALLBACK_TICK_RELOAD 20
static int batteryVoltageCallbackTick = 0;
static int batteryVoltageTick = BATTERY_VOLTAGE_TICK_RELOAD;
volatile float averageBatteryVoltage = 0;
static volatile float previousAverageBatteryVoltage;
volatile int batteryVoltage = 0;
volatile uint16_t micLevel = 0;
volatile uint16_t potLevel = 0;
volatile uint16_t temperatureLevel = 0;
volatile int lastValidBatteryVoltage = 64;
volatile uint32_t resumeTicks = 0;
#if !defined(PLATFORM_GD77S)
ticksTimer_t apoTimer;
#endif
#if defined(PLATFORM_MD380) || defined(PLATFORM_MDUV380) || defined(PLATFORM_RT84_DM1701) || defined(PLATFORM_MD2017)
bool powerRotarySwitchIsOn(void)
{
return (batteryVoltage > POWEROFF_VOLTAGE_THRESHOLD);
}
#endif
void showLowBattery(void)
{
showErrorMessage(currentLanguage->low_battery);
}
bool batteryIsLowWarning(void)
{
return (lowBatteryCount > LOW_BATTERY_VOLTAGE_RECOVERY_TIME);
}
bool batteryIsLowVoltageWarning(void)
{
return (powerRotarySwitchIsOn() ? (batteryVoltage < (CUTOFF_VOLTAGE_LOWER_HYST + LOW_BATTERY_WARNING_VOLTAGE_DIFFERENTIAL)) : false);
}
bool batteryIsLowCriticalVoltage(void)
{
return (powerRotarySwitchIsOn() ? (batteryVoltage < CUTOFF_VOLTAGE_LOWER_HYST) : false);
}
bool batteryLastReadingIsCritical(void)
{
if (powerRotarySwitchIsOn() == false)
{
return (lastValidBatteryVoltage < CUTOFF_VOLTAGE_UPPER_HYST);
}
lastValidBatteryVoltage = adcGetBatteryVoltage();
return (lastValidBatteryVoltage < CUTOFF_VOLTAGE_UPPER_HYST);
}
void batteryChecking(uiEvent_t *ev)
{
static ticksTimer_t lowBatteryBeepTimer = { 0, 0 };
static ticksTimer_t lowBatteryHeaderRedrawTimer = { 0, 0 };
static uint32_t lowBatteryCriticalCount = 0;
bool lowBatteryWarning = batteryIsLowVoltageWarning();
bool batIsLow = false;
if (powerRotarySwitchIsOn() && (batteryVoltage < 20))
{
if (menuSystemGetCurrentMenuNumber() != UI_POWER_OFF)
{
menuSystemPushNewMenu(UI_POWER_OFF);
}
return;
}
// Low battery threshold is reached after 30 seconds, in total, of lowBatteryWarning.
// Once reached, another 30 seconds is added to the counter to avoid retriggering on voltage fluctuations.
lowBatteryCount += (lowBatteryWarning
? ((lowBatteryCount <= (LOW_BATTERY_VOLTAGE_RECOVERY_TIME * 2)) ? ((lowBatteryCount == LOW_BATTERY_VOLTAGE_RECOVERY_TIME) ? LOW_BATTERY_VOLTAGE_RECOVERY_TIME : 1) : 0)
: (lowBatteryCount ? -1 : 0));
// Do we need to redraw the header row now ?
batIsLow = batteryIsLowWarning();
if (batIsLow && ticksTimerHasExpired(&lowBatteryHeaderRedrawTimer))
{
headerRowIsDirty = true;
ticksTimerStart(&lowBatteryHeaderRedrawTimer, 500);
}
if ((settingsUsbMode != USB_MODE_HOTSPOT) &&
#if defined(PLATFORM_GD77S)
(trxTransmissionEnabled == false) &&
#else
(menuSystemGetCurrentMenuNumber() != UI_TX_SCREEN) &&
#endif
batIsLow &&
ticksTimerHasExpired(&lowBatteryBeepTimer))
{
if (melody_play == NULL)
{
if (nonVolatileSettings.audioPromptMode < AUDIO_PROMPT_MODE_VOICE_THRESHOLD)
{
soundSetMelody(MELODY_LOW_BATTERY);
}
else
{
voicePromptsInit();
voicePromptsAppendLanguageString(currentLanguage->low_battery);
voicePromptsPlay();
}
// Let the beep sound, or the VP, to finish to play before resuming the scan (otherwise is could be silent).
if (uiDataGlobal.Scan.active)
{
uiDataGlobal.Scan.active = false;
watchdogRun(false);
while ((melody_play != NULL) || voicePromptsIsPlaying())
{
voicePromptsTick();
soundTickMelody();
osDelay(1);
}
watchdogRun(true);
uiDataGlobal.Scan.active = true;
}
ticksTimerStart(&lowBatteryBeepTimer, LOW_BATTERY_INTERVAL);
}
}
// Check if the battery has reached critical voltage (power off)
bool lowBatteryCritical = powerRotarySwitchIsOn() ? batteryIsLowCriticalVoltage() : false;
// Critical battery threshold is reached after 30 seconds, in total, of lowBatteryCritical.
lowBatteryCriticalCount += (lowBatteryCritical ? 1 : (lowBatteryCriticalCount ? -1 : 0));
// Low battery or poweroff (non RD-5R)
bool powerSwitchIsOff =
#if defined(PLATFORM_MD380) || defined(PLATFORM_MDUV380) || defined(PLATFORM_RT84_DM1701) || defined(PLATFORM_MD2017)
(powerRotarySwitchIsOn() == false);
#else
false;
#endif
if ((powerSwitchIsOff || lowBatteryCritical) && (menuSystemGetCurrentMenuNumber() != UI_POWER_OFF))
{
// is considered as flat (stable value), now stop the firmware: make it silent
if ((lowBatteryCritical && (lowBatteryCriticalCount > LOW_BATTERY_VOLTAGE_RECOVERY_TIME)) || powerSwitchIsOff)
{
radioAudioAmp(false);
soundSetMelody(NULL);
}
// Avoids delayed power off (on non RD-5R) if the power switch is turned off while in low battery condition
if (lowBatteryCritical && (powerSwitchIsOff == false))
{
// Now, the battery is considered as flat (stable value), powering off.
if (lowBatteryCriticalCount > LOW_BATTERY_VOLTAGE_RECOVERY_TIME)
{
showLowBattery();
powerOffFinalStage(false, false);
}
}
#if ! defined(PLATFORM_RD5R)
else
{
bool suspend = false;
#if !(defined(PLATFORM_GD77S) || defined(STM32F405xx))
suspend = settingsIsOptionBitSet(BIT_POWEROFF_SUSPEND);
// Suspend bit is set, but user pressed the SK2, asking for a real poweroff
if (suspend && BUTTONCHECK_DOWN(ev, BUTTON_SK2))
{
suspend = false;
} // Suspend bit is NOT set, but user pressed the SK2, asking for a suspend
else if ((suspend == false) && BUTTONCHECK_DOWN(ev, BUTTON_SK2))
{
suspend = true;
}
#endif
if (suspend)
{
powerOffFinalStage(true, false);
}
else
{
menuSystemPushNewMenu(UI_POWER_OFF);
}
}
#endif // ! PLATFORM_RD5R
}
}
void batteryUpdate(void)
{
batteryVoltageTick++;
if (batteryVoltageTick >= BATTERY_VOLTAGE_TICK_RELOAD)
{
if (powerRotarySwitchIsOn())
{
if (previousAverageBatteryVoltage != averageBatteryVoltage)
{
previousAverageBatteryVoltage = averageBatteryVoltage;
headerRowIsDirty = true;
}
batteryVoltageCallbackTick++;
if (batteryVoltageCallbackTick >= BATTERY_VOLTAGE_CALLBACK_TICK_RELOAD)
{
menuRadioInfosPushBackVoltage(averageBatteryVoltage);
batteryVoltageCallbackTick = 0;
}
}
batteryVoltageTick = 0;
}
}
void powerDown(bool doNotSavePowerOffState)
{
if (!doNotSavePowerOffState)
{
#if defined(PLATFORM_MD9600)
uint16_t radioPowerState = RADIO_POWER_STATE_STANDBY_FLAG;
batteryRAM_Write(0, (uint8_t *)&radioPowerState, 2U);
#endif
}
settingsSaveSettings(true);
codeplugSaveLastUsedChannelInZone();
#if defined(HAS_GPS)
#if defined(LOG_GPS_DATA)
gpsLoggingStop();
#endif
gpsOff();
#if defined(PLATFORM_MD9600)
gpsPower(false);
#endif
#endif
// Give it a bit of time to finish to write the flash (avoiding corruptions).
uint32_t m = ticksGetMillis();
while (true)
{
if ((ticksGetMillis() - m) > 300U)
{
break;
}
osDelay(1);
}
gpioSetDisplayBacklightIntensityPercentage(0);
displaySetDisplayPowerMode(false);
radioPowerOff(true, true);
//Reset the display, saves about 1mA
HAL_GPIO_WritePin(LCD_CS_GPIO_Port, LCD_CS_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(LCD_RST_GPIO_Port, LCD_RST_Pin, GPIO_PIN_RESET);
osDelay(20);
MX_USB_DEVICE_DeInit(); // Deinit USB
HAL_SuspendTick();
HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);
HAL_RTCEx_DeactivateWakeUpTimer(&hrtc);
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
__HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(&hrtc, RTC_FLAG_WUTF);
HAL_PWR_EnterSTANDBYMode();
HAL_GPIO_WritePin(PWR_SW_GPIO_Port, PWR_SW_Pin, GPIO_PIN_RESET);
}
void die(bool usbMonitoring, bool maintainRTC, bool forceSuspend, bool safeBoot)
{
int8_t batteryCriticalCount = 0;
#if !defined(PLATFORM_RD5R) && !defined(PLATFORM_GD77S)
uint32_t lowBatteryCriticalCount = 0;
ticksTimer_t nextPITCounterRunTimer = { .start = ticksGetMillis(), .timeout = SUSPEND_LOW_BATTERY_RATE };
#if defined(DEBUG_HARDWARE_SCREEN)
uint16_t y = 8;
#else
UNUSED_PARAMETER(safeBoot);
#endif
if (!maintainRTC)
{
HAL_GPIO_WritePin(PWR_SW_GPIO_Port, PWR_SW_Pin, GPIO_PIN_RESET); // This is normally already done before this function is called.
// But do it again, just in case, as its important that the radio will turn off when the power control is turned to off
}
#endif
audioAmpDisable(AUDIO_AMP_CHANNEL_RF);
audioAmpDisable(AUDIO_AMP_CHANNEL_BEEP);
audioAmpDisable(AUDIO_AMP_CHANNEL_PROMPT);
LedWrite(LED_GREEN, 0);
LedWrite(LED_RED, 0);
trxResetSquelchesState(RADIO_DEVICE_PRIMARY); // Could be put in sleep state and awaken with a signal, so this will re-enable the audio AMP
trxPowerUpDownRxAndC6000(false, true, true);
if (usbMonitoring)
{
ticksTimer_t checkBatteryTimer = { .start = ticksGetMillis(), .timeout = (safeBoot ? 500U : 1000U) };
#if defined(DEBUG_HARDWARE_SCREEN)
#warning SAFEBOOT HARDWARE DEBUG SCREEN ENABLED
if (safeBoot)
{
#if defined(STM32F405xx) && ! defined(PLATFORM_MD9600)
char cpuTypeBuf[SCREEN_LINE_BUFFER_SIZE] = {0};
uint32_t vpHeader[2];
displayClearBuf();
sprintf(cpuTypeBuf, "CPU Type :%s (%u)", ((NumInterruptPriorityBits == 4) ? "STM" : "TYT"), NumInterruptPriorityBits);
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "CPU Sig :0x%04X", cpuGetSignature());
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "CPU Rev :0x%04X", cpuGetRevision());
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "CPU Pack :0x%04X", cpuGetPackage());
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "CPU Flash :%dkb", cpuGetFlashSize());
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "Flash Type :0x%X", flashChipPartNumber);
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "NVRAM :0x%X %u", nonVolatileSettings.magicNumber, settingsIsOptionBitSet(BIT_SETTINGS_UPDATED));
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
sprintf(cpuTypeBuf, "Codec :%s", (codecIsAvailable() ? "OK" : "KO"));
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
SPI_Flash_read(VOICE_PROMPTS_FLASH_HEADER_ADDRESS, (uint8_t *)&vpHeader, sizeof(vpHeader));
sprintf(cpuTypeBuf, "VP :0x%X 0x%X", vpHeader[0], vpHeader[1]);
displayPrintAt(0, y, cpuTypeBuf , FONT_SIZE_2);
y += FONT_SIZE_2_HEIGHT;
displayRender();
#endif
}
#endif
while(true)
{
tick_com_request();
vTaskDelay((0U / portTICK_PERIOD_MS));
#if defined(DEBUG_HARDWARE_SCREEN)
if (safeBoot)
{
if (ticksTimerHasExpired(&checkBatteryTimer)) // reuse this timer
{
char buf[SCREEN_LINE_BUFFER_SIZE];
uint16_t ypos = y;
uint32_t buttons = 0;
int button_event = EVENT_BUTTON_NONE;
uint32_t key = keyboardRead();
#if defined(PLATFORM_MDUV380) || defined(PLATFORM_RT84_DM1701)
uint8_t rotDir = ' ';
#elif defined(PLATFORM_MD2017)
uint8_t trackDir = ' ';
#endif
buttonsCheckButtonsEvent(&buttons, &button_event, false);
displayFillRect(0, ypos, DISPLAY_SIZE_X, DISPLAY_SIZE_Y - y, true);
sprintf(buf, "Ps :%u, Lvl :%u %d", powerRotarySwitchIsOn(), potLevel, getVolumeControl());
displayPrintAt(0, ypos, buf , FONT_SIZE_2);
ypos += FONT_SIZE_2_HEIGHT;
sprintf(buf, "V :%d, ADC :%d", lastValidBatteryVoltage, adcGetBatteryVoltage());
displayPrintAt(0, ypos, buf , FONT_SIZE_2);
ypos += FONT_SIZE_2_HEIGHT;
sprintf(buf, "Btn :0x%X, Evt :%d", buttons, button_event);
displayPrintAt(0, ypos, buf , FONT_SIZE_2);
ypos += FONT_SIZE_2_HEIGHT;
sprintf(buf, "Key :%3d [%c]", key, ((key != 0) ? key : ' '));
displayPrintAt(0, ypos, buf , FONT_SIZE_2);
ypos += FONT_SIZE_2_HEIGHT;
#if defined(PLATFORM_MDUV380) || defined(PLATFORM_RT84_DM1701)
if (rotaryData.Direction != 0)
{
rotDir = ((rotaryData.Direction == 1) ? '+' : '-');
nonVolatileSettings.displayBacklightPercentage[DAY] += ((rotaryData.Direction > 0) ?
(nonVolatileSettings.displayBacklightPercentage[DAY] >= 10 ? 10 : 1)
:
(nonVolatileSettings.displayBacklightPercentage[DAY] >= 20 ? -10 : -1));
nonVolatileSettings.displayBacklightPercentage[DAY] = CLAMP(nonVolatileSettings.displayBacklightPercentage[DAY], 0, 100);
gpioSetDisplayBacklightIntensityPercentage(nonVolatileSettings.displayBacklightPercentage[DAY]);
rotaryData.Direction = 0;
}
sprintf(buf, "Rot :[%c], Bcl :%d%%", rotDir, nonVolatileSettings.displayBacklightPercentage[DAY]);
#elif defined(PLATFORM_MD2017)
if (trackballData.Count > (2 + 1)) // TRACKBALL_FAST_MOTION + 1
{
trackDir = trackballData.Direction;
trackballData.Count -= 2; // TRACKBALL_FAST_MOTION
}
sprintf(buf, "TBall :[%c], Cnt :%d", trackDir, trackballData.Count);
#endif
displayPrintAt(0, ypos, buf , FONT_SIZE_2);
//ypos += FONT_SIZE_2_HEIGHT;
displayRenderRows(y / 8, ((ypos / 8) + (FONT_SIZE_2_HEIGHT / 8)));
ticksTimerStart(&checkBatteryTimer, 200U);
}
batteryUpdate();
getVolumeControl(); // continue to average value..
}
else
#endif
{
if (ticksTimerHasExpired(&checkBatteryTimer))
{
batteryCriticalCount += (batteryLastReadingIsCritical() ? 1 : (batteryCriticalCount ? -1 : 0));
if (batteryCriticalCount > (LOW_BATTERY_VOLTAGE_RECOVERY_TIME / 1000))
{
powerDown(true);
while(true); // won't reach this.
}
ticksTimerStart(&checkBatteryTimer, 1000U);
}
}
}
}
else
{
uint8_t batteryLowRetries = 50;
#if !defined(PLATFORM_GD77S)
uint32_t prevPowerSwitchState =
#if !defined(PLATFORM_RD5R)
(powerRotarySwitchIsOn() ? 0 : 1)
#else
1
#endif
;
#endif
#if defined(HAS_GPS)
#if defined(LOG_GPS_DATA)
gpsLoggingStop();
#endif
gpsOff();
#if defined(PLATFORM_MD9600)
gpsPower(false);
#endif
#endif
while(batteryLowRetries-- > 0)
{
batteryCriticalCount += (batteryLastReadingIsCritical() ? 1 : (batteryCriticalCount ? -1 : 0));
osDelay(1);
}
bool batteryIsCritical = batteryCriticalCount > 25;
clockManagerSetRunMode(kAPP_PowerModeRun, CLOCK_MANAGER_RUN_SUSPEND_MODE);
isSuspended = true;
/* VK3KYY Need to port
watchdogDeinit();
*/
if (batteryIsCritical)
{
powerDown(true);
while(true); // won't reach this.
}
else
{
displaySetDisplayPowerMode(false);
}
MX_USB_DEVICE_DeInit(); // Deinit USB
while(true)
{
batteryUpdate();
#if !defined(PLATFORM_GD77S)
if (uiDataGlobal.SatelliteAndAlarmData.alarmType == ALARM_TYPE_NONE)
{
uint32_t powerSwitchState =
#if !defined(PLATFORM_RD5R)
(powerRotarySwitchIsOn() ? 0 : 1)
#else
1
#endif
;
// Safe Power On option is ON, user didn't press SK1 on power ON, so
// forceSuspend is true.
// Now, user just turned OFF the power switch, clear the forceSuspend flag to
// be able to handle the power ON event.
if ((powerSwitchState != 0) && forceSuspend)
{
forceSuspend = false;
}
if ((powerSwitchState == 0) && (forceSuspend == false) &&
((settingsIsOptionBitSet(BIT_SAFE_POWER_ON) ?
(((buttonsRead() & BUTTON_SK1) != 0) && (powerSwitchState != prevPowerSwitchState))
: true)))
{
// User wants to go in bootloader mode
if (buttonsRead() == (BUTTON_SK1 | BUTTON_PTT))
{
NVIC_SystemReset();
}
wakeFromSleep();
return;
}
prevPowerSwitchState = powerSwitchState;
}
#endif
#if !defined(PLATFORM_RD5R) && !defined(PLATFORM_GD77S)
if (ticksTimerHasExpired(&nextPITCounterRunTimer))
{
// Check if the battery has reached critical voltage (power off)
bool powerSwitchIsOn = powerRotarySwitchIsOn();
bool lowBatteryCritical = powerSwitchIsOn ? batteryIsLowCriticalVoltage() : false;
// Critical battery threshold is reached after 30 seconds, in total, of lowBatteryCritical.
lowBatteryCriticalCount += (lowBatteryCritical ? 1 : (lowBatteryCriticalCount ? -1 : 0));
if ((powerSwitchIsOn == false) ||
(lowBatteryCritical && (lowBatteryCriticalCount > (LOW_BATTERY_VOLTAGE_RECOVERY_TIME / 1000) /* 30s in total */)))
{
HAL_GPIO_WritePin(PWR_SW_GPIO_Port, PWR_SW_Pin, GPIO_PIN_RESET);
while(true);
}
ticksTimerStart(&nextPITCounterRunTimer, SUSPEND_LOW_BATTERY_RATE);
}
if (uiDataGlobal.SatelliteAndAlarmData.alarmType != ALARM_TYPE_NONE)
{
bool powerSwitchIsOff = (powerRotarySwitchIsOn() == false);
if (powerSwitchIsOff)
{
uiDataGlobal.SatelliteAndAlarmData.alarmType = ALARM_TYPE_NONE;
}
}
if (uiDataGlobal.SatelliteAndAlarmData.alarmType != ALARM_TYPE_NONE)
{
bool wakingUp =
#if defined(PLATFORM_RT84_DM1701) || defined(PLATFORM_MD2017)
(buttonsRead() & BUTTON_ORANGE);
#else // MD-UV3x0 | RT3S
((buttonsRead() & (BUTTON_SK2 | BUTTON_PTT)) == (BUTTON_SK2 | BUTTON_PTT));
#endif
if (wakingUp)
{
// Wait for button(s) release
while (
#if (defined(PLATFORM_RT84_DM1701) || defined(PLATFORM_MD2017))
(buttonsRead() & BUTTON_ORANGE)
#else
(buttonsRead() & (BUTTON_SK2 | BUTTON_PTT))
#endif
)
{
osDelay(10);
}
wakeFromSleep();
return;
}
}
if (uiDataGlobal.SatelliteAndAlarmData.alarmType == ALARM_TYPE_SATELLITE ||
uiDataGlobal.SatelliteAndAlarmData.alarmType == ALARM_TYPE_CLOCK)
{
if (uiDataGlobal.dateTimeSecs >= uiDataGlobal.SatelliteAndAlarmData.alarmTime)
{
wakeFromSleep();
return;
}
}
#endif
osDelay(100);
}
}
}
void wakeFromSleep(void)
{
MX_USB_DEVICE_Init();
#if !defined(PLATFORM_RD5R)
if (menuSystemGetPreviousMenuNumber() == MENU_SATELLITE)
{
// clockManagerSetRunMode(kAPP_PowerModeRun, CLOCK_MANAGER_SPEED_HS_RUN);
clockManagerSetRunMode(kAPP_PowerModeRun, CLOCK_MANAGER_SPEED_RUN);
}
else
{
clockManagerSetRunMode(kAPP_PowerModeRun, CLOCK_MANAGER_SPEED_RUN);
}
/*
GPIO_PinWrite(GPIO_Keep_Power_On, Pin_Keep_Power_On, 1);// This is normally already done before this function is called.
// But do it again, just in case, as its important that the radio will turn off when the power control is turned to off
*/
trxPowerUpDownRxAndC6000(true, true, true);
// Reset counters before enabling watchdog
hrc6000Task.AliveCount = TASK_FLAGGED_ALIVE;
beepTask.AliveCount = TASK_FLAGGED_ALIVE;
/* VK3KYY Need to port to MD9600
watchdogInit();
*/
displaySetDisplayPowerMode(true);
if (trxGetMode() == RADIO_MODE_DIGITAL)
{
HRC6000ResetTimeSlotDetection();
HRC6000InitDigitalDmrRx();
}
#endif
#if defined(HAS_GPS)
if (SETTINGS_GPS_MODE_GET(nonVolatileSettings) >= GPS_MODE_OFF)
{
gpsOn();
#if defined(LOG_GPS_DATA)
gpsLoggingStart();
#endif
}
#endif
#if !defined(PLATFORM_GD77S)
if (nonVolatileSettings.apo > 0)
{
ticksTimerStart(&apoTimer, ((nonVolatileSettings.apo * 30) * 60000U));
}
if ((nonVolatileSettings.autolockTimer > 0) && ticksTimerIsEnabled(&autolockTimer))
{
ticksTimerStart(&autolockTimer, (nonVolatileSettings.autolockTimer * 30000U));
}
#endif
// Trick to compensate the fact that VBat is disconnected from the battery when
// the power switch is set to OFF. Hence, we need to display the non averaged
// voltage value, to avoid the long ramp up.
resumeTicks = (ticksGetMillis() + BATTERY_VOLTAGE_STABILISATION_TIME);
voicePromptsInit(); // Flush the VPs
isSuspended = false;
}
void powerOffFinalStage(bool maintainRTC, bool forceSuspend)
{
uint32_t m;
// If TXing, get back to RX (this function can be called on low battery event).
if (trxTransmissionEnabled)
{
trxTransmissionEnabled = false;
trxActivateRx(true);
trxIsTransmitting = false;
LedWrite(LED_RED, 0);//LEDs_PinWrite(GPIO_LEDred, Pin_LEDred, 0);
}
// Restore DMR filter settings if the radio is turned off whilst in monitor mode
if (monitorModeData.isEnabled)
{
nonVolatileSettings.dmrCcTsFilter = monitorModeData.savedDMRCcTsFilter;
nonVolatileSettings.dmrDestinationFilter = monitorModeData.savedDMRDestinationFilter;
}
// If user was in a private call when they turned the radio off we need to restore the last Tg prior to stating the Private call.
// to the nonVolatile Setting overrideTG, otherwise when the radio is turned on again it be in PC mode to that station.
if ((trxTalkGroupOrPcId >> 24) == PC_CALL_FLAG)
{
settingsSet(nonVolatileSettings.overrideTG, uiDataGlobal.tgBeforePcMode);
}
menuHotspotRestoreSettings();
codeplugSaveLastUsedChannelInZone();
#if defined(LOG_GPS_DATA)
gpsLoggingStop();
#endif
m = ticksGetMillis();
settingsSaveSettings(true);
// Give it a bit of time before pulling the plug as DM-1801 EEPROM looks slower
// than GD-77 to write, then quickly power cycling triggers settings reset.
while (true)
{
if ((ticksGetMillis() - m) > 50)
{
break;
}
osDelay(1);
}
displayEnableBacklight(false, 0);
#if ! (defined(PLATFORM_RD5R))// || defined(PLATFORM_MD9600) || defined(PLATFORM_MD380) || defined(PLATFORM_MDUV380) || defined(PLATFORM_RT84_DM1701) || defined(PLATFORM_MD2017))
// This turns the power off to the CPU.
if (!maintainRTC)
{
HAL_GPIO_WritePin(PWR_SW_GPIO_Port, PWR_SW_Pin, GPIO_PIN_RESET);
}
#endif
die(false, maintainRTC, forceSuspend, false);
}
#if !defined(PLATFORM_GD77S)
void apoTick(bool eventFromOperator)
{
if (nonVolatileSettings.apo > 0)
{
int currentMenu = menuSystemGetCurrentMenuNumber();
// Reset APO timer:
// - on events
// - when scanning
// - when user has set a Satellite alarm
// - when transmissing, while in hotspot mode or while using the CPS
// - on RF activity
if (eventFromOperator ||
uiDataGlobal.Scan.active ||
((currentMenu == UI_TX_SCREEN) || (currentMenu == UI_HOTSPOT_MODE) || (currentMenu == UI_CPS)) ||
(uiDataGlobal.SatelliteAndAlarmData.alarmType != ALARM_TYPE_NONE))
{
if (uiNotificationIsVisible() && (uiNotificationGetId() == NOTIFICATION_ID_USER_APO))
{
uiNotificationHide(true);
}
ticksTimerStart(&apoTimer, ((nonVolatileSettings.apo * 30) * 60000U));
}
// No event in the last 'apo' time => Suspend
if (ticksTimerHasExpired(&apoTimer))
{
powerDown(false);
}
else
{
// 1 minute or less is remaining, it's time to show the APO notification
if ((ticksTimerRemaining(&apoTimer) <= 60000U) &&
((uiNotificationIsVisible() && (uiNotificationGetId() == NOTIFICATION_ID_USER_APO)) == false))
{
if (nonVolatileSettings.audioPromptMode < AUDIO_PROMPT_MODE_VOICE_THRESHOLD)
{
soundSetMelody(MELODY_APO_TRIGGERED);
}
else
{
voicePromptsInit();
voicePromptsAppendLanguageString(currentLanguage->auto_power_off);
voicePromptsPlay();
}
uiNotificationShow(NOTIFICATION_TYPE_MESSAGE, NOTIFICATION_ID_USER_APO, 60000U, currentLanguage->auto_power_off, true);
}
}
}
}
#endif
Reference in a new issue View git blame Copy permalink