liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

FL-528 GUI: View, ViewDispather. Dolphin: first start. (#276)

Browse Source 
* GUI: view. Flooper-blooper fix compilation error.
* GUI: view and viewdispatcher bones
* GUI: view implementation, view models, view dispatcher
* GUI: view navigation, model refinement. Power: use view, view dispatcher.
* HAL Flash: proper page write. Dolphin: views. Power: views
* Dolphin: transition idle scree to Views
* Dolphin: input events on stats view. Format sources.
* HAL: flash erase. Dolphin: permanent state storage.
* Dolphin: first start welcome. HAL: flash operation status, errata 2.2.9 crutch.
This commit is contained in:
あく
2021-01-08 07:42:48 +03:00
committed by GitHub
parent d65e9b04ce
commit 1b78418f9f
33 changed files with 995 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
applications/power/power.c
View File

@@ -1,38 +1,33 @@
#include "power.h"
#include "power_views.h"
#include <flipper_v2.h>
#include <menu/menu.h>
#include <menu/menu_item.h>
#include <gui/gui.h>
#include <gui/widget.h>
#include <gui/view.h>
#include <gui/view_dispatcher.h>
#include <assets_icons.h>
#include <api-hal-power.h>
#include <cli/cli.h>
struct Power {
ViewDispatcher* view_dispatcher;
View* info_view;
Icon* usb_icon;
Widget* usb_widget;
Icon* battery_icon;
Widget* battery_widget;
Widget* widget;
ValueMutex* menu_vm;
Cli* cli;
MenuItem* menu;
float current_charger;
float current_gauge;
float voltage_charger;
float voltage_gauge;
uint32_t capacity_remaining;
uint32_t capacity_full;
float temperature_charger;
float temperature_gauge;
uint8_t charge;
};
void power_draw_usb_callback(Canvas* canvas, void* context) {
@@ -46,70 +41,31 @@ void power_draw_battery_callback(Canvas* canvas, void* context) {
Power* power = context;
canvas_draw_icon(canvas, 0, 0, power->battery_icon);
canvas_draw_box(canvas, 2, 2, (float)power->charge / 100 * 14, 4);
with_view_model(
power->info_view, (PowerInfoModel * model) {
canvas_draw_box(canvas, 2, 2, (float)model->charge / 100 * 14, 4);
});
}
void power_off_callback(void* context) {
void power_menu_off_callback(void* context) {
api_hal_power_off();
}
void power_enable_otg_callback(void* context) {
void power_menu_reset_callback(void* context) {
NVIC_SystemReset();
}
void power_menu_enable_otg_callback(void* context) {
api_hal_power_enable_otg();
}
void power_disable_otg_callback(void* context) {
void power_menu_disable_otg_callback(void* context) {
api_hal_power_disable_otg();
}
void power_info_callback(void* context) {
void power_menu_info_callback(void* context) {
Power* power = context;
widget_enabled_set(power->widget, true);
}
void power_draw_callback(Canvas* canvas, void* context) {
Power* power = context;
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 2, 10, "Power state:");
char buffer[64];
canvas_set_font(canvas, FontSecondary);
snprintf(
buffer,
64,
"Current: %ld/%ldmA",
(int32_t)(power->current_gauge * 1000),
(int32_t)(power->current_charger * 1000));
canvas_draw_str(canvas, 5, 22, buffer);
snprintf(
buffer,
64,
"Voltage: %ld/%ldmV",
(uint32_t)(power->voltage_gauge * 1000),
(uint32_t)(power->voltage_charger * 1000));
canvas_draw_str(canvas, 5, 32, buffer);
snprintf(buffer, 64, "Charge: %ld%%", (uint32_t)(power->charge));
canvas_draw_str(canvas, 5, 42, buffer);
snprintf(
buffer, 64, "Capacity: %ld of %ldmAh", power->capacity_remaining, power->capacity_full);
canvas_draw_str(canvas, 5, 52, buffer);
snprintf(
buffer,
64,
"Temperature: %ld/%ldC",
(uint32_t)(power->temperature_gauge),
(uint32_t)(power->temperature_charger));
canvas_draw_str(canvas, 5, 62, buffer);
}
void power_input_callback(InputEvent* event, void* context) {
Power* power = context;
if(!event->state || event->input != InputBack) return;
widget_enabled_set(power->widget, false);
view_dispatcher_switch_to_view(power->view_dispatcher, PowerViewInfo);
}
Power* power_alloc() {
@@ -122,26 +78,30 @@ Power* power_alloc() {
power->menu = menu_item_alloc_menu("Power", NULL);
menu_item_subitem_add(
power->menu, menu_item_alloc_function("Poweroff", NULL, power_off_callback, power));
power->menu, menu_item_alloc_function("Off", NULL, power_menu_off_callback, power));
menu_item_subitem_add(
power->menu, menu_item_alloc_function("Reset", NULL, power_menu_reset_callback, power));
menu_item_subitem_add(
power->menu,
menu_item_alloc_function("Enable OTG", NULL, power_enable_otg_callback, power));
menu_item_alloc_function("Enable OTG", NULL, power_menu_enable_otg_callback, power));
menu_item_subitem_add(
power->menu,
menu_item_alloc_function("Disable OTG", NULL, power_disable_otg_callback, power));
menu_item_alloc_function("Disable OTG", NULL, power_menu_disable_otg_callback, power));
menu_item_subitem_add(
power->menu, menu_item_alloc_function("Info", NULL, power_info_callback, power));
power->menu, menu_item_alloc_function("Info", NULL, power_menu_info_callback, power));
power->view_dispatcher = view_dispatcher_alloc();
power->info_view = view_alloc();
view_allocate_model(power->info_view, ViewModelTypeLockFree, sizeof(PowerInfoModel));
view_set_draw_callback(power->info_view, power_info_draw_callback);
view_set_previous_callback(power->info_view, power_info_back_callback);
view_dispatcher_add_view(power->view_dispatcher, PowerViewInfo, power->info_view);
power->usb_icon = assets_icons_get(I_USBConnected_15x8);
power->usb_widget = widget_alloc();
widget_set_width(power->usb_widget, icon_get_width(power->usb_icon));
widget_draw_callback_set(power->usb_widget, power_draw_usb_callback, power);
power->widget = widget_alloc();
widget_draw_callback_set(power->widget, power_draw_callback, power);
widget_input_callback_set(power->widget, power_input_callback, power);
widget_enabled_set(power->widget, false);
power->battery_icon = assets_icons_get(I_Battery_19x8);
power->battery_widget = widget_alloc();
widget_set_width(power->battery_widget, icon_get_width(power->battery_icon));
@@ -204,9 +164,9 @@ void power_task(void* p) {
}
Gui* gui = furi_open("gui");
gui_add_widget(gui, power->widget, GuiLayerFullscreen);
gui_add_widget(gui, power->usb_widget, GuiLayerStatusBarLeft);
gui_add_widget(gui, power->battery_widget, GuiLayerStatusBarRight);
view_dispatcher_attach_to_gui(power->view_dispatcher, gui, ViewDispatcherTypeFullscreen);
with_value_mutex(
power->menu_vm, (Menu * menu) { menu_item_add(menu, power->menu); });
@@ -221,16 +181,22 @@ void power_task(void* p) {
furiac_ready();
while(1) {
power->charge = api_hal_power_get_pct();
power->capacity_remaining = api_hal_power_get_battery_remaining_capacity();
power->capacity_full = api_hal_power_get_battery_full_capacity();
power->current_charger = api_hal_power_get_battery_current(ApiHalPowerICCharger);
power->current_gauge = api_hal_power_get_battery_current(ApiHalPowerICFuelGauge);
power->voltage_charger = api_hal_power_get_battery_voltage(ApiHalPowerICCharger);
power->voltage_gauge = api_hal_power_get_battery_voltage(ApiHalPowerICFuelGauge);
power->temperature_charger = api_hal_power_get_battery_temperature(ApiHalPowerICCharger);
power->temperature_gauge = api_hal_power_get_battery_temperature(ApiHalPowerICFuelGauge);
widget_update(power->widget);
with_view_model(
power->info_view, (PowerInfoModel * model) {
model->charge = api_hal_power_get_pct();
model->capacity_remaining = api_hal_power_get_battery_remaining_capacity();
model->capacity_full = api_hal_power_get_battery_full_capacity();
model->current_charger = api_hal_power_get_battery_current(ApiHalPowerICCharger);
model->current_gauge = api_hal_power_get_battery_current(ApiHalPowerICFuelGauge);
model->voltage_charger = api_hal_power_get_battery_voltage(ApiHalPowerICCharger);
model->voltage_gauge = api_hal_power_get_battery_voltage(ApiHalPowerICFuelGauge);
model->temperature_charger =
api_hal_power_get_battery_temperature(ApiHalPowerICCharger);
model->temperature_gauge =
api_hal_power_get_battery_temperature(ApiHalPowerICFuelGauge);
});
widget_update(power->battery_widget);
widget_enabled_set(power->usb_widget, api_hal_power_is_charging());
osDelay(1000);
}

38
applications/power/power_views.c Normal file
View File

@@ -0,0 +1,38 @@
#include "power_views.h"
void power_info_draw_callback(Canvas* canvas, void* context) {
PowerInfoModel* data = context;
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 2, 10, "Power state:");
char buffer[64];
canvas_set_font(canvas, FontSecondary);
snprintf(
buffer,
64,
"Current: %ld/%ldmA",
(int32_t)(data->current_gauge * 1000),
(int32_t)(data->current_charger * 1000));
canvas_draw_str(canvas, 5, 22, buffer);
snprintf(
buffer,
64,
"Voltage: %ld/%ldmV",
(uint32_t)(data->voltage_gauge * 1000),
(uint32_t)(data->voltage_charger * 1000));
canvas_draw_str(canvas, 5, 32, buffer);
snprintf(buffer, 64, "Charge: %ld%%", (uint32_t)(data->charge));
canvas_draw_str(canvas, 5, 42, buffer);
snprintf(buffer, 64, "Capacity: %ld of %ldmAh", data->capacity_remaining, data->capacity_full);
canvas_draw_str(canvas, 5, 52, buffer);
snprintf(
buffer,
64,
"Temperature: %ld/%ldC",
(uint32_t)(data->temperature_gauge),
(uint32_t)(data->temperature_charger));
canvas_draw_str(canvas, 5, 62, buffer);
}

31
applications/power/power_views.h Normal file
View File

@@ -0,0 +1,31 @@
#pragma once
#include <stdint.h>
#include <stdbool.h>
#include <gui/canvas.h>
#include <flipper_v2.h>
#include <gui/view.h>
typedef enum { PowerViewInfo } PowerView;
typedef struct {
float current_charger;
float current_gauge;
float voltage_charger;
float voltage_gauge;
uint32_t capacity_remaining;
uint32_t capacity_full;
float temperature_charger;
float temperature_gauge;
uint8_t charge;
} PowerInfoModel;
static uint32_t power_info_back_callback(void* context) {
return VIEW_NONE;
}
void power_info_draw_callback(Canvas* canvas, void* context);