M module-bsp/board/linux/CMakeLists.txt => module-bsp/board/linux/CMakeLists.txt +0 -1
@@ 25,7 25,6 @@ target_sources(module-bsp
hal/battery_charger/BatteryCharger.cpp
hal/key_input/KeyInput.cpp
bell_temp_sensor/bell_temp_sensor.cpp
- rotary_encoder/rotary_encoder.cpp
${CMAKE_CURRENT_BINARY_DIR}/eink-config.h
)
D module-bsp/board/linux/rotary_encoder/rotary_encoder.cpp => module-bsp/board/linux/rotary_encoder/rotary_encoder.cpp +0 -20
@@ 1,20 0,0 @@
-// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
-// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-
-#include <bsp/rotary_encoder/rotary_encoder.hpp>
-
-namespace bsp::rotary_encoder
-{
- int init(xQueueHandle qHandle)
- {
- return 1;
- }
- void deinit()
- {}
-
- std::optional<type> WorkerEventHandler()
- {
- return std::nullopt;
- }
-
-} // namespace bsp::rotary_encoder
A module-bsp/board/rt1051/bellpx/bsp/KeyInputCommon.hpp => module-bsp/board/rt1051/bellpx/bsp/KeyInputCommon.hpp +23 -0
@@ 0,0 1,23 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+namespace bsp
+{
+ enum class NotificationSource : uint8_t
+ {
+ leftSideKeyPress = 1,
+ leftSideKeyRelease,
+ rightSideKeyPress,
+ rightSideKeyRelease,
+ lightCenterKeyPress,
+ lightCenterKeyRelease,
+ latchKeyPress,
+ latchKeyRelease,
+ wakeupEvent,
+ wakeupEventRelease,
+ rotaryEncoder,
+ Invalid = 0xFF
+ };
+} // namespace bsp
M module-bsp/board/rt1051/bellpx/bsp/rotary_encoder/rotary_encoder.cpp => module-bsp/board/rt1051/bellpx/bsp/rotary_encoder/rotary_encoder.cpp +46 -43
@@ 1,7 1,8 @@
// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-#include <bsp/rotary_encoder/rotary_encoder.hpp>
+#include "rotary_encoder.hpp"
+#include <bsp/KeyInputCommon.hpp>
#include <board/BoardDefinitions.hpp>
#include <timers.h>
#include <fsl_common.h>
@@ 15,18 16,23 @@ namespace bsp::rotary_encoder
{
namespace
{
- constexpr auto POLL_INTERVAL_MS = 100U;
- constexpr uint16_t MAX_PER_100MS = 100U;
+ enum class Direction
+ {
+ forward = 0x01,
+ backward = 0x02,
+ undefined = 0xFF
+ };
+ constexpr auto MAX_PER_CHECK = 100;
constexpr auto PRIMARY_SOURCE = kQTMR_ClockCounter0InputPin;
constexpr auto BOARD_QTMR_ENC_CHANNEL = kQTMR_Channel_0;
constexpr auto SECONDARY_SOURCE = kQTMR_Counter1InputPin;
+ constexpr auto INTERRUPT_MODE = kQTMR_EdgeInterruptEnable;
auto BOARD_QTMR_ID = TMR3;
xQueueHandle gHandleIrq;
- TimerHandle_t gTimerHandle;
uint32_t encCounter;
} // namespace
- int init(xQueueHandle qHandle)
+ void init(xQueueHandle qHandle)
{
gHandleIrq = qHandle;
qtmr_config_t timerCfg;
@@ 34,63 40,60 @@ namespace bsp::rotary_encoder
timerCfg.primarySource = PRIMARY_SOURCE;
timerCfg.secondarySource = SECONDARY_SOURCE;
QTMR_Init(BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL, &timerCfg);
+ QTMR_SetupInputCapture(
+ BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL, SECONDARY_SOURCE, false, false, kQTMR_RisingAndFallingEdge);
+ QTMR_EnableInterrupts(BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL, INTERRUPT_MODE);
QTMR_StartTimer(BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL, kQTMR_QuadCountMode);
- if (!gTimerHandle) {
- gTimerHandle =
- xTimerCreate("RotEncTimer", pdMS_TO_TICKS(POLL_INTERVAL_MS), true, nullptr, [](TimerHandle_t) {
- if (gHandleIrq) {
- uint8_t val{0x01};
- xQueueSend(gHandleIrq, &val, 0);
- }
- });
- }
- if (xTimerStart(gTimerHandle, 0) != pdPASS) {
- LOG_ERROR("Couldn't start encoder timer");
- }
+
LOG_DEBUG("Init rotary encoder driver");
- const auto ret = (gTimerHandle && gHandleIrq) ? (kStatus_Success) : (kStatus_Fail);
- LOG_DEBUG("Init rotary encoder driver status %i", ret);
- return ret;
}
void deinit()
{
- xTimerDelete(gTimerHandle, 50);
- gTimerHandle = nullptr;
gHandleIrq = nullptr;
+ QTMR_DisableInterrupts(BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL, INTERRUPT_MODE);
QTMR_Deinit(BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL);
}
- std::optional<type> WorkerEventHandler()
+ std::vector<KeyEvent> getKeyEvents()
{
uint16_t tmp = QTMR_GetCurrentTimerCount(BOARD_QTMR_ID, BOARD_QTMR_ENC_CHANNEL);
- std::optional<type> ret;
+ auto direction = Direction::undefined;
+ std::vector<KeyEvent> out;
- if (tmp != encCounter && encCounter >= 0xFFFFU - MAX_PER_100MS && encCounter <= 0xFFFFU) {
- if (tmp <= MAX_PER_100MS || tmp > encCounter) {
- ret = type::forward;
- }
- else {
- ret = type::backward;
- }
+ int difference = tmp - encCounter;
+ if (difference > MAX_PER_CHECK) {
+ direction = Direction::backward;
}
- else if (tmp != encCounter && encCounter <= MAX_PER_100MS) {
- if ((tmp >= 0xFFFFU - MAX_PER_100MS) || tmp < encCounter) {
- ret = type::backward;
- }
- else {
- ret = type::forward;
- }
+ else if (difference < -MAX_PER_CHECK) {
+ direction = Direction::forward;
}
- else if (tmp < encCounter) {
- ret = type::backward;
+ else if (difference > 0) {
+ direction = Direction::forward;
}
- else if (tmp > encCounter) {
- ret = type::forward;
+ else if (difference < 0) {
+ direction = Direction::backward;
}
encCounter = tmp;
- return ret;
+ if (direction == Direction::forward) {
+ out.push_back({KeyCodes::JoystickUp, KeyEvents::Moved});
+ }
+ else if (direction == Direction::backward) {
+ out.push_back({KeyCodes::JoystickDown, KeyEvents::Moved});
+ }
+
+ return out;
+ }
+
+ BaseType_t IRQHandler(uint32_t mask)
+ {
+ BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+ if (gHandleIrq != nullptr) {
+ std::uint8_t val = static_cast<std::uint8_t>(NotificationSource::rotaryEncoder);
+ xQueueSendFromISR(gHandleIrq, &val, &xHigherPriorityTaskWoken);
+ }
+ return xHigherPriorityTaskWoken;
}
} // namespace bsp::rotary_encoder
R module-bsp/bsp/rotary_encoder/rotary_encoder.hpp => module-bsp/board/rt1051/bellpx/bsp/rotary_encoder/rotary_encoder.hpp +11 -11
@@ 1,23 1,23 @@
-#pragma once
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
-#include <cstdint>
-#include <optional>
+#pragma once
-#include "../common.hpp"
+#include <bsp/common.hpp>
+#include <hal/key_input/KeyEventDefinitions.hpp>
#include <queue.hpp>
+#include <cstdint>
+#include <vector>
+
namespace bsp
{
namespace rotary_encoder
{
- enum class type
- {
- forward = 0x01,
- backward = 0x02
- };
- int init(xQueueHandle qHandle);
+ void init(xQueueHandle qHandle);
void deinit();
- std::optional<type> WorkerEventHandler();
+ std::vector<KeyEvent> getKeyEvents();
+ BaseType_t IRQHandler(uint32_t mask);
} // namespace rotary_encoder
} // namespace bsp
M module-bsp/board/rt1051/bellpx/bsp/switches/switches.cpp => module-bsp/board/rt1051/bellpx/bsp/switches/switches.cpp +51 -68
@@ 43,21 43,6 @@ namespace bsp::bell_switches
Invalid
};
- enum class NotificationSource : uint16_t
- {
- leftSideKeyPress = 0x0001,
- leftSideKeyRelease = 0x0002,
- rightSideKeyPress = 0x0004,
- rightSideKeyRelease = 0x0008,
- lightCenterKeyPress = 0x0010,
- lightCenterKeyRelease = 0x0020,
- latchKeyPress = 0x0040,
- latchKeyRelease = 0x0080,
- wakeupEvent = 0x0400,
- wakeupEventRelease = 0x0800,
- Invalid = 0xFFFF
- };
-
void debounceTimerCallback(TimerHandle_t timerHandle);
struct DebounceTimerState
@@ 143,8 128,26 @@ namespace bsp::bell_switches
if (timerState->notificationSource == NotificationSource::latchKeyPress) {
latchEventFlag.setReleased();
}
- // Using responding release notification source, which is one bit shifted
- auto val = (static_cast<std::uint16_t>(timerState->notificationSource) << 1);
+ auto val = NotificationSource::Invalid;
+ switch (timerState->notificationSource) {
+ case NotificationSource::leftSideKeyPress:
+ val = NotificationSource::leftSideKeyRelease;
+ break;
+ case NotificationSource::rightSideKeyPress:
+ val = NotificationSource::rightSideKeyRelease;
+ break;
+ case NotificationSource::lightCenterKeyPress:
+ val = NotificationSource::lightCenterKeyRelease;
+ break;
+ case NotificationSource::latchKeyPress:
+ val = NotificationSource::latchKeyRelease;
+ break;
+ case NotificationSource::wakeupEvent:
+ val = NotificationSource::wakeupEventRelease;
+ break;
+ default:
+ break;
+ }
xQueueSendFromISR(qHandleIrq, &val, &xHigherPriorityTaskWoken);
timerState->lastState = KeyEvents::Pressed;
}
@@ 345,79 348,59 @@ namespace bsp::bell_switches
gpio_wakeup->DisableInterrupt(1 << static_cast<uint32_t>(BoardDefinitions::BELL_WAKEUP));
}
- std::vector<KeyEvent> getKeyEvents(KeyNotificationSource notification)
+ std::vector<KeyEvent> getKeyEvents(NotificationSource notification)
{
std::vector<KeyEvent> out;
+ KeyEvent keyEvent;
- if (notification & static_cast<uint16_t>(NotificationSource::leftSideKeyPress)) {
+ switch (notification) {
+ case NotificationSource::leftSideKeyPress:
LOG_DEBUG("leftSideKeyPress");
- KeyEvent keyEvent{KeyCodes::FnLeft, KeyEvents::Pressed};
+ keyEvent = {KeyCodes::FnLeft, KeyEvents::Pressed};
out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::leftSideKeyRelease)) {
+ break;
+ case NotificationSource::leftSideKeyRelease:
LOG_DEBUG("leftSideKeyRelease");
- KeyEvent keyEvent{KeyCodes::FnLeft, KeyEvents::Released};
+ keyEvent = {KeyCodes::FnLeft, KeyEvents::Released};
out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::rightSideKeyPress)) {
+ break;
+ case NotificationSource::rightSideKeyPress:
LOG_DEBUG("rightSideKeyPress");
- KeyEvent keyEvent{KeyCodes::FnRight, KeyEvents::Pressed};
+ keyEvent = {KeyCodes::FnRight, KeyEvents::Pressed};
out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint8_t>(NotificationSource::rightSideKeyRelease)) {
+ break;
+ case NotificationSource::rightSideKeyRelease:
LOG_DEBUG("rightSideKeyRelease");
- KeyEvent keyEvent{KeyCodes::FnRight, KeyEvents::Released};
+ keyEvent = {KeyCodes::FnRight, KeyEvents::Released};
out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::lightCenterKeyPress)) {
+ break;
+ case NotificationSource::lightCenterKeyPress:
LOG_DEBUG("lightCenterKeyPress");
- KeyEvent keyEvent{KeyCodes::JoystickEnter, KeyEvents::Pressed};
- out.push_back(keyEvent);
- // workaround for current GUI event processing
- keyEvent = {KeyCodes::JoystickEnter, KeyEvents::Released};
+ keyEvent = {KeyCodes::JoystickEnter, KeyEvents::Moved};
out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::lightCenterKeyRelease)) {
+ break;
+ case NotificationSource::lightCenterKeyRelease:
LOG_DEBUG("lightCenterKeyRelease");
- KeyEvent keyEvent{KeyCodes::JoystickEnter, KeyEvents::Pressed};
- out.push_back(keyEvent);
- // workaround for current GUI event processing
- keyEvent = {KeyCodes::JoystickEnter, KeyEvents::Released};
+ keyEvent = {KeyCodes::JoystickEnter, KeyEvents::Moved};
out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::latchKeyPress)) {
+ break;
+ case NotificationSource::latchKeyPress:
LOG_DEBUG("latchKeyPress");
- KeyEvent keyEvent{KeyCodes::JoystickRight, KeyEvents::Pressed};
+ keyEvent = {KeyCodes::JoystickRight, KeyEvents::Moved};
out.push_back(keyEvent);
- // workaround for current GUI event processing
- keyEvent = {KeyCodes::JoystickRight, KeyEvents::Released};
- out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::latchKeyRelease)) {
+ break;
+ case NotificationSource::latchKeyRelease:
LOG_DEBUG("latchKeyRelease");
- KeyEvent keyEvent{KeyCodes::JoystickLeft, KeyEvents::Pressed};
+ keyEvent = {KeyCodes::JoystickLeft, KeyEvents::Moved};
out.push_back(keyEvent);
- // workaround for current GUI event processing
- keyEvent = {KeyCodes::JoystickLeft, KeyEvents::Released};
- out.push_back(keyEvent);
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::wakeupEvent)) {
+ break;
+ case NotificationSource::wakeupEvent:
/* Implement wakeup event */
- }
-
- if (notification & static_cast<uint16_t>(NotificationSource::wakeupEventRelease)) {
- KeyEvent keyEvent;
+ break;
+ case NotificationSource::wakeupEventRelease:
/* Implement wakeup event */
+ break;
}
-
return out;
}
M module-bsp/board/rt1051/bellpx/bsp/switches/switches.hpp => module-bsp/board/rt1051/bellpx/bsp/switches/switches.hpp +2 -1
@@ 4,13 4,14 @@
#pragma once
#include <hal/key_input/KeyEventDefinitions.hpp>
+#include <bsp/KeyInputCommon.hpp>
#include <cstdint>
#include <vector>
namespace bsp::bell_switches
{
- std::vector<KeyEvent> getKeyEvents(KeyNotificationSource notification);
+ std::vector<KeyEvent> getKeyEvents(NotificationSource notification);
std::int32_t init(xQueueHandle qHandle);
M module-bsp/board/rt1051/bellpx/hal/key_input/KeyInput.cpp => module-bsp/board/rt1051/bellpx/hal/key_input/KeyInput.cpp +18 -2
@@ 2,9 2,11 @@
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#include "KeyInput.hpp"
+#include <bsp/KeyInputCommon.hpp>
#include <hal/GenericFactory.hpp>
#include <bsp/switches/switches.hpp>
+#include <bsp/rotary_encoder/rotary_encoder.hpp>
#include <board/BoardDefinitions.hpp>
namespace hal::key_input
@@ 17,21 19,35 @@ namespace hal::key_input
void KeyInput::init(xQueueHandle queueHandle)
{
bsp::bell_switches::init(queueHandle);
+ bsp::rotary_encoder::init(queueHandle);
}
void KeyInput::deinit()
{
bsp::bell_switches::deinit();
+ bsp::rotary_encoder::deinit();
}
std::vector<bsp::KeyEvent> KeyInput::getKeyEvents(KeyNotificationSource notification)
{
- return bsp::bell_switches::getKeyEvents(notification);
+ auto keyNotification = static_cast<bsp::NotificationSource>(notification);
+ if (keyNotification == bsp::NotificationSource::rotaryEncoder) {
+ return bsp::rotary_encoder::getKeyEvents();
+ }
+ else {
+ return bsp::bell_switches::getKeyEvents(keyNotification);
+ }
}
BaseType_t generalIRQHandler(std::uint32_t irqMask)
{
- return bsp::bell_switches::IRQHandler(irqMask);
+ constexpr std::uint32_t encoderMask{99};
+ if (irqMask == encoderMask) {
+ return bsp::rotary_encoder::IRQHandler(irqMask);
+ }
+ else {
+ return bsp::bell_switches::IRQHandler(irqMask);
+ }
}
BaseType_t wakeupIRQHandler()
M module-bsp/board/rt1051/bellpx/irq_gpio.cpp => module-bsp/board/rt1051/bellpx/irq_gpio.cpp +19 -0
@@ 8,6 8,7 @@
#include "FreeRTOS.h"
#include "queue.h"
#include "fsl_common.h"
+#include <fsl_qtmr.h>
#include "board/rt1051/bsp/eink/bsp_eink.h"
#include <hal/battery_charger/AbstractBatteryCharger.hpp>
@@ 28,6 29,7 @@ namespace bsp
DisableIRQ(GPIO2_Combined_16_31_IRQn);
DisableIRQ(GPIO3_Combined_16_31_IRQn);
DisableIRQ(GPIO5_Combined_0_15_IRQn);
+ DisableIRQ(TMR3_IRQn);
GPIO_PortDisableInterrupts(GPIO1, UINT32_MAX);
GPIO_PortDisableInterrupts(GPIO2, UINT32_MAX);
@@ 39,6 41,10 @@ namespace bsp
GPIO_PortClearInterruptFlags(GPIO2, UINT32_MAX);
GPIO_PortClearInterruptFlags(GPIO3, UINT32_MAX);
GPIO_PortClearInterruptFlags(GPIO5, UINT32_MAX);
+ QTMR_ClearStatusFlags(TMR3,
+ kQTMR_Channel_0,
+ kQTMR_CompareFlag | kQTMR_Compare1Flag | kQTMR_Compare2Flag | kQTMR_OverflowFlag |
+ kQTMR_EdgeFlag);
EnableIRQ(GPIO1_Combined_0_15_IRQn);
NVIC_SetPriority(GPIO1_Combined_0_15_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY);
@@ 57,6 63,9 @@ namespace bsp
EnableIRQ(GPIO5_Combined_0_15_IRQn);
NVIC_SetPriority(GPIO5_Combined_0_15_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY);
+
+ EnableIRQ(TMR3_IRQn);
+ NVIC_SetPriority(TMR3_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY);
}
extern "C"
@@ 173,5 182,15 @@ namespace bsp
// Switch context if necessary
portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
}
+
+ void TMR3_IRQHandler(void)
+ {
+ QTMR_ClearStatusFlags(TMR3,
+ kQTMR_Channel_0,
+ kQTMR_CompareFlag | kQTMR_Compare1Flag | kQTMR_Compare2Flag | kQTMR_OverflowFlag |
+ kQTMR_EdgeFlag);
+ const uint8_t QTMR3_mask = 99;
+ hal::key_input::generalIRQHandler(QTMR3_mask);
+ }
}
} // namespace bsp
M module-gui/gui/input/Translator.cpp => module-gui/gui/input/Translator.cpp +5 -1
@@ 175,11 175,15 @@ namespace gui
InputEvent KeyInputSimpleTranslation::translate(RawKey key)
{
auto evt = KeyBaseTranslation::set(key);
- // when last action timed out we don't want to handle key release
if (isPreviousKeyTimedOut && key.state == RawKey::State::Released) {
+ // when last action timed out we don't want to handle key release
evt.setState(InputEvent::State::Undefined);
isPreviousKeyTimedOut = false;
}
+ else if (key.state == RawKey::State::Moved) {
+ // translation of single moved event to keyReleasedShort
+ evt.setState(InputEvent::State::keyReleasedShort);
+ }
evt.setKeyCode(getKeyCode(key.keyCode));
return evt;
}
M products/BellHybrid/services/evtmgr/WorkerEvent.cpp => products/BellHybrid/services/evtmgr/WorkerEvent.cpp +1 -35
@@ 6,7 6,6 @@
#include <bsp/eink_frontlight/eink_frontlight.hpp>
#include <service-audio/AudioMessage.hpp>
#include <service-evtmgr/EVMessages.hpp>
-#include <bsp/rotary_encoder/rotary_encoder.hpp>
namespace bell
{
@@ 15,56 14,23 @@ namespace bell
{}
void WorkerEvent::addProductQueues(std::list<sys::WorkerQueueInfo> &queuesList)
- {
- constexpr auto elementSize = sizeof(std::uint8_t);
- queuesList.emplace_back(rotaryEncoderQueueName, elementSize, rotaryEncoderQueueSize);
- }
+ {}
void WorkerEvent::initProductHardware()
{
bsp::eink_frontlight::init();
- bsp::rotary_encoder::init(queues[static_cast<int32_t>(EventQueues::queueRotaryEncoder)]->GetQueueHandle());
}
bool WorkerEvent::handleMessage(std::uint32_t queueID)
{
- auto &queue = queues[queueID];
- if (queueID == static_cast<uint32_t>(EventQueues::queueRotaryEncoder)) {
- uint8_t notification;
- if (!queue->Dequeue(¬ification, 0)) {
- return false;
- }
- handleRotaryEncoderEvent();
- }
return WorkerEventCommon::handleMessage(queueID);
}
void WorkerEvent::deinitProductHardware()
{
bsp::eink_frontlight::deinit();
- bsp::rotary_encoder::deinit();
- }
-
- void WorkerEvent::processRotaryAsShortRelease(bsp::KeyCodes code)
- {
- processKeyEvent(bsp::KeyEvents::Pressed, code);
- processKeyEvent(bsp::KeyEvents::Released, code);
}
- void WorkerEvent::handleRotaryEncoderEvent()
- {
- if (const auto &key = bsp::rotary_encoder::WorkerEventHandler(); key.has_value()) {
- if (key.value() == bsp::rotary_encoder::type::forward) {
- processRotaryAsShortRelease(bsp::KeyCodes::JoystickUp);
- }
- else if (key.value() == bsp::rotary_encoder::type::backward) {
- processRotaryAsShortRelease(bsp::KeyCodes::JoystickDown);
- }
- else {
- LOG_ERROR("Unknown rotary event");
- }
- }
- }
void WorkerEvent::processKeyEvent(bsp::KeyEvents event, bsp::KeyCodes code)
{
auto message = std::make_shared<sevm::KbdMessage>();
M products/BellHybrid/services/evtmgr/WorkerEvent.hpp => products/BellHybrid/services/evtmgr/WorkerEvent.hpp +0 -6
@@ 18,12 18,6 @@ namespace bell
void deinitProductHardware() final;
void processKeyEvent(bsp::KeyEvents event, bsp::KeyCodes code) final;
bool handleMessage(std::uint32_t queueID) override;
- void processRotaryAsShortRelease(bsp::KeyCodes code);
- void handleRotaryEncoderEvent();
- enum class EventQueues
- {
- queueRotaryEncoder = static_cast<int>(WorkerEventQueues::queueRTC) + 1,
- };
static constexpr auto rotaryEncoderQueueSize = 64U;
static constexpr auto rotaryEncoderQueueName = "qRotaryEncoder";
};