arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-08-05 13:26:57 +00:00
Code Issues Releases Wiki Activity

style(core): fix cstyles [no changelog]

Browse Source
This commit is contained in:
kopecdav 2025-05-07 18:45:45 +02:00 committed by kopecdav
parent a3ab75b5aa
commit 892a1b8171
11 changed files with 46 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/embed/io/nrf/stm32u5/nrf.c
View File

@ -25,9 +25,9 @@
#include <io/nrf.h> #include <io/nrf.h>
#include <sys/irq.h> #include <sys/irq.h>
#include <sys/mpu.h> #include <sys/mpu.h>
#include <sys/power_manager.h>
#include <sys/systick.h> #include <sys/systick.h>
#include <sys/systimer.h> #include <sys/systimer.h>
#include <sys/power_manager.h>
#include <util/tsqueue.h> #include <util/tsqueue.h>
#include "../crc8.h" #include "../crc8.h"

7
core/embed/projects/prodtest/cmd/prodtest_power_manager.c
View File

@ -312,10 +312,9 @@ void prodtest_pm_event_monitor(cli_t* cli) {
} }
cli_progress(cli, "%s %s %d %d %d", cli_progress(cli, "%s %s %d %d %d",
state.usb_connected ? "USB_connected" : "USB_disconnected", state.usb_connected ? "USB_connected" : "USB_disconnected",
state.wireless_connected ? "WLC_connected" : "WLC_disconnected", state.wireless_connected ? "WLC_connected" : "WLC_disconnected",
state.charging_status, state.power_state, state.soc); state.charging_status, state.power_state, state.soc);
cli_ok(cli, ""); cli_ok(cli, "");
} }

6
core/embed/projects/prodtest/cmd/prodtest_wpc.c
View File

@ -22,14 +22,13 @@
#include <trezor_rtl.h> #include <trezor_rtl.h>
#include <rtl/cli.h> #include <rtl/cli.h>
#include <sys/systick.h>
#include <sys/power_manager.h> #include <sys/power_manager.h>
#include <sys/systick.h>
#include <stdlib.h> #include <stdlib.h>
#include "../stwlc38/stwlc38.h" #include "../stwlc38/stwlc38.h"
static void prodtest_wpc_info(cli_t* cli) { static void prodtest_wpc_info(cli_t* cli) {
if (cli_arg_count(cli) > 0) { if (cli_arg_count(cli) > 0) {
cli_error_arg_count(cli); cli_error_arg_count(cli);
return; return;
@ -41,7 +40,6 @@ static void prodtest_wpc_info(cli_t* cli) {
// Deinit power manager to not interfere with STWLC38 // Deinit power manager to not interfere with STWLC38
pm_deinit(); pm_deinit();
stwlc38_init(); stwlc38_init();
cli_trace(cli, "Reading STWLC38 info..."); cli_trace(cli, "Reading STWLC38 info...");
@ -77,7 +75,6 @@ static void prodtest_wpc_info(cli_t* cli) {
cli_trace(cli, " nvm_patch_err: 0x%X ", chip_info.nvm_patch_err); cli_trace(cli, " nvm_patch_err: 0x%X ", chip_info.nvm_patch_err);
cli_trace(cli, " nvm_prod_info_err: 0x%X ", chip_info.nvm_prod_info_err); cli_trace(cli, " nvm_prod_info_err: 0x%X ", chip_info.nvm_prod_info_err);
stwlc38_deinit(); stwlc38_deinit();
// initlize power manager again // initlize power manager again
@ -97,7 +94,6 @@ cleanup:
cli_error(cli, CLI_ERROR, "Failed to reinitialize power manager."); cli_error(cli, CLI_ERROR, "Failed to reinitialize power manager.");
return; return;
} }
} }
static void prodtest_wpc_update(cli_t* cli) { static void prodtest_wpc_update(cli_t* cli) {

2
core/embed/sys/backup_ram/backup_ram.c
View File

@ -148,7 +148,7 @@ backup_ram_status_t backup_ram_erase_unused(void) {
} }
backup_ram_status_t backup_ram_store_power_manager_data( backup_ram_status_t backup_ram_store_power_manager_data(
const backup_ram_power_manager_data_t *pm_data) { const backup_ram_power_manager_data_t *pm_data) {
backup_ram_driver_t *drv = &backup_ram_driver; backup_ram_driver_t *drv = &backup_ram_driver;
if (!drv->initialized) { if (!drv->initialized) {

8
core/embed/sys/power_manager/fuel_gauge/fuel_gauge.c
View File

@ -31,7 +31,7 @@ void fuel_gauge_init(fuel_gauge_state_t* state, float R, float Q,
// Initialize state // Initialize state
state->soc = 0.0f; state->soc = 0.0f;
state->soc_latched = 0.0f; state->soc_latched = 0.0f;
state->P = P_init; // Initial error covariance state->P = P_init; // Initial error covariance
} }
void fuel_gauge_reset(fuel_gauge_state_t* state) { void fuel_gauge_reset(fuel_gauge_state_t* state) {
@ -44,7 +44,7 @@ void fuel_gauge_set_soc(fuel_gauge_state_t* state, float soc, float P) {
// Set SOC directly // Set SOC directly
state->soc = soc; state->soc = soc;
state->soc_latched = soc; state->soc_latched = soc;
state->P = P; // Set error covariance state->P = P; // Set error covariance
} }
void fuel_gauge_initial_guess(fuel_gauge_state_t* state, float voltage_V, void fuel_gauge_initial_guess(fuel_gauge_state_t* state, float voltage_V,
@ -60,8 +60,8 @@ void fuel_gauge_initial_guess(fuel_gauge_state_t* state, float voltage_V,
state->soc_latched = state->soc; state->soc_latched = state->soc;
} }
float fuel_gauge_update(fuel_gauge_state_t* state, uint32_t dt_ms, float voltage_V, float fuel_gauge_update(fuel_gauge_state_t* state, uint32_t dt_ms,
float current_mA, float temperature) { float voltage_V, float current_mA, float temperature) {
// Determine if we're in discharge mode // Determine if we're in discharge mode
bool discharging_mode = current_mA >= 0.0f; bool discharging_mode = current_mA >= 0.0f;

4
core/embed/sys/power_manager/fuel_gauge/fuel_gauge.h
View File

@ -80,5 +80,5 @@ void fuel_gauge_initial_guess(fuel_gauge_state_t* state, float voltage_V,
* @param temperature Battery temperature (°C) * @param temperature Battery temperature (°C)
* @return Updated SOC estimate (0.0 to 1.0) * @return Updated SOC estimate (0.0 to 1.0)
*/ */
float fuel_gauge_update(fuel_gauge_state_t* state, uint32_t dt_ms, float voltage_V, float fuel_gauge_update(fuel_gauge_state_t* state, uint32_t dt_ms,
float current_mA, float temperature); float voltage_V, float current_mA, float temperature);

11
core/embed/sys/power_manager/inc/sys/power_manager.h
View File

@ -23,11 +23,11 @@
typedef enum { typedef enum {
PM_WAKEUP_FLAG_BUTTON = 0x1 << 0, // Button pressed PM_WAKEUP_FLAG_BUTTON = 0x1 << 0, // Button pressed
PM_WAKEUP_FLAG_WPC = 0x1 << 1, // Wireless power charging event PM_WAKEUP_FLAG_WPC = 0x1 << 1, // Wireless power charging event
PM_WAKEUP_FLAG_BLE = 0x1 << 2, // Bluetooth connection event PM_WAKEUP_FLAG_BLE = 0x1 << 2, // Bluetooth connection event
PM_WAKEUP_FLAG_NFC = 0x1 << 3, // NFC event PM_WAKEUP_FLAG_NFC = 0x1 << 3, // NFC event
PM_WAKEUP_FLAG_USB = 0x1 << 4, // USB event PM_WAKEUP_FLAG_USB = 0x1 << 4, // USB event
PM_WAKEUP_FLAG_TIMER = 0x1 << 5, // Timer event PM_WAKEUP_FLAG_TIMER = 0x1 << 5, // Timer event
} pm_wakeup_flags_t; } pm_wakeup_flags_t;
/* API return status codes */ /* API return status codes */
@ -111,4 +111,3 @@ pm_status_t pm_wait_until_active(uint32_t timeout_ms);
pm_status_t pm_wakeup_flags_set(pm_wakeup_flags_t flags); pm_status_t pm_wakeup_flags_set(pm_wakeup_flags_t flags);
pm_status_t pm_wakeup_flags_reset(void); pm_status_t pm_wakeup_flags_reset(void);
pm_status_t pm_wakeup_flags_get(pm_wakeup_flags_t* flags); pm_status_t pm_wakeup_flags_get(pm_wakeup_flags_t* flags);

5
core/embed/sys/power_manager/stm32u5/power_control.c
View File

@ -77,7 +77,7 @@ pm_status_t pm_control_hibernate() {
} }
// Wait for the device to power off // Wait for the device to power off
//systick_delay_ms(50); // systick_delay_ms(50);
return PM_ERROR; return PM_ERROR;
} }
@ -206,9 +206,6 @@ void pm_control_suspend() {
#ifdef USE_TROPIC #ifdef USE_TROPIC
tropic_init(); tropic_init();
#endif #endif
} }
static void pm_background_tasks_suspend(void) { static void pm_background_tasks_suspend(void) {

56
core/embed/sys/power_manager/stm32u5/power_manager.c
View File

@ -59,7 +59,6 @@ pm_status_t pm_init(bool inherit_state) {
PM_FUEL_GAUGE_R_AGGRESSIVE, PM_FUEL_GAUGE_Q_AGGRESSIVE, PM_FUEL_GAUGE_R_AGGRESSIVE, PM_FUEL_GAUGE_Q_AGGRESSIVE,
PM_FUEL_GAUGE_P_INIT); PM_FUEL_GAUGE_P_INIT);
// Create monitoring timer // Create monitoring timer
drv->monitoring_timer = systimer_create(pm_monitoring_timer_handler, NULL); drv->monitoring_timer = systimer_create(pm_monitoring_timer_handler, NULL);
systimer_set_periodic(drv->monitoring_timer, PM_BATTERY_SAMPLING_PERIOD_MS); systimer_set_periodic(drv->monitoring_timer, PM_BATTERY_SAMPLING_PERIOD_MS);
@ -70,44 +69,38 @@ pm_status_t pm_init(bool inherit_state) {
// Initial power source measurement // Initial power source measurement
npm1300_measure(pm_pmic_data_ready, NULL); npm1300_measure(pm_pmic_data_ready, NULL);
// Try to recover SoC from the backup RAM // Try to recover SoC from the backup RAM
backup_ram_power_manager_data_t pm_recovery_data; backup_ram_power_manager_data_t pm_recovery_data;
backup_ram_status_t status = backup_ram_status_t status =
backup_ram_read_power_manager_data(&pm_recovery_data); backup_ram_read_power_manager_data(&pm_recovery_data);
if (status == BACKUP_RAM_OK) { if (status == BACKUP_RAM_OK) {
fuel_gauge_set_soc(&drv->fuel_gauge, pm_recovery_data.soc, pm_recovery_data.P); fuel_gauge_set_soc(&drv->fuel_gauge, pm_recovery_data.soc,
pm_recovery_data.P);
} else { } else {
// Wait for 1s to sample battery data // Wait for 1s to sample battery data
systick_delay_ms(1000); systick_delay_ms(1000);
pm_battery_initial_soc_guess(); pm_battery_initial_soc_guess();
} }
if(inherit_state){ if (inherit_state) {
// Inherit power manager state left in beckup RAM from bootloader. // Inherit power manager state left in beckup RAM from bootloader.
// in case of error, start with PM_STATE_POWER_SAVE as a lowest state in // in case of error, start with PM_STATE_POWER_SAVE as a lowest state in
// active mode. // active mode.
if (status != BACKUP_RAM_OK && if (status != BACKUP_RAM_OK &&
(pm_recovery_data.bootloader_exit_state != PM_STATE_POWER_SAVE && (pm_recovery_data.bootloader_exit_state != PM_STATE_POWER_SAVE &&
pm_recovery_data.bootloader_exit_state != PM_STATE_ACTIVE)) { pm_recovery_data.bootloader_exit_state != PM_STATE_ACTIVE)) {
drv->state = PM_STATE_POWER_SAVE;
drv->state = PM_STATE_POWER_SAVE;
} else { } else {
// Backup RAM contain valid data // Backup RAM contain valid data
drv->state = pm_recovery_data.bootloader_exit_state; drv->state = pm_recovery_data.bootloader_exit_state;
} }
}else{ } else {
// Start in lowest state and wait for the bootup sequence to // Start in lowest state and wait for the bootup sequence to
// finish (call of pm_turn_on()) // finish (call of pm_turn_on())
drv->state = PM_STATE_HIBERNATE; drv->state = PM_STATE_HIBERNATE;
} }
// Fuel gauge SoC available, set fuel_gauge initialized. // Fuel gauge SoC available, set fuel_gauge initialized.
@ -119,11 +112,11 @@ pm_status_t pm_init(bool inherit_state) {
// Poll until fuel_gauge is initialized and first PMIC & WLC measurements // Poll until fuel_gauge is initialized and first PMIC & WLC measurements
// propagates into power_monitor. // propagates into power_monitor.
bool state_machine_stabilized; bool state_machine_stabilized;
do{ do {
irq_key_t irq_key = irq_lock(); irq_key_t irq_key = irq_lock();
state_machine_stabilized = drv->state_machine_stabilized; state_machine_stabilized = drv->state_machine_stabilized;
irq_unlock(irq_key); irq_unlock(irq_key);
}while(!state_machine_stabilized); } while (!state_machine_stabilized);
drv->initialized = true; drv->initialized = true;
@ -143,7 +136,7 @@ void pm_deinit(void) {
drv->shutdown_timer = NULL; drv->shutdown_timer = NULL;
} }
if(drv->fuel_gauge_initialized){ if (drv->fuel_gauge_initialized) {
pm_store_data_to_backup_ram(); pm_store_data_to_backup_ram();
} }
@ -151,7 +144,6 @@ void pm_deinit(void) {
stwlc38_deinit(); stwlc38_deinit();
drv->initialized = false; drv->initialized = false;
} }
pm_status_t pm_get_events(pm_event_t* event_flags) { pm_status_t pm_get_events(pm_event_t* event_flags) {
@ -228,7 +220,6 @@ pm_status_t pm_hibernate(void) {
// Whenever hibernation request fall through, request was rejected // Whenever hibernation request fall through, request was rejected
return PM_REQUEST_REJECTED; return PM_REQUEST_REJECTED;
} }
pm_status_t pm_turn_on(void) { pm_status_t pm_turn_on(void) {
@ -240,16 +231,16 @@ pm_status_t pm_turn_on(void) {
// Poll until at least single PMIC measurement is done // Poll until at least single PMIC measurement is done
uint32_t pmic_last_update_ms; uint32_t pmic_last_update_ms;
do{ do {
irq_key_t irq_key = irq_lock(); irq_key_t irq_key = irq_lock();
pmic_last_update_ms = drv->pmic_last_update_ms; pmic_last_update_ms = drv->pmic_last_update_ms;
irq_unlock(irq_key); irq_unlock(irq_key);
} while(pmic_last_update_ms == 0); } while (pmic_last_update_ms == 0);
// Check if device has enough power to startup // Check if device has enough power to startup
if(drv->pmic_data.usb_status == 0x0 && if (drv->pmic_data.usb_status == 0x0 &&
drv->pmic_data.vbat < PM_BATTERY_UNDERVOLT_RECOVERY_THR_V){ drv->pmic_data.vbat < PM_BATTERY_UNDERVOLT_RECOVERY_THR_V) {
return PM_REQUEST_REJECTED; return PM_REQUEST_REJECTED;
} }
drv->request_turn_on = true; drv->request_turn_on = true;
@ -350,22 +341,20 @@ pm_status_t pm_store_data_to_backup_ram() {
return PM_OK; return PM_OK;
} }
pm_status_t pm_wait_until_active(uint32_t timeout_ms){ pm_status_t pm_wait_until_active(uint32_t timeout_ms) {
pm_driver_t* drv = &g_pm; pm_driver_t* drv = &g_pm;
uint32_t expire_time = ticks_timeout(timeout_ms); uint32_t expire_time = ticks_timeout(timeout_ms);
while(1){ while (1) {
if (ticks_expired(expire_time)) {
if(ticks_expired(expire_time)){
// Timeout expired // Timeout expired
return PM_REQUEST_REJECTED; return PM_REQUEST_REJECTED;
} }
if((drv->state == PM_STATE_ACTIVE) || (drv->state == PM_STATE_POWER_SAVE)){ if ((drv->state == PM_STATE_ACTIVE) ||
(drv->state == PM_STATE_POWER_SAVE)) {
return PM_OK; return PM_OK;
} }
} }
return PM_OK; return PM_OK;
@ -396,8 +385,7 @@ pm_status_t pm_wakeup_flags_reset(void) {
return PM_OK; return PM_OK;
} }
pm_status_t pm_wakeup_flags_get(pm_wakeup_flags_t *flags) { pm_status_t pm_wakeup_flags_get(pm_wakeup_flags_t* flags) {
pm_driver_t* drv = &g_pm; pm_driver_t* drv = &g_pm;
if (!drv->initialized) { if (!drv->initialized) {
@ -408,10 +396,8 @@ pm_status_t pm_wakeup_flags_get(pm_wakeup_flags_t *flags) {
*flags = drv->wakeup_flags; *flags = drv->wakeup_flags;
irq_unlock(irq_key); irq_unlock(irq_key);
return PM_OK; return PM_OK;
} }
// Timer handlers // Timer handlers
static void pm_monitoring_timer_handler(void* context) { static void pm_monitoring_timer_handler(void* context) {
pm_monitor_power_sources(); pm_monitor_power_sources();

13
core/embed/sys/power_manager/stm32u5/power_monitoring.c
View File

@ -75,22 +75,20 @@ void pm_monitor_power_sources(void) {
// Fuel gauge not initialized yet, battery SoC not available, // Fuel gauge not initialized yet, battery SoC not available,
// Sample the battery data into the circular buffer, request new PMIC // Sample the battery data into the circular buffer, request new PMIC
if(!drv->fuel_gauge_initialized){ if (!drv->fuel_gauge_initialized) {
pm_battery_sampling(drv->pmic_data.vbat, drv->pmic_data.ibat, pm_battery_sampling(drv->pmic_data.vbat, drv->pmic_data.ibat,
drv->pmic_data.ntc_temp); drv->pmic_data.ntc_temp);
// Request fresh measurements // Request fresh measurements
npm1300_measure(pm_pmic_data_ready, NULL); npm1300_measure(pm_pmic_data_ready, NULL);
drv->pmic_measurement_ready = false; drv->pmic_measurement_ready = false;
return; return;
} }
fuel_gauge_update(&drv->fuel_gauge, drv->pmic_sampling_period_ms, fuel_gauge_update(&drv->fuel_gauge, drv->pmic_sampling_period_ms,
drv->pmic_data.vbat, drv->pmic_data.ibat, drv->pmic_data.vbat, drv->pmic_data.ibat,
drv->pmic_data.ntc_temp); drv->pmic_data.ntc_temp);
// Ceil the float soc to user friendly integer // Ceil the float soc to user friendly integer
uint8_t soc_ceiled_temp = (int)(drv->fuel_gauge.soc_latched * 100 + 0.999f); uint8_t soc_ceiled_temp = (int)(drv->fuel_gauge.soc_latched * 100 + 0.999f);
@ -117,7 +115,6 @@ void pm_monitor_power_sources(void) {
drv->pmic_measurement_ready = false; drv->pmic_measurement_ready = false;
drv->state_machine_stabilized = true; drv->state_machine_stabilized = true;
} }
// PMIC measurement callback // PMIC measurement callback
@ -125,7 +122,7 @@ void pm_pmic_data_ready(void* context, npm1300_report_t* report) {
pm_driver_t* drv = &g_pm; pm_driver_t* drv = &g_pm;
// Store measurement timestamp // Store measurement timestamp
if(drv->pmic_last_update_ms == 0) { if (drv->pmic_last_update_ms == 0) {
drv->pmic_sampling_period_ms = PM_BATTERY_SAMPLING_PERIOD_MS; drv->pmic_sampling_period_ms = PM_BATTERY_SAMPLING_PERIOD_MS;
} else { } else {
// Timeout, reset the last update timestamp // Timeout, reset the last update timestamp

19
core/embed/sys/power_manager/stm32u5/power_states.c
View File

@ -98,9 +98,7 @@ void pm_process_state_machine(void) {
// State handler implementations // State handler implementations
pm_internal_state_t pm_handle_state_hibernate(pm_driver_t* drv) { pm_internal_state_t pm_handle_state_hibernate(pm_driver_t* drv) {
if (drv->request_turn_on) { if (drv->request_turn_on) {
drv->request_turn_on = false; drv->request_turn_on = false;
return PM_STATE_POWER_SAVE; return PM_STATE_POWER_SAVE;
@ -124,7 +122,6 @@ pm_internal_state_t pm_handle_state_hibernate(pm_driver_t* drv) {
} }
pm_internal_state_t pm_handle_state_charging(pm_driver_t* drv) { pm_internal_state_t pm_handle_state_charging(pm_driver_t* drv) {
if (drv->request_turn_on) { if (drv->request_turn_on) {
drv->request_turn_on = false; drv->request_turn_on = false;
return PM_STATE_POWER_SAVE; return PM_STATE_POWER_SAVE;
@ -166,11 +163,10 @@ pm_internal_state_t pm_handle_state_startup_rejected(pm_driver_t* drv) {
} }
pm_internal_state_t pm_handle_state_shutting_down(pm_driver_t* drv) { pm_internal_state_t pm_handle_state_shutting_down(pm_driver_t* drv) {
// System is shutting down, but user can still hibernate the device early. // System is shutting down, but user can still hibernate the device early.
if (drv->request_hibernate) { if (drv->request_hibernate) {
drv->request_hibernate = false; drv->request_hibernate = false;
return PM_STATE_HIBERNATE; return PM_STATE_HIBERNATE;
} }
// Return to power save if external power or battery recovered // Return to power save if external power or battery recovered
@ -187,7 +183,6 @@ pm_internal_state_t pm_handle_state_shutting_down(pm_driver_t* drv) {
} }
pm_internal_state_t pm_handle_state_power_save(pm_driver_t* drv) { pm_internal_state_t pm_handle_state_power_save(pm_driver_t* drv) {
// Handle hibernate request // Handle hibernate request
if (drv->request_hibernate) { if (drv->request_hibernate) {
drv->request_hibernate = false; drv->request_hibernate = false;
@ -214,7 +209,6 @@ pm_internal_state_t pm_handle_state_power_save(pm_driver_t* drv) {
} }
pm_internal_state_t pm_handle_state_active(pm_driver_t* drv) { pm_internal_state_t pm_handle_state_active(pm_driver_t* drv) {
// Handle hibernate request // Handle hibernate request
if (drv->request_hibernate) { if (drv->request_hibernate) {
drv->request_hibernate = false; drv->request_hibernate = false;
@ -244,7 +238,6 @@ void pm_enter_hibernate(pm_driver_t* drv) {
// will try to hibernate immediately after reboot. // will try to hibernate immediately after reboot.
pm_store_data_to_backup_ram(); pm_store_data_to_backup_ram();
reboot_device(); reboot_device();
} }
void pm_enter_charging(pm_driver_t* drv) { void pm_enter_charging(pm_driver_t* drv) {
@ -254,7 +247,6 @@ void pm_enter_charging(pm_driver_t* drv) {
void pm_enter_suspend(pm_driver_t* drv) { void pm_enter_suspend(pm_driver_t* drv) {
PM_SET_EVENT(drv->event_flags, PM_EVENT_ENTERED_MODE_SUSPEND); PM_SET_EVENT(drv->event_flags, PM_EVENT_ENTERED_MODE_SUSPEND);
pm_control_suspend(); pm_control_suspend();
} }
void pm_enter_shutting_down(pm_driver_t* drv) { void pm_enter_shutting_down(pm_driver_t* drv) {
@ -275,15 +267,8 @@ void pm_enter_active(pm_driver_t* drv) {
PM_SET_EVENT(drv->event_flags, PM_EVENT_ENTERED_MODE_ACTIVE); PM_SET_EVENT(drv->event_flags, PM_EVENT_ENTERED_MODE_ACTIVE);
} }
void pm_exit_shutting_down(pm_driver_t* drv) { void pm_exit_shutting_down(pm_driver_t* drv) {
// Stop the shutdown timer // Stop the shutdown timer
systimer_unset(drv->shutdown_timer); systimer_unset(drv->shutdown_timer);
drv->shutdown_timer_elapsed = false; drv->shutdown_timer_elapsed = false;
} }