From 79af0eb025c35a0d0f94942ee8ebd24ef2910e22 Mon Sep 17 00:00:00 2001 From: skiinder Date: Wed, 15 Apr 2026 10:52:01 +0800 Subject: [PATCH] =?UTF-8?q?feat(events):=20=E6=B7=BB=E5=8A=A0=E5=8A=9F?= =?UTF-8?q?=E8=83=BD=E4=BD=8D=E5=9B=BE=E7=8A=B6=E6=80=81=E4=BA=8B=E4=BB=B6?= =?UTF-8?q?=E5=B9=B6=E7=A7=BB=E9=99=A4=E6=97=A7=E7=9A=84=E6=8C=89=E9=94=AE?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E4=BA=8B=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 添加新的 function_bitmap_state_event 事件类型用于跟踪功能键位图状态 - 移除已废弃的 key_function_event 事件及其相关文件 - 更新 CMakeLists.txt 中的源文件列表以包含新事件文件 - 修改协议定义文件 device_comm.options 和 device_comm.proto 以使用位图方式传输功能键状态而不是单独的按键事件 - 更新键盘核心模块中的位图处理逻辑，添加 usage_to_bitmap_pos 辅助函数来正确定位修饰键和普通按键的位置 - 修改报告构建逻辑以正确处理新的位图布局 - 更新协议模块以处理新的功能位图状态事件和 LED 状态事件 - 实现协议模块中的 ACK、错误响应和 LED 状态编码功能 --- CMakeLists.txt | 2 +- inc/events/function_bitmap_state_event.h | 41 ++++ inc/events/key_function_event.h | 37 ---- proto/device_comm.options | 1 + proto/device_comm.proto | 8 +- src/events/function_bitmap_state_event.c | 27 +++ src/events/key_function_event.c | 43 ---- src/keyboard_core_module.c | 71 ++++--- src/protocol_module.c | 238 +++++++++++++++++++++-- 9 files changed, 341 insertions(+), 127 deletions(-) create mode 100644 inc/events/function_bitmap_state_event.h delete mode 100644 inc/events/key_function_event.h create mode 100644 src/events/function_bitmap_state_event.c delete mode 100644 src/events/key_function_event.c diff --git a/CMakeLists.txt b/CMakeLists.txt index ec06ef8..910ac6c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,13 +42,13 @@ target_sources(app PRIVATE src/events/bat_state_event.c src/events/datetime_event.c src/events/encoder_event.c + src/events/function_bitmap_state_event.c src/events/function_bitmap_update_event.c src/events/hid_led_event.c src/events/hid_report_sent_event.c src/events/hid_transport_state_event.c src/events/hid_tx_report_event.c src/events/led_strip_en_event.c - src/events/key_function_event.c src/mode_switch_module.c src/events/keyboard_hid_report_event.c src/events/mode_switch_event.c diff --git a/inc/events/function_bitmap_state_event.h b/inc/events/function_bitmap_state_event.h new file mode 100644 index 0000000..fa7715d --- /dev/null +++ b/inc/events/function_bitmap_state_event.h @@ -0,0 +1,41 @@ +#ifndef BLINKY_FUNCTION_BITMAP_STATE_EVENT_H_ +#define BLINKY_FUNCTION_BITMAP_STATE_EVENT_H_ + +#include +#include + +#include +#include + +#include "keyboard_core.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct function_bitmap_state_event { + struct app_event_header header; + uint8_t bitmap[KEYBOARD_PROTOCOL_BITMAP_BYTES]; +}; + +APP_EVENT_TYPE_DECLARE(function_bitmap_state_event); + +static inline int submit_function_bitmap_state_event(const uint8_t *bitmap) +{ + struct function_bitmap_state_event *event; + + if (bitmap == NULL) { + return -EINVAL; + } + + event = new_function_bitmap_state_event(); + memcpy(event->bitmap, bitmap, sizeof(event->bitmap)); + APP_EVENT_SUBMIT(event); + return 0; +} + +#ifdef __cplusplus +} +#endif + +#endif /* BLINKY_FUNCTION_BITMAP_STATE_EVENT_H_ */ diff --git a/inc/events/key_function_event.h b/inc/events/key_function_event.h deleted file mode 100644 index 404728e..0000000 --- a/inc/events/key_function_event.h +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef BLINKY_KEY_FUNCTION_EVENT_H_ -#define BLINKY_KEY_FUNCTION_EVENT_H_ - -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -enum key_function_action { - KEY_FUNCTION_ACTION_RELEASE = 0U, - KEY_FUNCTION_ACTION_PRESS = 1U, -}; - -struct key_function_event { - struct app_event_header header; - uint16_t usage; - uint8_t action; -}; - -APP_EVENT_TYPE_DECLARE(key_function_event); - -static inline void submit_key_function_event(uint16_t usage, uint8_t action) -{ - struct key_function_event *event = new_key_function_event(); - - event->usage = usage; - event->action = action; - APP_EVENT_SUBMIT(event); -} - -#ifdef __cplusplus -} -#endif - -#endif /* BLINKY_KEY_FUNCTION_EVENT_H_ */ diff --git a/proto/device_comm.options b/proto/device_comm.options index 82623b7..c0c5843 100644 --- a/proto/device_comm.options +++ b/proto/device_comm.options @@ -1 +1,2 @@ Bitmap.usage_bitmap max_size:29 +FunctionKeyEvent.usage_bitmap max_size:29 diff --git a/proto/device_comm.proto b/proto/device_comm.proto index b97b3a6..84da6c1 100644 --- a/proto/device_comm.proto +++ b/proto/device_comm.proto @@ -17,14 +17,8 @@ message Bitmap { bytes usage_bitmap = 1; } -enum KeyAction { - KEY_ACTION_RELEASE = 0; - KEY_ACTION_PRESS = 1; -} - message FunctionKeyEvent { - uint32 usage = 1; - KeyAction action = 2; + bytes usage_bitmap = 1; } message LedState { diff --git a/src/events/function_bitmap_state_event.c b/src/events/function_bitmap_state_event.c new file mode 100644 index 0000000..a371e4f --- /dev/null +++ b/src/events/function_bitmap_state_event.c @@ -0,0 +1,27 @@ +#include "function_bitmap_state_event.h" + +static void log_function_bitmap_state_event(const struct app_event_header *aeh) +{ + const struct function_bitmap_state_event *event = + cast_function_bitmap_state_event(aeh); + + APP_EVENT_MANAGER_LOG(aeh, "bitmap_len:%zu", sizeof(event->bitmap)); +} + +static void profile_function_bitmap_state_event(struct log_event_buf *buf, + const struct app_event_header *aeh) +{ + ARG_UNUSED(buf); + ARG_UNUSED(aeh); +} + +APP_EVENT_INFO_DEFINE(function_bitmap_state_event, + ENCODE(), + ENCODE(), + profile_function_bitmap_state_event); + +APP_EVENT_TYPE_DEFINE(function_bitmap_state_event, + log_function_bitmap_state_event, + &function_bitmap_state_event_info, + APP_EVENT_FLAGS_CREATE( + APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE)); diff --git a/src/events/key_function_event.c b/src/events/key_function_event.c deleted file mode 100644 index 9efb9c5..0000000 --- a/src/events/key_function_event.c +++ /dev/null @@ -1,43 +0,0 @@ -#include "key_function_event.h" - -static const char *action_name(uint8_t action) -{ - switch (action) { - case KEY_FUNCTION_ACTION_RELEASE: - return "release"; - - case KEY_FUNCTION_ACTION_PRESS: - return "press"; - - default: - return "unknown"; - } -} - -static void log_key_function_event(const struct app_event_header *aeh) -{ - const struct key_function_event *event = cast_key_function_event(aeh); - - APP_EVENT_MANAGER_LOG(aeh, "usage:0x%04x action:%s", - event->usage, action_name(event->action)); -} - -static void profile_key_function_event(struct log_event_buf *buf, - const struct app_event_header *aeh) -{ - const struct key_function_event *event = cast_key_function_event(aeh); - - nrf_profiler_log_encode_uint16(buf, event->usage); - nrf_profiler_log_encode_uint8(buf, event->action); -} - -APP_EVENT_INFO_DEFINE(key_function_event, - ENCODE(NRF_PROFILER_ARG_U16, NRF_PROFILER_ARG_U8), - ENCODE("usage", "action"), - profile_key_function_event); - -APP_EVENT_TYPE_DEFINE(key_function_event, - log_key_function_event, - &key_function_event_info, - APP_EVENT_FLAGS_CREATE( - APP_EVENT_TYPE_FLAGS_INIT_LOG_ENABLE)); diff --git a/src/keyboard_core_module.c b/src/keyboard_core_module.c index 4a0250e..e53675d 100644 --- a/src/keyboard_core_module.c +++ b/src/keyboard_core_module.c @@ -15,10 +15,10 @@ #include #include "encoder_event.h" +#include "function_bitmap_state_event.h" #include "function_bitmap_update_event.h" #include "keyboard_core.h" #include "keyboard_hid_report_event.h" -#include "key_function_event.h" #include "mode_switch_event.h" #include "set_protocol_event.h" @@ -146,13 +146,40 @@ static const struct keymap_entry *keymap_get(uint16_t key_id) return NULL; } -static bool usage_bitmap_test(const uint8_t *bitmap, uint16_t usage_id) +static bool usage_to_bitmap_pos(uint16_t usage_id, uint8_t *byte_idx, + uint8_t *bit_idx) { - if ((bitmap == NULL) || (usage_id > KEYBOARD_PROTOCOL_USAGE_MAX)) { + if ((byte_idx == NULL) || (bit_idx == NULL)) { return false; } - return (bitmap[usage_id / 8U] & BIT(usage_id % 8U)) != 0U; + if ((usage_id >= KEYBOARD_USAGE_FIRST_MODIFIER) && + (usage_id <= KEYBOARD_USAGE_LAST_MODIFIER)) { + *byte_idx = 0U; + *bit_idx = (uint8_t)(usage_id - KEYBOARD_USAGE_FIRST_MODIFIER); + return true; + } + + if (usage_id <= KEYBOARD_NKRO_USAGE_MAX) { + *byte_idx = (uint8_t)(1U + (usage_id / 8U)); + *bit_idx = (uint8_t)(usage_id % 8U); + return true; + } + + return false; +} + +static bool usage_bitmap_test(const uint8_t *bitmap, uint16_t usage_id) +{ + uint8_t byte_idx; + uint8_t bit_idx; + + if ((bitmap == NULL) || + !usage_to_bitmap_pos(usage_id, &byte_idx, &bit_idx)) { + return false; + } + + return (bitmap[byte_idx] & BIT(bit_idx)) != 0U; } static bool usage_bitmap_write(uint8_t *bitmap, uint16_t usage_id, bool pressed) @@ -161,13 +188,12 @@ static bool usage_bitmap_write(uint8_t *bitmap, uint16_t usage_id, bool pressed) uint8_t bit_idx; bool was_pressed; - if ((bitmap == NULL) || (usage_id > KEYBOARD_PROTOCOL_USAGE_MAX)) { + if ((bitmap == NULL) || + !usage_to_bitmap_pos(usage_id, &byte_idx, &bit_idx)) { LOG_WRN("Unsupported keyboard usage 0x%04x", usage_id); return false; } - byte_idx = usage_id / 8U; - bit_idx = usage_id % 8U; was_pressed = (bitmap[byte_idx] & BIT(bit_idx)) != 0U; if (was_pressed == pressed) { @@ -227,12 +253,14 @@ static void build_boot_report(uint8_t report[KEYBOARD_BOOT_REPORT_SIZE]) build_effective_hid_bitmap(effective_hid_bitmap); memset(report, 0, KEYBOARD_BOOT_REPORT_SIZE); - report[0] = effective_hid_bitmap[KEYBOARD_PROTOCOL_BITMAP_BYTES - 1U]; + report[0] = effective_hid_bitmap[0]; report[1] = KEYBOARD_BOOT_RESERVED_BYTE; for (uint16_t usage_id = 0; usage_id <= KEYBOARD_NKRO_USAGE_MAX; usage_id++) { - uint8_t byte_idx = usage_id / 8U; - uint8_t bit_idx = usage_id % 8U; + uint8_t byte_idx; + uint8_t bit_idx; + + (void)usage_to_bitmap_pos(usage_id, &byte_idx, &bit_idx); if ((effective_hid_bitmap[byte_idx] & BIT(bit_idx)) == 0U) { continue; @@ -254,8 +282,8 @@ static void build_nkro_report(uint8_t report[KEYBOARD_NKRO_REPORT_SIZE]) uint8_t effective_hid_bitmap[KEYBOARD_PROTOCOL_BITMAP_BYTES]; build_effective_hid_bitmap(effective_hid_bitmap); - report[0] = effective_hid_bitmap[KEYBOARD_PROTOCOL_BITMAP_BYTES - 1U]; - memcpy(&report[1], effective_hid_bitmap, KEYBOARD_NKRO_BITMAP_BYTES); + report[0] = effective_hid_bitmap[0]; + memcpy(&report[1], &effective_hid_bitmap[1], KEYBOARD_NKRO_BITMAP_BYTES); } static uint16_t active_consumer_usage_get(void) @@ -386,15 +414,9 @@ static void emit_all_reports(bool force) } } -static void emit_function_release_events(void) +static void emit_function_state_event(void) { - for (uint16_t usage_id = 0; usage_id <= KEYBOARD_PROTOCOL_USAGE_MAX; usage_id++) { - if (!usage_bitmap_test(keyboard_state.function_pressed_bitmap, usage_id)) { - continue; - } - - submit_key_function_event(usage_id, KEY_FUNCTION_ACTION_RELEASE); - } + (void)submit_function_bitmap_state_event(keyboard_state.pressed_usage_bitmap); } static void emit_release_reports(enum mode_switch_mode mode) @@ -451,7 +473,7 @@ static void module_pause(void) if (mode_valid) { emit_release_reports(current_mode); } - emit_function_release_events(); + emit_function_state_event(); keyboard_state_clear(); reports_cache_invalidate(); @@ -497,10 +519,7 @@ static bool handle_button_event(const struct button_event *event) } if (routed_to_function) { - submit_key_function_event(entry->usage_id, - event->pressed ? - KEY_FUNCTION_ACTION_PRESS : - KEY_FUNCTION_ACTION_RELEASE); + emit_function_state_event(); } else { emit_keys_report(false); } @@ -526,7 +545,7 @@ static bool handle_mode_switch_event(const struct mode_switch_event *event) mode_changed = mode_valid && (current_mode != event->mode); if (mode_changed) { emit_release_reports(current_mode); - emit_function_release_events(); + emit_function_state_event(); keyboard_state_clear(); reports_cache_invalidate(); } diff --git a/src/protocol_module.c b/src/protocol_module.c index e30dc1a..d1765fe 100644 --- a/src/protocol_module.c +++ b/src/protocol_module.c @@ -18,9 +18,14 @@ #include +#include "function_bitmap_state_event.h" +#include "function_bitmap_update_event.h" +#include "hid_led_event.h" #include "proto_rx_event.h" #include "proto_tx_event.h" #include "protocol_module.h" +#include "theme_rgb_update_event.h" +#include "time_sync_event.h" LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF); @@ -29,7 +34,7 @@ LOG_MODULE_REGISTER(MODULE, LOG_LEVEL_INF); #define PROTOCOL_PRODUCT_ID 0x52F0U #define PROTOCOL_FIRMWARE_MAJOR 0U #define PROTOCOL_FIRMWARE_MINOR 0U -#define PROTOCOL_CAPABILITY_FLAGS 0U +#define PROTOCOL_CAPABILITY_FLAGS (BIT(0) | BIT(1) | BIT(2) | BIT(3) | BIT(4)) #define PROTOCOL_MAX_MSG_LEN 128U static bool initialized; @@ -91,6 +96,59 @@ static int encode_hello_rsp(uint8_t *rsp_payload, size_t rsp_payload_buf_size, return encode_body(&body, rsp_payload, rsp_payload_buf_size, rsp_payload_len); } +static int encode_ack(uint8_t acked_type, uint8_t *rsp_payload, + size_t rsp_payload_buf_size, size_t *rsp_payload_len) +{ + CdcPacketBody body = CdcPacketBody_init_zero; + + body.which_body = CdcPacketBody_ack_tag; + body.body.ack.acked_type = acked_type; + + return encode_body(&body, rsp_payload, rsp_payload_buf_size, rsp_payload_len); +} + +static int encode_error(uint8_t error_type, ErrorCode error_code, + uint8_t *rsp_payload, size_t rsp_payload_buf_size, + size_t *rsp_payload_len) +{ + CdcPacketBody body = CdcPacketBody_init_zero; + + body.which_body = CdcPacketBody_error_tag; + body.body.error.error_type = error_type; + body.body.error.error_code = error_code; + + return encode_body(&body, rsp_payload, rsp_payload_buf_size, rsp_payload_len); +} + +static int encode_led_state(uint32_t led_mask, uint8_t *payload, + size_t payload_buf_size, size_t *payload_len) +{ + CdcPacketBody body = CdcPacketBody_init_zero; + + body.which_body = CdcPacketBody_led_state_tag; + body.body.led_state.led_mask = led_mask; + + return encode_body(&body, payload, payload_buf_size, payload_len); +} + +static int encode_function_bitmap_state(const uint8_t *bitmap, uint8_t *payload, + size_t payload_buf_size, + size_t *payload_len) +{ + CdcPacketBody body = CdcPacketBody_init_zero; + + if (bitmap == NULL) { + return -EINVAL; + } + + body.which_body = CdcPacketBody_function_key_event_tag; + body.body.function_key_event.usage_bitmap.size = KEYBOARD_PROTOCOL_BITMAP_BYTES; + memcpy(body.body.function_key_event.usage_bitmap.bytes, bitmap, + KEYBOARD_PROTOCOL_BITMAP_BYTES); + + return encode_body(&body, payload, payload_buf_size, payload_len); +} + static int module_init(void) { for (size_t i = 0; i < ARRAY_SIZE(hello_done); i++) { @@ -156,21 +214,98 @@ int protocol_module_process_message(enum proto_transport transport, return err; } - if (body.which_body != CdcPacketBody_hello_req_tag) { + switch (body.which_body) { + case CdcPacketBody_hello_req_tag: + LOG_INF("HelloReq transport:%u protocol_version:%u", + transport, body.body.hello_req.protocol_version); + + if (body.body.hello_req.protocol_version != PROTOCOL_VERSION) { + LOG_WRN("Unexpected protocol version:%u", + body.body.hello_req.protocol_version); + } + + hello_done[transport] = true; + return encode_hello_rsp(rsp_payload, rsp_payload_buf_size, rsp_payload_len); + + case CdcPacketBody_bitmap_tag: + if (!hello_done[transport]) { + return encode_error(CdcPacketBody_bitmap_tag, + ErrorCode_ERROR_CODE_NOT_READY, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + if (body.body.bitmap.usage_bitmap.size != KEYBOARD_PROTOCOL_BITMAP_BYTES) { + return encode_error(CdcPacketBody_bitmap_tag, + ErrorCode_ERROR_CODE_INVALID_LENGTH, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + err = submit_function_bitmap_update_event( + body.body.bitmap.usage_bitmap.bytes); + if (err) { + return encode_error(CdcPacketBody_bitmap_tag, + ErrorCode_ERROR_CODE_INVALID_PARAM, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + return encode_ack(CdcPacketBody_bitmap_tag, rsp_payload, + rsp_payload_buf_size, rsp_payload_len); + + case CdcPacketBody_time_sync_tag: + if (!hello_done[transport]) { + return encode_error(CdcPacketBody_time_sync_tag, + ErrorCode_ERROR_CODE_NOT_READY, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + if (body.body.time_sync.version != 1U) { + return encode_error(CdcPacketBody_time_sync_tag, + ErrorCode_ERROR_CODE_INVALID_PARAM, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + submit_time_sync_event(body.body.time_sync.version, + body.body.time_sync.flags, + body.body.time_sync.timezone_min, + body.body.time_sync.utc_ms, + body.body.time_sync.accuracy_ms); + return encode_ack(CdcPacketBody_time_sync_tag, rsp_payload, + rsp_payload_buf_size, rsp_payload_len); + + case CdcPacketBody_theme_rgb_tag: + if (!hello_done[transport]) { + return encode_error(CdcPacketBody_theme_rgb_tag, + ErrorCode_ERROR_CODE_NOT_READY, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + if ((body.body.theme_rgb.red > 255U) || + (body.body.theme_rgb.green > 255U) || + (body.body.theme_rgb.blue > 255U)) { + return encode_error(CdcPacketBody_theme_rgb_tag, + ErrorCode_ERROR_CODE_INVALID_PARAM, + rsp_payload, rsp_payload_buf_size, + rsp_payload_len); + } + + submit_theme_rgb_update_event((struct theme_rgb) { + .r = (uint8_t)body.body.theme_rgb.red, + .g = (uint8_t)body.body.theme_rgb.green, + .b = (uint8_t)body.body.theme_rgb.blue, + }); + return encode_ack(CdcPacketBody_theme_rgb_tag, rsp_payload, + rsp_payload_buf_size, rsp_payload_len); + + default: LOG_WRN("Unsupported protobuf body case %d", body.which_body); return -ENOTSUP; } - - LOG_INF("HelloReq transport:%u protocol_version:%u", - transport, body.body.hello_req.protocol_version); - - if (body.body.hello_req.protocol_version != PROTOCOL_VERSION) { - LOG_WRN("Unexpected protocol version:%u", - body.body.hello_req.protocol_version); - } - - hello_done[transport] = true; - return encode_hello_rsp(rsp_payload, rsp_payload_buf_size, rsp_payload_len); } static bool handle_proto_rx_event(const struct proto_rx_event *event) @@ -205,12 +340,87 @@ static bool handle_proto_rx_event(const struct proto_rx_event *event) return false; } +static bool handle_function_bitmap_state_event( + const struct function_bitmap_state_event *event) +{ + uint8_t payload[PROTOCOL_MAX_MSG_LEN]; + size_t payload_len; + int err; + + if (!running) { + return false; + } + + for (enum proto_transport transport = 0; transport < PROTO_TRANSPORT_COUNT; + transport++) { + if (!hello_done[transport]) { + continue; + } + + err = encode_function_bitmap_state(event->bitmap, payload, + sizeof(payload), &payload_len); + if (err) { + LOG_WRN("FunctionKeyEvent encode failed (%d)", err); + return false; + } + + err = submit_proto_tx_event(transport, payload, payload_len); + if (err) { + LOG_WRN("FunctionKeyEvent submit failed (%d)", err); + } + } + + return false; +} + +static bool handle_hid_led_event(const struct hid_led_event *event) +{ + uint8_t payload[PROTOCOL_MAX_MSG_LEN]; + size_t payload_len; + int err; + enum proto_transport transport; + + if (!running) { + return false; + } + + transport = (event->transport == HID_TRANSPORT_USB) ? + PROTO_TRANSPORT_USB_CDC : + PROTO_TRANSPORT_BLE_NUS; + + if (!hello_done[transport]) { + return false; + } + + err = encode_led_state(event->led_bm, payload, sizeof(payload), &payload_len); + if (err) { + LOG_WRN("LedState encode failed (%d)", err); + return false; + } + + err = submit_proto_tx_event(transport, payload, payload_len); + if (err) { + LOG_WRN("LedState submit failed (%d)", err); + } + + return false; +} + static bool app_event_handler(const struct app_event_header *aeh) { if (is_proto_rx_event(aeh)) { return handle_proto_rx_event(cast_proto_rx_event(aeh)); } + if (is_function_bitmap_state_event(aeh)) { + return handle_function_bitmap_state_event( + cast_function_bitmap_state_event(aeh)); + } + + if (is_hid_led_event(aeh)) { + return handle_hid_led_event(cast_hid_led_event(aeh)); + } + if (is_module_state_event(aeh)) { const struct module_state_event *event = cast_module_state_event(aeh); int err; @@ -266,6 +476,8 @@ static bool app_event_handler(const struct app_event_header *aeh) } APP_EVENT_LISTENER(MODULE, app_event_handler); +APP_EVENT_SUBSCRIBE(MODULE, function_bitmap_state_event); +APP_EVENT_SUBSCRIBE(MODULE, hid_led_event); APP_EVENT_SUBSCRIBE(MODULE, module_state_event); APP_EVENT_SUBSCRIBE(MODULE, proto_rx_event); APP_EVENT_SUBSCRIBE_EARLY(MODULE, power_down_event);