From 83065919978ebc5b517cc2880b2fa006a292e80b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Jo=C5=84ski?= Date: Tue, 9 Nov 2021 14:39:41 +0100 Subject: [PATCH] [BH-1030] Frontlight ramp Frontlight ramp --- .../BacklightHandlerCommon.cpp | 38 ++---- .../BacklightHandlerCommon.hpp | 10 +- .../screen-light-control/ControlFunctions.cpp | 3 + .../ScreenLightControlParameters.cpp | 6 + .../ScreenLightControlParameters.hpp | 17 +++ .../ScreenLightControlMessage.hpp | 15 +++ .../alarms/src/actions/FrontlightAction.cpp | 7 -- .../advanced/FrontlightListItemProvider.cpp | 8 +- .../models/advanced/FrontlightModel.cpp | 4 +- .../BellHybrid/services/evtmgr/CMakeLists.txt | 1 + .../services/evtmgr/EventManager.cpp | 6 + .../backlight-handler/BacklightHandler.cpp | 99 +++++++++++++-- .../backlight-handler/BacklightHandler.hpp | 16 +++ .../ScreenLightControl.cpp | 114 +++++++++--------- .../ScreenLightControl.hpp | 34 ++++-- .../backlight-handler/BacklightHandler.cpp | 35 +++++- .../include/evtmgr/BacklightHandler.hpp | 2 +- 17 files changed, 286 insertions(+), 129 deletions(-) diff --git a/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp index 3af02aad7aa631a16fe25cca5afaff7af74f1f5c..03f3bea40a903b8d70d09bafa8a97d06e76cfbb2 100644 --- a/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp +++ b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.cpp @@ -17,40 +17,16 @@ namespace backlight HandlerCommon::HandlerCommon(std::shared_ptr settings, std::shared_ptr screenLightController, - sys::Service *parent) + sys::Service *parent, + sys::timer::TimerCallback &&screenLightTimerCallback) : settings{std::move(settings)}, screenLightController{std::move(screenLightController)}, - screenLightTimer{std::make_shared(sys::TimerFactory::createSingleShotTimer( - parent, timers::screenLightTimerName, timers::screenLightTimerTimeout, [this](sys::Timer &t) { - if (getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic && - this->screenLightController->isLightOn()) { - this->screenLightController->processRequest(screen_light_control::Action::turnOff); - } - }))} + screenLightTimer{std::make_shared( + sys::TimerFactory::createSingleShotTimer(parent, + timers::screenLightTimerName, + timers::screenLightTimerTimeout, + std::move(screenLightTimerCallback)))} {} - void HandlerCommon::init() - { - using namespace screen_light_control; - settings->registerValueChange(settings::Brightness::brightnessLevel, [&](const std::string &value) { - ManualModeParameters params{utils::getNumericValue(value)}; - screenLightController->processRequest(Action::setManualModeBrightness, Parameters(params)); - }); - - settings->registerValueChange(settings::Brightness::autoMode, [&]([[maybe_unused]] const std::string &value) { - const auto action = getScreenAutoModeState() == ScreenLightMode::Automatic ? Action::enableAutomaticMode - : Action::disableAutomaticMode; - screenLightController->processRequest(action); - }); - - settings->registerValueChange(settings::Brightness::state, [&]([[maybe_unused]] const std::string &value) { - const auto action = getScreenLightState() ? Action::turnOn : Action::turnOff; - if (action == Action::turnOn) { - onScreenLightTurnedOn(); - } - screenLightController->processRequest(action); - }); - } - auto HandlerCommon::getValue(const std::string &path) const -> std::string { return settings->getValue(path); diff --git a/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp index e58143e997d9e91dc7ff2a16c8468d0edec0baeb..05457b739f5331df7d597d648e4a2288355a653b 100644 --- a/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp +++ b/module-services/service-evtmgr/backlight-handler/BacklightHandlerCommon.hpp @@ -21,10 +21,11 @@ namespace backlight public: HandlerCommon(std::shared_ptr settings, std::shared_ptr screenLightController, - sys::Service *parent); + sys::Service *parent, + sys::timer::TimerCallback &&screenLightTimerCallback); /// initialise in InitHandler when Service is ready - void init(); + virtual void init() = 0; /// Process request of the screen light control /// @screen_light_control::Action an action to perform @@ -39,6 +40,7 @@ namespace backlight private: virtual void onScreenLightTurnedOn() = 0; + protected: std::shared_ptr settings; std::shared_ptr screenLightController; @@ -51,8 +53,8 @@ namespace backlight { return screenLightController; } - void handleScreenLightSettings(screen_light_control::Action action, - const screen_light_control::Parameters ¶ms); + virtual void handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms); void handleScreenLightRefresh(); protected: diff --git a/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp b/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp index 3ea448c271136c8003187410062fc765ed23b0b4..138c3cd00cea73e5675523810e83caef61c47724 100644 --- a/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp +++ b/module-services/service-evtmgr/screen-light-control/ControlFunctions.cpp @@ -60,6 +60,9 @@ namespace screen_light_control::functions rampTargetReached = true; } } + else { + rampTargetReached = true; + } } return rampState; diff --git a/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.cpp b/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.cpp index d0ae1f17c2f5a4fc05f9bf39a0b42e6d76e1f3ba..d3abcd08ed6c4ab9b287c9759adf111748580b37 100644 --- a/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.cpp +++ b/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.cpp @@ -24,4 +24,10 @@ namespace screen_light_control Expects(hasLinearProgressModeParams()); return linearProgressModeParams.value(); } + + auto Parameters::getConstLinearProgressModeParams() const noexcept -> const ConstLinearProgressModeParameters & + { + Expects(hasConstLinearProgressModeParams()); + return constLinearProgressModeParams.value(); + } } // namespace screen_light_control diff --git a/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.hpp b/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.hpp index ecadd82ba67dd3b34fed7bc24bb591e3cbfff030..89d3aed382a1560a56f32e094d1dde152662fc71 100644 --- a/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.hpp +++ b/module-services/service-evtmgr/screen-light-control/ScreenLightControlParameters.hpp @@ -60,11 +60,17 @@ namespace screen_light_control float brightnessHysteresis = 0.0f; }; + struct ConstLinearProgressModeParameters + { + float targetBrightness = 0.0f; + }; + class Parameters { std::optional manualModeParams; std::optional autoModeParams; std::optional linearProgressModeParams; + std::optional constLinearProgressModeParams; public: Parameters() = default; @@ -77,6 +83,9 @@ namespace screen_light_control explicit Parameters(const LinearProgressModeParameters &autoModeParams) : linearProgressModeParams{autoModeParams} {} + explicit Parameters(const ConstLinearProgressModeParameters &autoModeParams) + : constLinearProgressModeParams{autoModeParams} + {} [[nodiscard]] bool hasManualModeParams() const noexcept { @@ -98,5 +107,13 @@ namespace screen_light_control } [[nodiscard]] auto getLinearProgressModeParams() const noexcept -> const LinearProgressModeParameters &; + + [[nodiscard]] bool hasConstLinearProgressModeParams() const noexcept + { + return constLinearProgressModeParams.has_value(); + } + + [[nodiscard]] auto getConstLinearProgressModeParams() const noexcept + -> const ConstLinearProgressModeParameters &; }; } // namespace screen_light_control diff --git a/module-services/service-evtmgr/service-evtmgr/ScreenLightControlMessage.hpp b/module-services/service-evtmgr/service-evtmgr/ScreenLightControlMessage.hpp index 74298116c1df00e7153360a433f232782597068a..cbaa2fe114076b0bcafefc6113072253a2a85f47 100644 --- a/module-services/service-evtmgr/service-evtmgr/ScreenLightControlMessage.hpp +++ b/module-services/service-evtmgr/service-evtmgr/ScreenLightControlMessage.hpp @@ -80,6 +80,21 @@ namespace sevm } }; + class ScreenLightSetConstLinearModeParams : public ScreenLightControlMessage + { + screen_light_control::ConstLinearProgressModeParameters params; + + public: + explicit ScreenLightSetConstLinearModeParams(screen_light_control::ConstLinearProgressModeParameters params) + : ScreenLightControlMessage(screen_light_control::Action::setAutomaticModeParameters), params{params} + {} + + [[nodiscard]] auto getParams() const noexcept -> screen_light_control::ConstLinearProgressModeParameters + { + return params; + } + }; + class ScreenLightControlRequestParameters : public sys::DataMessage { public: diff --git a/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp b/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp index dd6a86f4359ce87da6e82b713ea3003cf044d5d5..f443dd7a7f842941e262f165fb225ac1f3df1fd7 100644 --- a/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp +++ b/products/BellHybrid/alarms/src/actions/FrontlightAction.cpp @@ -73,10 +73,6 @@ namespace alarms bool ManualFrontlightAction::execute() { - service.bus.sendUnicast( - std::make_shared(screen_light_control::Action::disableAutomaticMode), - service::name::evt_manager); - auto params = prepareParameters(); service.bus.sendUnicast(std::make_shared( screen_light_control::Action::turnOn, screen_light_control::Parameters{params}), @@ -107,9 +103,6 @@ namespace alarms const auto params = prepareParameters(); service.bus.sendUnicast(std::make_shared(params), service::name::evt_manager); - service.bus.sendUnicast( - std::make_shared(screen_light_control::Action::enableAutomaticMode), - service::name::evt_manager); service.bus.sendUnicast(std::make_shared(screen_light_control::Action::turnOn), service::name::evt_manager); return true; diff --git a/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightListItemProvider.cpp b/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightListItemProvider.cpp index 4e3ec461411673eeabc5a61bbf1f2148afb97bb5..d65ff60f234e9e70dcbd08649232a2b5864d46e9 100644 --- a/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightListItemProvider.cpp +++ b/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightListItemProvider.cpp @@ -34,10 +34,10 @@ namespace app::bell_settings auto mode = new gui::UTF8ListItem(model.getModeModel(), gui::UTF8Spinner::Range{modeOnDemandsStr, modeAutoStr}, utils::translate("app_bell_settings_frontlight_mode_top_message")); - mode->setOnValueChanged([this, modeAutoStr](const auto &val) { - model.setMode(val == modeAutoStr ? screen_light_control::ScreenLightMode::Automatic - : screen_light_control::ScreenLightMode::Manual); - }); + mode->onExit = [this, mode, modeAutoStr]() { + model.setMode(mode->getCurrentValue() == modeAutoStr ? screen_light_control::ScreenLightMode::Automatic + : screen_light_control::ScreenLightMode::Manual); + }; internalData.emplace_back(mode); } FrontlightListItemProvider::FrontlightListItemProvider(AbstractFrontlightModel &model) : model{model} diff --git a/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightModel.cpp b/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightModel.cpp index 203187d98582f65ab785ece939f4579348b2d87e..fd8155aa8e662272ca93cdc6cd5fb9a4c4325deb 100644 --- a/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightModel.cpp +++ b/products/BellHybrid/apps/application-bell-settings/models/advanced/FrontlightModel.cpp @@ -68,8 +68,8 @@ namespace app::bell_settings } void FrontlightModel::setBrightness(Brightness value) { - screen_light_control::ManualModeParameters parameters{fixedValToPercentage(value)}; - app->bus.sendUnicast(std::make_shared(parameters), + screen_light_control::ConstLinearProgressModeParameters parameters{fixedValToPercentage(value)}; + app->bus.sendUnicast(std::make_shared(parameters), service::name::evt_manager); } gui::AbstractSettingsModel &FrontlightModel::getBrightnessModel() diff --git a/products/BellHybrid/services/evtmgr/CMakeLists.txt b/products/BellHybrid/services/evtmgr/CMakeLists.txt index a4045e114e082517ada800a93d2404b7281b8c6a..19d169d63a7b9449da1d9a96383e68c439e6404f 100644 --- a/products/BellHybrid/services/evtmgr/CMakeLists.txt +++ b/products/BellHybrid/services/evtmgr/CMakeLists.txt @@ -42,6 +42,7 @@ target_link_libraries(evtmgr keymap module-bsp module-utils + module-sys service-evtmgr bell::appmgr sys diff --git a/products/BellHybrid/services/evtmgr/EventManager.cpp b/products/BellHybrid/services/evtmgr/EventManager.cpp index d1261e0e05b34fc43234ccf1f016a759cbb9c22e..92f843d1d156991758b57948d6b87d3bdcc8165c 100644 --- a/products/BellHybrid/services/evtmgr/EventManager.cpp +++ b/products/BellHybrid/services/evtmgr/EventManager.cpp @@ -98,6 +98,12 @@ void EventManager::initProductEvents() return sys::msgHandled(); }); + connect(typeid(sevm::ScreenLightSetConstLinearModeParams), [&](sys::Message *msgl) { + auto *m = static_cast(msgl); + backlightHandler.processScreenRequest(m->getAction(), screen_light_control::Parameters(m->getParams())); + return sys::msgHandled(); + }); + connect(sevm::ScreenLightControlRequestParameters(), [&](sys::Message *msgl) { screen_light_control::ManualModeParameters params = {backlightHandler.getScreenBrightnessValue()}; auto msg = std::make_shared( diff --git a/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp b/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp index 75fde7b93230f0a755927d7d1431976a2492c872..ae8ae5588259c0aa8087b1856a541e632e16a011 100644 --- a/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp +++ b/products/BellHybrid/services/evtmgr/backlight-handler/BacklightHandler.cpp @@ -4,11 +4,12 @@ #include #include - +#include #include #include #include +#include namespace backlight { @@ -19,10 +20,29 @@ namespace backlight } // namespace timers Handler::Handler(std::shared_ptr settings, sys::Service *parent) - : HandlerCommon( - std::move(settings), std::make_shared(parent), parent) + : HandlerCommon(std::move(settings), + std::make_shared(parent), + parent, + [this](sys::Timer &t) { + if (this->screenLightController->isLightOn()) { + this->screenLightController->processRequest(screen_light_control::Action::turnOff); + } + }) {} + void Handler::init() + { + using namespace screen_light_control; + settings->registerValueChange(settings::Brightness::brightnessLevel, [&](const std::string &value) { + ConstLinearProgressModeParameters params{utils::getNumericValue(value)}; + screenLightController->processRequest(Action::setAutomaticModeParameters, Parameters(params)); + }); + + settings->registerValueChange(settings::Brightness::autoMode, [&](const std::string &value) { + onDemandModeOn = utils::getNumericValue(value); + }); + } + void Handler::handleKeyPressed([[maybe_unused]] int key) { handleScreenLightRefresh(key); @@ -32,16 +52,26 @@ namespace backlight { auto controller = getScreenLightControl(); auto timer = getScreenLightTimer(); - if (!controller->isLightOn() && (key == static_cast(KeyMap::Frontlight))) { - controller->processRequest(screen_light_control::Action::turnOn); - timer->restart(timers::screenLightTimerTimeout); - } - else if (controller->isLightOn()) { - if (controller->isAutoModeOn() || key == static_cast(KeyMap::Frontlight)) { + + if (key == static_cast(KeyMap::Frontlight)) { + if (controller->isLightOn()) { + setKeyPressedModeFrontlightOff(); controller->processRequest(screen_light_control::Action::turnOff); timer->stop(); } else { + setKeyPressedModeFrontlightOn(); + controller->processRequest(screen_light_control::Action::turnOn); + timer->restart(onDemandModeOn ? timers::screenLightTimerTimeout : timers::screenLightTimerHoldTimeout); + } + } + else { + if (controller->isLightOn()) { + timer->restart(timers::screenLightTimerHoldTimeout); + } + else if (!onDemandModeOn) { + setKeyPressedModeFrontlightOn(); + controller->processRequest(screen_light_control::Action::turnOn); timer->restart(timers::screenLightTimerHoldTimeout); } } @@ -54,10 +84,59 @@ namespace backlight getScreenLightControl()->processRequest(action, params); } + void Handler::handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms) + { + switch (action) { + case screen_light_control::Action::turnOn: + if (params.hasManualModeParams()) { + auto timer = getScreenLightTimer(); + timer->stop(); + backlightMode = BacklightMode::WithoutTimer; + } + break; + case screen_light_control::Action::setAutomaticModeParameters: + if (params.hasConstLinearProgressModeParams()) { + backlightMode = BacklightMode::WithTimer; + setValue(settings::Brightness::brightnessLevel, + utils::to_string(params.getConstLinearProgressModeParams().targetBrightness)); + } + else if (params.hasLinearProgressModeParams()) { + backlightMode = BacklightMode::WithoutTimer; + } + break; + case screen_light_control::Action::enableAutomaticMode: + onDemandModeOn = false; + break; + case screen_light_control::Action::disableAutomaticMode: + onDemandModeOn = true; + break; + default: + break; + } + + HandlerCommon::handleScreenLightSettings(action, params); + } + void Handler::onScreenLightTurnedOn() { - if (!getScreenLightControl()->isAutoModeOn()) { + if (backlightMode == BacklightMode::WithTimer) { startScreenLightTimer(); } } + + void Handler::setKeyPressedModeFrontlightOn() + { + using namespace screen_light_control; + auto brightnessLevel = utils::getNumericValue(getValue(settings::Brightness::brightnessLevel)); + screen_light_control::ConstLinearProgressModeParameters params{brightnessLevel}; + screenLightController->processRequest(Action::setAutomaticModeParameters, Parameters(params)); + } + + void Handler::setKeyPressedModeFrontlightOff() + { + using namespace screen_light_control; + screenLightController->processRequest(Action::setAutomaticModeParameters, + Parameters(screen_light_control::ConstLinearProgressModeParameters{0})); + } } // namespace backlight diff --git a/products/BellHybrid/services/evtmgr/include/evtmgr/backlight-handler/BacklightHandler.hpp b/products/BellHybrid/services/evtmgr/include/evtmgr/backlight-handler/BacklightHandler.hpp index 4b13f7327b5e70211e2517aee24d43d934b0618f..0bf750978ab049f2662cfce5f530cca839618167 100644 --- a/products/BellHybrid/services/evtmgr/include/evtmgr/backlight-handler/BacklightHandler.hpp +++ b/products/BellHybrid/services/evtmgr/include/evtmgr/backlight-handler/BacklightHandler.hpp @@ -16,20 +16,36 @@ namespace settings namespace backlight { + enum class BacklightMode + { + WithTimer, + WithoutTimer + }; /// @brief Backlight events handler class Handler : public HandlerCommon { public: Handler(std::shared_ptr settings, sys::Service *parent); + void init() override; + void handleKeyPressed(int key = 0); void processScreenRequest(screen_light_control::Action action, const screen_light_control::Parameters ¶ms) override; + void handleScreenLightSettings(screen_light_control::Action action, + const screen_light_control::Parameters ¶ms) override; + private: void handleScreenLightRefresh(int key = 0); void onScreenLightTurnedOn() override; + + void setKeyPressedModeFrontlightOn(); + void setKeyPressedModeFrontlightOff(); + + bool onDemandModeOn = true; + BacklightMode backlightMode = BacklightMode::WithTimer; }; } // namespace backlight diff --git a/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp b/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp index cf14cbf7cd56b34da96ab0591d94677579d22191..547f32e4c516e70b998247c0224c436c23784ce8 100644 --- a/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp +++ b/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.cpp @@ -5,17 +5,24 @@ #include #include +#include + +#include +#include namespace bell::screen_light_control { ScreenLightController::ScreenLightController(sys::Service *parent) + : cpuSentinel(std::make_shared(screenLightControlName, parent)) { - controlTimer = sys::TimerFactory::createPeriodicTimer(parent, + auto sentinelRegistrationMsg = std::make_shared(cpuSentinel); + parent->bus.sendUnicast(std::move(sentinelRegistrationMsg), service::name::system_manager); + + controlTimer = sys::TimerFactory::createPeriodicTimer(parent, "LightControlTimer", std::chrono::milliseconds{CONTROL_TIMER_MS}, [this](sys::Timer &) { controlTimerCallback(); }); - - setParameters(ManualModeParameters{}); + automaticMode = ScreenLightMode::Automatic; } ScreenLightController::~ScreenLightController() @@ -38,37 +45,35 @@ namespace bell::screen_light_control turnOn(params.hasManualModeParams() ? std::optional(params.getManualModeParams()) : std::nullopt); break; - case Action::enableAutomaticMode: - enableAutomaticMode(); - break; - case Action::disableAutomaticMode: - disableAutomaticMode(); - setManualBrightnessLevel(brightnessValue); - break; - case Action::setManualModeBrightness: - if (params.hasManualModeParams()) { - setParameters(params.getManualModeParams()); - } - break; case Action::setAutomaticModeParameters: if (params.hasLinearProgressModeParams()) { setParameters(params.getLinearProgressModeParams()); } + else if (params.hasConstLinearProgressModeParams()) { + setParameters(params.getConstLinearProgressModeParams()); + } + break; + default: break; } } void ScreenLightController::controlTimerCallback() { - auto currentBrightness = ::screen_light_control::functions::brightnessRampOut(); + auto newBrightness = ::screen_light_control::functions::brightnessRampOut(); + bsp::eink_frontlight::setBrightness(newBrightness); - bsp::eink_frontlight::setBrightness(currentBrightness); if (::screen_light_control::functions::isRampTargetReached()) { if (!automaticModeFunctions.empty()) { - setUpAutomaticFunction(getNextAutomaticFunction(), currentBrightness); + setUpAutomaticFunction(getNextAutomaticFunction(), newBrightness); } else { - disableAutomaticMode(); + if (newBrightness == MINIMAL_TARGET) { + turnOff(); + bsp::eink_frontlight::turnOff(); + } + setBrightnessInstant(MINIMAL_TARGET); + disableTimers(); } } } @@ -85,7 +90,7 @@ namespace bell::screen_light_control auto ScreenLightController::getBrightnessValue() const noexcept -> bsp::eink_frontlight::BrightnessPercentage { - return brightnessValue; + return brightnessWhenOn; } void ScreenLightController::enableTimers() @@ -101,7 +106,6 @@ namespace bell::screen_light_control void ScreenLightController::setParameters(const LinearProgressModeParameters ¶ms) { if (params.functions.empty()) { - LOG_ERROR("Functions are not defined. Cannot proceed with automatic mode."); disableTimers(); return; } @@ -113,7 +117,7 @@ namespace bell::screen_light_control ::screen_light_control::functions::setHysteresis(params.brightnessHysteresis); setUpAutomaticFunction(getNextAutomaticFunction(), ::screen_light_control::functions::getRampState()); - setManualBrightnessLevel(params.startBrightnessValue); + setBrightnessInstant(getStandarizedRampTarget(params.startBrightnessValue)); if (lightOn && automaticMode == ScreenLightMode::Automatic) { enableTimers(); @@ -137,61 +141,59 @@ namespace bell::screen_light_control ::screen_light_control::functions::LinearProgressFunction function, bsp::eink_frontlight::BrightnessPercentage currentBrightness) { + const auto rampTarget = getStandarizedRampTarget(function.target); ::screen_light_control::functions::setRampStep( - std::abs(function.target - currentBrightness) / + std::abs(rampTarget - currentBrightness) / (static_cast(function.duration.count()) / CONTROL_TIMER_MS)); - ::screen_light_control::functions::setRampTarget(function.target); - } - - void ScreenLightController::setParameters(ManualModeParameters params) - { - brightnessValue = params.manualModeBrightness; - ::screen_light_control::functions::setRampTarget(brightnessValue); - setManualBrightnessLevel(brightnessValue); - } - - void ScreenLightController::enableAutomaticMode() - { - if (lightOn) { - enableTimers(); - } - automaticMode = ScreenLightMode::Automatic; + ::screen_light_control::functions::setRampTarget(rampTarget); } - void ScreenLightController::disableAutomaticMode() + void ScreenLightController::setParameters(const ConstLinearProgressModeParameters ¶ms) { - disableTimers(); - automaticMode = ScreenLightMode::Manual; - automaticModeFunctions.clear(); + setBrightnessInstant(getStandarizedRampTarget(params.targetBrightness)); } void ScreenLightController::turnOn(const std::optional ¶ms) { if (params.has_value()) { - const auto brightness = params->manualModeBrightness; - ::screen_light_control::functions::setRampTarget(brightness); - setManualBrightnessLevel(brightness); + brightnessWhenOn = getStandarizedRampTarget(params->manualModeBrightness); } + ::screen_light_control::functions::setRampTarget(brightnessWhenOn); bsp::eink_frontlight::turnOn(); - if (automaticMode == ScreenLightMode::Automatic) { - enableTimers(); - } + cpuSentinelKeepOn(); + enableTimers(); lightOn = true; } - void ScreenLightController::setManualBrightnessLevel(bsp::eink_frontlight::BrightnessPercentage brightness) + void ScreenLightController::setBrightnessInstant(bsp::eink_frontlight::BrightnessPercentage brightness) { - bsp::eink_frontlight::setBrightness(brightness); - ::screen_light_control::functions::setRampState(brightness); + brightnessWhenOn = getStandarizedRampTarget(brightness); + ::screen_light_control::functions::setRampTarget(brightnessWhenOn); + ::screen_light_control::functions::setRampStep(RAMP_STEP_PER_MS * CONTROL_TIMER_MS); } void ScreenLightController::turnOff() { - bsp::eink_frontlight::turnOff(); - disableAutomaticMode(); lightOn = false; + ::screen_light_control::functions::setRampTarget(MINIMAL_TARGET); + cpuSentinelRelease(); + enableTimers(); + } - setManualBrightnessLevel(brightnessValue); + void ScreenLightController::cpuSentinelKeepOn() + { + cpuSentinel->HoldMinimumFrequency(bsp::CpuFrequencyHz::Level_6); + } + + void ScreenLightController::cpuSentinelRelease() + { + cpuSentinel->ReleaseMinimumFrequency(); + } + + bsp::eink_frontlight::BrightnessPercentage ScreenLightController::getStandarizedRampTarget( + bsp::eink_frontlight::BrightnessPercentage target) + { + return std::max(target, MINIMAL_TARGET); } -} // namespace screen_light_control +} // namespace bell::screen_light_control diff --git a/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.hpp b/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.hpp index b7fdaa5a5e8ab9325dfa1f472eb5283ee356e391..4e72d4532d7aa04ff965e0c9d7e1cac9adb149aa 100644 --- a/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.hpp +++ b/products/BellHybrid/services/evtmgr/screen-light-control/ScreenLightControl.hpp @@ -6,6 +6,7 @@ #include #include +#include #include #include @@ -19,15 +20,18 @@ namespace sys /// Processing of ambient light sensor input to screen brightness output. namespace bell::screen_light_control { + constexpr auto screenLightControlName = "ScreenLightControl"; + /// Control screen light and keeps it's current state class ScreenLightController : public ::screen_light_control::ScreenLightController { public: - using Action = ::screen_light_control::Action; - using Parameters = ::screen_light_control::Parameters; - using ScreenLightMode = ::screen_light_control::ScreenLightMode; - using ManualModeParameters = ::screen_light_control::ManualModeParameters; - using LinearProgressModeParameters = ::screen_light_control::LinearProgressModeParameters; + using Action = ::screen_light_control::Action; + using Parameters = ::screen_light_control::Parameters; + using ScreenLightMode = ::screen_light_control::ScreenLightMode; + using ManualModeParameters = ::screen_light_control::ManualModeParameters; + using LinearProgressModeParameters = ::screen_light_control::LinearProgressModeParameters; + using ConstLinearProgressModeParameters = ::screen_light_control::ConstLinearProgressModeParameters; explicit ScreenLightController(sys::Service *parent); ~ScreenLightController() override; @@ -46,8 +50,8 @@ namespace bell::screen_light_control void disableTimers(); void setParameters(const LinearProgressModeParameters ¶ms); - void setParameters(ManualModeParameters params); - void setManualBrightnessLevel(bsp::eink_frontlight::BrightnessPercentage brightness); + void setParameters(const ConstLinearProgressModeParameters ¶ms); + void setBrightnessInstant(bsp::eink_frontlight::BrightnessPercentage brightness); void setAutomaticModeFunctions(const LinearProgressModeParameters::LinearFunctions &functions); ::screen_light_control::functions::LinearProgressFunction getNextAutomaticFunction(); @@ -57,15 +61,21 @@ namespace bell::screen_light_control void turnOff(); void turnOn(const std::optional ¶ms = std::nullopt); - void enableAutomaticMode(); - void disableAutomaticMode(); + void cpuSentinelKeepOn(); + void cpuSentinelRelease(); + + bsp::eink_frontlight::BrightnessPercentage getStandarizedRampTarget( + bsp::eink_frontlight::BrightnessPercentage target); static constexpr inline auto CONTROL_TIMER_MS = 25; + static constexpr inline auto RAMP_STEP_PER_MS = 0.1; + static constexpr inline auto MINIMAL_TARGET = 15; sys::TimerHandle controlTimer; - bool lightOn = false; - ScreenLightMode automaticMode = ScreenLightMode::Manual; - bsp::eink_frontlight::BrightnessPercentage brightnessValue = 0.0; + std::shared_ptr cpuSentinel; + bool lightOn = false; + ScreenLightMode automaticMode = ScreenLightMode::Manual; + bsp::eink_frontlight::BrightnessPercentage brightnessWhenOn = MINIMAL_TARGET; LinearProgressModeParameters::LinearFunctions automaticModeFunctions; }; } // namespace bell::screen_light_control diff --git a/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp b/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp index 895ca83f2701ae4b4391a8b30fcc081364be909b..4a6f081a8e7b35df5ee618db88d98a23675e6362 100644 --- a/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp +++ b/products/PurePhone/services/evtmgr/backlight-handler/BacklightHandler.cpp @@ -18,14 +18,45 @@ namespace backlight } // namespace timers Handler::Handler(std::shared_ptr settings, sys::Service *parent) - : HandlerCommon( - std::move(settings), std::make_shared(parent), parent), + : HandlerCommon(std::move(settings), + std::make_shared(parent), + parent, + [this](sys::Timer &t) { + if (getScreenAutoModeState() == screen_light_control::ScreenLightMode::Automatic && + this->screenLightController->isLightOn()) { + this->screenLightController->processRequest(screen_light_control::Action::turnOff); + } + }), keypadLightTimer{sys::TimerFactory::createSingleShotTimer( parent, timers::keypadLightTimerName, timers::keypadLightTimerTimeout, [this](sys::Timer &) { bsp::keypad_backlight::shutdown(); })} {} + void Handler::init() + { + using namespace screen_light_control; + + settings->registerValueChange(settings::Brightness::brightnessLevel, [&](const std::string &value) { + ManualModeParameters params{utils::getNumericValue(value)}; + screenLightController->processRequest(Action::setManualModeBrightness, Parameters(params)); + }); + + settings->registerValueChange(settings::Brightness::autoMode, [&]([[maybe_unused]] const std::string &value) { + const auto action = getScreenAutoModeState() == ScreenLightMode::Automatic ? Action::enableAutomaticMode + : Action::disableAutomaticMode; + screenLightController->processRequest(action); + }); + + settings->registerValueChange(settings::Brightness::state, [&]([[maybe_unused]] const std::string &value) { + const auto action = getScreenLightState() ? Action::turnOn : Action::turnOff; + if (action == Action::turnOn) { + onScreenLightTurnedOn(); + } + screenLightController->processRequest(action); + }); + } + void Handler::handleKeyPressed([[maybe_unused]] int key) { handleKeypadLightRefresh(); diff --git a/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp b/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp index f029d5c84dde53130e96bfdd4ead6edc4bcb5869..24bef04dd957fa94239dc78edd4aab4436219949 100644 --- a/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp +++ b/products/PurePhone/services/evtmgr/include/evtmgr/BacklightHandler.hpp @@ -22,6 +22,7 @@ namespace backlight public: Handler(std::shared_ptr settings, sys::Service *parent); + void init() override; void handleKeyPressed(int key = 0); /// Process request of the keypad light control /// @keypad_backlight::action an action to perform @@ -32,7 +33,6 @@ namespace backlight const screen_light_control::Parameters ¶ms) override; private: - std::shared_ptr settings; /// Timer that keeps key backlight on for a certain time if there was key pressed sys::TimerHandle keypadLightTimer; /// Timer that keeps screen backlight on for a certain time if there was key pressed