Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-14 00:18:35 -07:00
Code Issues Packages Projects Releases Wiki Activity

[FL-3841] FuriEventLoop Pt.2 (#3703)

Browse Source 
* Abstract primitive type from main logic in FuriEventLoop
* Remove message_queue_i.h
* Add stream buffer support for event loop
* Add semaphore support for event loop
* Add temporary unit test workaround
* Make the linter happy
* Add mutex support for event loop
* Implement event subscription and unsubscription while the event loop is running
* Implement edge events
* Fix leftover logical errors
* Add event loop timer example application
* Implement flag-based edge trigger and one-shot mode
* Add event loop mutex example application
* Only notify the event loop if stream buffer is at or above its trigger level
* Reformat comments
* Add event loop stream buffer example application
* Add event loop multiple elements example application
* Improve event loop flag names
* Remove redundant signal handler as it is already handled by the event loop
* Refactor Power service, improve ViewHolder
* Use ViewHolder instead of ViewDispatcher in About app
* Enable ViewDispatcher queue on construction, deprecate view_dispatcher_enable_queue()
* Remove all invocations of view_dispatcher_enable_queue()
* Remove app-scened-template
* Remove missing library from target.json
* Port Accessor app to ViewHolder
* Make the linter happy
* Add example_view_holder application, update ViewHolder docs
* Add example_view_dispatcher application, update ViewDispatcher docs
* Replace FuriSemaphore with FuriApiLock, remove workaround delay
* Fix logical error
* Fix another logical error
* Use the sources directive to speed up compilation
* Use constant define macro
* Improve FuriEventLoop documentation
* Improve FuriEventLoop documentation once more
* Bump API Version
* Gui: remove redundant checks from ViewDispatcher
* Gui: remove dead ifs from ViewDispatcher

Co-authored-by: Silent <CookiePLMonster@users.noreply.github.com>
Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
MX
2024-08-10 14:32:27 +03:00
parent 1e5dd001fe
commit bf6c6c231f
104 changed files with 2099 additions and 1757 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
applications/services/power/power_cli.c
View File

@@ -17,13 +17,15 @@ void power_cli_off(Cli* cli, FuriString* args) {
void power_cli_reboot(Cli* cli, FuriString* args) {
UNUSED(cli);
UNUSED(args);
power_reboot(PowerBootModeNormal);
Power* power = furi_record_open(RECORD_POWER);
power_reboot(power, PowerBootModeNormal);
}
void power_cli_reboot2dfu(Cli* cli, FuriString* args) {
UNUSED(cli);
UNUSED(args);
power_reboot(PowerBootModeDfu);
Power* power = furi_record_open(RECORD_POWER);
power_reboot(power, PowerBootModeDfu);
}
void power_cli_5v(Cli* cli, FuriString* args) {

300
applications/services/power/power_service/power.c
View File

@@ -4,10 +4,18 @@
#include <furi.h>
#include <furi_hal.h>
#define POWER_OFF_TIMEOUT 90
#define TAG "Power"
#include <update_util/update_operation.h>
#include <notification/notification_messages.h>
void power_draw_battery_callback(Canvas* canvas, void* context) {
#define TAG "Power"
#define POWER_OFF_TIMEOUT_S (90U)
#define POWER_POLL_PERIOD_MS (1000UL)
#define POWER_VBUS_LOW_THRESHOLD (4.0f)
#define POWER_HEALTH_LOW_THRESHOLD (70U)
static void power_draw_battery_callback(Canvas* canvas, void* context) {
furi_assert(context);
Power* power = context;
canvas_draw_icon(canvas, 0, 0, &I_Battery_26x8);
@@ -219,6 +227,7 @@ void power_draw_battery_callback(Canvas* canvas, void* context) {
}
canvas_set_bitmap_mode(canvas, 0);
}
} else {
canvas_draw_box(canvas, 8, 3, 8, 2);
}
@@ -228,99 +237,61 @@ static ViewPort* power_battery_view_port_alloc(Power* power) {
ViewPort* battery_view_port = view_port_alloc();
view_port_set_width(battery_view_port, icon_get_width(&I_Battery_26x8));
view_port_draw_callback_set(battery_view_port, power_draw_battery_callback, power);
gui_add_view_port(power->gui, battery_view_port, GuiLayerStatusBarRight);
return battery_view_port;
}
Power* power_alloc(void) {
Power* power = malloc(sizeof(Power));
static bool power_update_info(Power* power) {
const PowerInfo info = {
.is_charging = furi_hal_power_is_charging(),
.gauge_is_ok = furi_hal_power_gauge_is_ok(),
.is_shutdown_requested = furi_hal_power_is_shutdown_requested(),
.charge = furi_hal_power_get_pct(),
.health = furi_hal_power_get_bat_health_pct(),
.capacity_remaining = furi_hal_power_get_battery_remaining_capacity(),
.capacity_full = furi_hal_power_get_battery_full_capacity(),
.current_charger = furi_hal_power_get_battery_current(FuriHalPowerICCharger),
.current_gauge = furi_hal_power_get_battery_current(FuriHalPowerICFuelGauge),
.voltage_battery_charge_limit = furi_hal_power_get_battery_charge_voltage_limit(),
.voltage_charger = furi_hal_power_get_battery_voltage(FuriHalPowerICCharger),
.voltage_gauge = furi_hal_power_get_battery_voltage(FuriHalPowerICFuelGauge),
.voltage_vbus = furi_hal_power_get_usb_voltage(),
.temperature_charger = furi_hal_power_get_battery_temperature(FuriHalPowerICCharger),
.temperature_gauge = furi_hal_power_get_battery_temperature(FuriHalPowerICFuelGauge),
};
// Records
power->notification = furi_record_open(RECORD_NOTIFICATION);
power->gui = furi_record_open(RECORD_GUI);
// Pubsub
power->event_pubsub = furi_pubsub_alloc();
// State initialization
power->state = PowerStateNotCharging;
power->battery_low = false;
power->power_off_timeout = POWER_OFF_TIMEOUT;
power->api_mtx = furi_mutex_alloc(FuriMutexTypeNormal);
// Gui
power->view_dispatcher = view_dispatcher_alloc();
power->power_off = power_off_alloc();
view_dispatcher_add_view(
power->view_dispatcher, PowerViewOff, power_off_get_view(power->power_off));
power->power_unplug_usb = power_unplug_usb_alloc();
view_dispatcher_add_view(
power->view_dispatcher,
PowerViewUnplugUsb,
power_unplug_usb_get_view(power->power_unplug_usb));
view_dispatcher_attach_to_gui(
power->view_dispatcher, power->gui, ViewDispatcherTypeFullscreen);
// Battery view port
power->battery_view_port = power_battery_view_port_alloc(power);
power->show_low_bat_level_message = true;
return power;
const bool need_refresh = (power->info.charge != info.charge) ||
(power->info.is_charging != info.is_charging);
power->info = info;
return need_refresh;
}
static void power_check_charging_state(Power* power) {
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
if(furi_hal_power_is_charging()) {
if((power->info.charge == 100) || (furi_hal_power_is_charging_done())) {
if(power->state != PowerStateCharged) {
notification_internal_message(power->notification, &sequence_charged);
notification_internal_message(notification, &sequence_charged);
power->state = PowerStateCharged;
power->event.type = PowerEventTypeFullyCharged;
furi_pubsub_publish(power->event_pubsub, &power->event);
}
} else {
if(power->state != PowerStateCharging) {
notification_internal_message(power->notification, &sequence_charging);
power->state = PowerStateCharging;
power->event.type = PowerEventTypeStartCharging;
furi_pubsub_publish(power->event_pubsub, &power->event);
}
}
} else {
if(power->state != PowerStateNotCharging) {
notification_internal_message(power->notification, &sequence_not_charging);
power->state = PowerStateNotCharging;
power->event.type = PowerEventTypeStopCharging;
} else if(power->state != PowerStateCharging) {
notification_internal_message(notification, &sequence_charging);
power->state = PowerStateCharging;
power->event.type = PowerEventTypeStartCharging;
furi_pubsub_publish(power->event_pubsub, &power->event);
}
} else if(power->state != PowerStateNotCharging) {
notification_internal_message(notification, &sequence_not_charging);
power->state = PowerStateNotCharging;
power->event.type = PowerEventTypeStopCharging;
furi_pubsub_publish(power->event_pubsub, &power->event);
}
}
static bool power_update_info(Power* power) {
PowerInfo info;
info.is_charging = furi_hal_power_is_charging();
info.gauge_is_ok = furi_hal_power_gauge_is_ok();
info.is_shutdown_requested = furi_hal_power_is_shutdown_requested();
info.charge = furi_hal_power_get_pct();
info.health = furi_hal_power_get_bat_health_pct();
info.capacity_remaining = furi_hal_power_get_battery_remaining_capacity();
info.capacity_full = furi_hal_power_get_battery_full_capacity();
info.current_charger = furi_hal_power_get_battery_current(FuriHalPowerICCharger);
info.current_gauge = furi_hal_power_get_battery_current(FuriHalPowerICFuelGauge);
info.voltage_battery_charge_limit = furi_hal_power_get_battery_charge_voltage_limit();
info.voltage_charger = furi_hal_power_get_battery_voltage(FuriHalPowerICCharger);
info.voltage_gauge = furi_hal_power_get_battery_voltage(FuriHalPowerICFuelGauge);
info.voltage_vbus = furi_hal_power_get_usb_voltage();
info.temperature_charger = furi_hal_power_get_battery_temperature(FuriHalPowerICCharger);
info.temperature_gauge = furi_hal_power_get_battery_temperature(FuriHalPowerICFuelGauge);
furi_mutex_acquire(power->api_mtx, FuriWaitForever);
bool need_refresh = power->info.charge != info.charge;
need_refresh |= power->info.is_charging != info.is_charging;
power->info = info;
furi_mutex_release(power->api_mtx);
return need_refresh;
furi_record_close(RECORD_NOTIFICATION);
}
static void power_check_low_battery(Power* power) {
@@ -329,40 +300,41 @@ static void power_check_low_battery(Power* power) {
}
// Check battery charge and vbus voltage
if((power->info.is_shutdown_requested) && (power->info.voltage_vbus < 4.0f) &&
power->show_low_bat_level_message) {
if((power->info.is_shutdown_requested) &&
(power->info.voltage_vbus < POWER_VBUS_LOW_THRESHOLD) && power->show_battery_low_warning) {
if(!power->battery_low) {
view_dispatcher_send_to_front(power->view_dispatcher);
view_dispatcher_switch_to_view(power->view_dispatcher, PowerViewOff);
view_holder_send_to_front(power->view_holder);
view_holder_set_view(power->view_holder, power_off_get_view(power->view_power_off));
}
power->battery_low = true;
} else {
if(power->battery_low) {
view_dispatcher_switch_to_view(power->view_dispatcher, VIEW_NONE);
power->power_off_timeout = POWER_OFF_TIMEOUT;
// view_dispatcher_switch_to_view(power->view_dispatcher, VIEW_NONE);
view_holder_set_view(power->view_holder, NULL);
power->power_off_timeout = POWER_OFF_TIMEOUT_S;
}
power->battery_low = false;
}
// If battery low, update view and switch off power after timeout
if(power->battery_low) {
PowerOffResponse response = power_off_get_response(power->power_off);
PowerOffResponse response = power_off_get_response(power->view_power_off);
if(response == PowerOffResponseDefault) {
if(power->power_off_timeout) {
power_off_set_time_left(power->power_off, power->power_off_timeout--);
power_off_set_time_left(power->view_power_off, power->power_off_timeout--);
} else {
power_off(power);
}
} else if(response == PowerOffResponseOk) {
power_off(power);
} else if(response == PowerOffResponseHide) {
view_dispatcher_switch_to_view(power->view_dispatcher, VIEW_NONE);
view_holder_set_view(power->view_holder, NULL);
if(power->power_off_timeout) {
power_off_set_time_left(power->power_off, power->power_off_timeout--);
power_off_set_time_left(power->view_power_off, power->power_off_timeout--);
} else {
power_off(power);
}
} else if(response == PowerOffResponseCancel) {
view_dispatcher_switch_to_view(power->view_dispatcher, VIEW_NONE);
view_holder_set_view(power->view_holder, NULL);
}
}
}
@@ -384,6 +356,121 @@ void power_trigger_ui_update(Power* power) {
view_port_update(power->battery_view_port);
}
static void power_handle_shutdown(Power* power) {
furi_hal_power_off();
// Notify user if USB is plugged
view_holder_send_to_front(power->view_holder);
view_holder_set_view(
power->view_holder, power_unplug_usb_get_view(power->view_power_unplug_usb));
furi_delay_ms(100);
furi_halt("Disconnect USB for safe shutdown");
}
static void power_handle_reboot(PowerBootMode mode) {
if(mode == PowerBootModeNormal) {
update_operation_disarm();
} else if(mode == PowerBootModeDfu) {
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeDfu);
} else if(mode == PowerBootModeUpdateStart) {
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePreUpdate);
} else {
furi_crash();
}
furi_hal_power_reset();
}
static bool power_message_callback(FuriEventLoopObject* object, void* context) {
furi_assert(context);
Power* power = context;
furi_assert(object == power->message_queue);
PowerMessage msg;
furi_check(furi_message_queue_get(power->message_queue, &msg, 0) == FuriStatusOk);
switch(msg.type) {
case PowerMessageTypeShutdown:
power_handle_shutdown(power);
break;
case PowerMessageTypeReboot:
power_handle_reboot(msg.boot_mode);
break;
case PowerMessageTypeGetInfo:
*msg.power_info = power->info;
break;
case PowerMessageTypeIsBatteryHealthy:
*msg.bool_param = power->info.health > POWER_HEALTH_LOW_THRESHOLD;
break;
case PowerMessageTypeShowBatteryLowWarning:
power->show_battery_low_warning = *msg.bool_param;
break;
default:
furi_crash();
}
if(msg.lock) {
api_lock_unlock(msg.lock);
}
return true;
}
static void power_tick_callback(void* context) {
furi_assert(context);
Power* power = context;
// Update data from gauge and charger
const bool need_refresh = power_update_info(power);
// Check low battery level
power_check_low_battery(power);
// Check and notify about charging state
power_check_charging_state(power);
// Check and notify about battery level change
power_check_battery_level_change(power);
// Update battery view port
if(need_refresh) {
view_port_update(power->battery_view_port);
}
// Check OTG status and disable it in case of fault
if(furi_hal_power_is_otg_enabled()) {
furi_hal_power_check_otg_status();
}
}
static Power* power_alloc(void) {
Power* power = malloc(sizeof(Power));
// Pubsub
power->event_pubsub = furi_pubsub_alloc();
// State initialization
power->power_off_timeout = POWER_OFF_TIMEOUT_S;
power->show_battery_low_warning = true;
// Gui
Gui* gui = furi_record_open(RECORD_GUI);
power->view_holder = view_holder_alloc();
power->view_power_off = power_off_alloc();
power->view_power_unplug_usb = power_unplug_usb_alloc();
view_holder_attach_to_gui(power->view_holder, gui);
// Battery view port
power->battery_view_port = power_battery_view_port_alloc(power);
gui_add_view_port(gui, power->battery_view_port, GuiLayerStatusBarRight);
// Event loop
power->event_loop = furi_event_loop_alloc();
power->message_queue = furi_message_queue_alloc(4, sizeof(PowerMessage));
furi_event_loop_subscribe_message_queue(
power->event_loop,
power->message_queue,
FuriEventLoopEventIn,
power_message_callback,
power);
furi_event_loop_tick_set(power->event_loop, 1000, power_tick_callback, power);
return power;
}
int32_t power_srv(void* p) {
UNUSED(p);
@@ -396,40 +483,9 @@ int32_t power_srv(void* p) {
Power* power = power_alloc();
power_update_info(power);
furi_record_create(RECORD_POWER, power);
DesktopSettings* settings = malloc(sizeof(DesktopSettings));
desktop_settings_load(settings);
power->displayBatteryPercentage = settings->displayBatteryPercentage;
free(settings);
while(1) {
// Update data from gauge and charger
bool need_refresh = power_update_info(power);
// Check low battery level
power_check_low_battery(power);
// Check and notify about charging state
power_check_charging_state(power);
// Check and notify about battery level change
power_check_battery_level_change(power);
// Update battery view port
if(need_refresh) {
view_port_update(power->battery_view_port);
}
// Check OTG status and disable it in case of fault
if(furi_hal_power_is_otg_enabled()) {
furi_hal_power_check_otg_status();
}
furi_delay_ms(1000);
}
furi_crash("That was unexpected");
furi_event_loop_run(power->event_loop);
return 0;
}

5
applications/services/power/power_service/power.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include <stdint.h>
#include <core/pubsub.h>
#include <stdbool.h>
#include <core/pubsub.h>
#ifdef __cplusplus
extern "C" {
#endif
@@ -65,7 +66,7 @@ void power_off(Power* power);
*
* @param mode PowerBootMode
*/
void power_reboot(PowerBootMode mode);
void power_reboot(Power* power, PowerBootMode mode);
/** Get power info
*

76
applications/services/power/power_service/power_api.c
View File

@@ -1,41 +1,39 @@
#include "power_i.h"
#include <furi.h>
#include <furi_hal.h>
#include <update_util/update_operation.h>
void power_off(Power* power) {
furi_check(power);
furi_hal_power_off();
// Notify user if USB is plugged
view_dispatcher_send_to_front(power->view_dispatcher);
view_dispatcher_switch_to_view(power->view_dispatcher, PowerViewUnplugUsb);
furi_delay_ms(100);
furi_halt("Disconnect USB for safe shutdown");
PowerMessage msg = {
.type = PowerMessageTypeShutdown,
};
furi_check(
furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
}
void power_reboot(PowerBootMode mode) {
if(mode == PowerBootModeNormal) {
update_operation_disarm();
} else if(mode == PowerBootModeDfu) {
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModeDfu);
} else if(mode == PowerBootModeUpdateStart) {
furi_hal_rtc_set_boot_mode(FuriHalRtcBootModePreUpdate);
} else {
furi_crash();
}
void power_reboot(Power* power, PowerBootMode mode) {
PowerMessage msg = {
.type = PowerMessageTypeReboot,
.boot_mode = mode,
};
furi_hal_power_reset();
furi_check(
furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
}
void power_get_info(Power* power, PowerInfo* info) {
furi_check(power);
furi_check(info);
furi_mutex_acquire(power->api_mtx, FuriWaitForever);
memcpy(info, &power->info, sizeof(power->info));
furi_mutex_release(power->api_mtx);
PowerMessage msg = {
.type = PowerMessageTypeGetInfo,
.power_info = info,
.lock = api_lock_alloc_locked(),
};
furi_check(
furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
api_lock_wait_unlock_and_free(msg.lock);
}
FuriPubSub* power_get_pubsub(Power* power) {
@@ -45,16 +43,30 @@ FuriPubSub* power_get_pubsub(Power* power) {
bool power_is_battery_healthy(Power* power) {
furi_check(power);
bool is_healthy = false;
furi_mutex_acquire(power->api_mtx, FuriWaitForever);
is_healthy = power->info.health > POWER_BATTERY_HEALTHY_LEVEL;
furi_mutex_release(power->api_mtx);
return is_healthy;
bool ret = false;
PowerMessage msg = {
.type = PowerMessageTypeIsBatteryHealthy,
.lock = api_lock_alloc_locked(),
.bool_param = &ret,
};
furi_check(
furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
api_lock_wait_unlock_and_free(msg.lock);
return ret;
}
void power_enable_low_battery_level_notification(Power* power, bool enable) {
furi_check(power);
furi_mutex_acquire(power->api_mtx, FuriWaitForever);
power->show_low_bat_level_message = enable;
furi_mutex_release(power->api_mtx);
PowerMessage msg = {
.type = PowerMessageTypeShowBatteryLowWarning,
.bool_param = &enable,
};
furi_check(
furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
}

46
applications/services/power/power_service/power_i.h
View File

@@ -2,19 +2,15 @@
#include "power.h"
#include <stdint.h>
#include <gui/view_dispatcher.h>
#include <gui/gui.h>
#include <gui/view_holder.h>
#include <toolbox/api_lock.h>
#include <assets_icons.h>
#include <gui/modules/popup.h>
#include "views/power_off.h"
#include "views/power_unplug_usb.h"
#include <notification/notification_messages.h>
#define POWER_BATTERY_HEALTHY_LEVEL 70
typedef enum {
PowerStateNotCharging,
PowerStateCharging,
@@ -22,29 +18,45 @@ typedef enum {
} PowerState;
struct Power {
ViewDispatcher* view_dispatcher;
PowerOff* power_off;
PowerUnplugUsb* power_unplug_usb;
ViewHolder* view_holder;
FuriPubSub* event_pubsub;
FuriEventLoop* event_loop;
FuriMessageQueue* message_queue;
ViewPort* battery_view_port;
Gui* gui;
NotificationApp* notification;
FuriPubSub* event_pubsub;
PowerEvent event;
PowerOff* view_power_off;
PowerUnplugUsb* view_power_unplug_usb;
PowerEvent event;
PowerState state;
PowerInfo info;
bool battery_low;
bool show_low_bat_level_message;
bool show_battery_low_warning;
uint8_t displayBatteryPercentage;
uint8_t battery_level;
uint8_t power_off_timeout;
FuriMutex* api_mtx;
};
typedef enum {
PowerViewOff,
PowerViewUnplugUsb,
} PowerView;
typedef enum {
PowerMessageTypeShutdown,
PowerMessageTypeReboot,
PowerMessageTypeGetInfo,
PowerMessageTypeIsBatteryHealthy,
PowerMessageTypeShowBatteryLowWarning,
} PowerMessageType;
typedef struct {
PowerMessageType type;
union {
PowerBootMode boot_mode;
PowerInfo* power_info;
bool* bool_param;
};
FuriApiLock lock;
} PowerMessage;