From be233a141bd178b7b25e837cdc7bdfd25db8b424 Mon Sep 17 00:00:00 2001 From: Merlinov <64584348+Merlinov@users.noreply.github.com> Date: Wed, 8 Feb 2023 21:52:43 +0300 Subject: [PATCH] Add files via upload --- app/src/hid.c | 225 ++++++++++++++++------------------------- app/src/hid_listener.c | 82 +++++++-------- app/src/hog.c | 96 +++++++++++++++++- app/src/main.c | 8 ++ 4 files changed, 230 insertions(+), 181 deletions(-) diff --git a/app/src/hid.c b/app/src/hid.c index b66a910d..209d679a 100644 --- a/app/src/hid.c +++ b/app/src/hid.c @@ -4,7 +4,6 @@ * SPDX-License-Identifier: MIT */ -#include "zmk/keys.h" #include LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); @@ -16,30 +15,28 @@ static struct zmk_hid_keyboard_report keyboard_report = { static struct zmk_hid_consumer_report consumer_report = {.report_id = 2, .body = {.keys = {0}}}; +static struct zmk_hid_mouse_report mouse_report = { + .report_id = 4, .body = {.buttons = 0, .x = 0, .y = 0, .scroll_x = 0, .scroll_y = 0}}; + // Keep track of how often a modifier was pressed. // Only release the modifier if the count is 0. static int explicit_modifier_counts[8] = {0, 0, 0, 0, 0, 0, 0, 0}; static zmk_mod_flags_t explicit_modifiers = 0; -static zmk_mod_flags_t implicit_modifiers = 0; -static zmk_mod_flags_t masked_modifiers = 0; #define SET_MODIFIERS(mods) \ { \ - keyboard_report.body.modifiers = (mods & ~masked_modifiers) | implicit_modifiers; \ + keyboard_report.body.modifiers = mods; \ LOG_DBG("Modifiers set to 0x%02X", keyboard_report.body.modifiers); \ } -#define GET_MODIFIERS (keyboard_report.body.modifiers) - zmk_mod_flags_t zmk_hid_get_explicit_mods() { return explicit_modifiers; } int zmk_hid_register_mod(zmk_mod_t modifier) { explicit_modifier_counts[modifier]++; LOG_DBG("Modifier %d count %d", modifier, explicit_modifier_counts[modifier]); WRITE_BIT(explicit_modifiers, modifier, true); - zmk_mod_flags_t current = GET_MODIFIERS; SET_MODIFIERS(explicit_modifiers); - return current == GET_MODIFIERS ? 0 : 1; + return 0; } int zmk_hid_unregister_mod(zmk_mod_t modifier) { @@ -53,68 +50,30 @@ int zmk_hid_unregister_mod(zmk_mod_t modifier) { LOG_DBG("Modifier %d released", modifier); WRITE_BIT(explicit_modifiers, modifier, false); } - zmk_mod_flags_t current = GET_MODIFIERS; SET_MODIFIERS(explicit_modifiers); - return current == GET_MODIFIERS ? 0 : 1; -} - -bool zmk_hid_mod_is_pressed(zmk_mod_t modifier) { - zmk_mod_flags_t mod_flag = 1 << modifier; - return (zmk_hid_get_explicit_mods() & mod_flag) == mod_flag; + return 0; } int zmk_hid_register_mods(zmk_mod_flags_t modifiers) { - int ret = 0; for (zmk_mod_t i = 0; i < 8; i++) { if (modifiers & (1 << i)) { - ret += zmk_hid_register_mod(i); + zmk_hid_register_mod(i); } } - return ret; + return 0; } int zmk_hid_unregister_mods(zmk_mod_flags_t modifiers) { - int ret = 0; for (zmk_mod_t i = 0; i < 8; i++) { if (modifiers & (1 << i)) { - ret += zmk_hid_unregister_mod(i); + zmk_hid_unregister_mod(i); } } - - return ret; -} - -#if IS_ENABLED(CONFIG_ZMK_HID_REPORT_TYPE_NKRO) - -#define TOGGLE_KEYBOARD(code, val) WRITE_BIT(keyboard_report.body.keys[code / 8], code % 8, val) - -static inline int select_keyboard_usage(zmk_key_t usage) { - if (usage > ZMK_HID_KEYBOARD_NKRO_MAX_USAGE) { - return -EINVAL; - } - TOGGLE_KEYBOARD(usage, 1); return 0; } -static inline int deselect_keyboard_usage(zmk_key_t usage) { - if (usage > ZMK_HID_KEYBOARD_NKRO_MAX_USAGE) { - return -EINVAL; - } - TOGGLE_KEYBOARD(usage, 0); - return 0; -} - -static inline bool check_keyboard_usage(zmk_key_t usage) { - if (usage > ZMK_HID_KEYBOARD_NKRO_MAX_USAGE) { - return false; - } - return keyboard_report.body.keys[usage / 8] & (1 << (usage % 8)); -} - -#elif IS_ENABLED(CONFIG_ZMK_HID_REPORT_TYPE_HKRO) - #define TOGGLE_KEYBOARD(match, val) \ - for (int idx = 0; idx < CONFIG_ZMK_HID_KEYBOARD_REPORT_SIZE; idx++) { \ + for (int idx = 0; idx < ZMK_HID_KEYBOARD_NKRO_SIZE; idx++) { \ if (keyboard_report.body.keys[idx] != match) { \ continue; \ } \ @@ -124,33 +83,8 @@ static inline bool check_keyboard_usage(zmk_key_t usage) { } \ } -static inline int select_keyboard_usage(zmk_key_t usage) { - TOGGLE_KEYBOARD(0U, usage); - return 0; -} - -static inline int deselect_keyboard_usage(zmk_key_t usage) { - TOGGLE_KEYBOARD(usage, 0U); - return 0; -} - -static inline int check_keyboard_usage(zmk_key_t usage) { - for (int idx = 0; idx < CONFIG_ZMK_HID_KEYBOARD_REPORT_SIZE; idx++) { - if (keyboard_report.body.keys[idx] == usage) { - return true; - } - } - return false; -} - -#else -#error "A proper HID report type must be selected" -#endif - #define TOGGLE_CONSUMER(match, val) \ - COND_CODE_1(IS_ENABLED(CONFIG_ZMK_HID_CONSUMER_REPORT_USAGES_BASIC), \ - (if (val > 0xFF) { return -ENOTSUP; }), ()) \ - for (int idx = 0; idx < CONFIG_ZMK_HID_CONSUMER_REPORT_SIZE; idx++) { \ + for (int idx = 0; idx < ZMK_HID_CONSUMER_NKRO_SIZE; idx++) { \ if (consumer_report.body.keys[idx] != match) { \ continue; \ } \ @@ -160,39 +94,21 @@ static inline int check_keyboard_usage(zmk_key_t usage) { } \ } -int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t new_implicit_modifiers) { - implicit_modifiers = new_implicit_modifiers; - zmk_mod_flags_t current = GET_MODIFIERS; - SET_MODIFIERS(explicit_modifiers); - return current == GET_MODIFIERS ? 0 : 1; +int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t implicit_modifiers) { + SET_MODIFIERS(explicit_modifiers | implicit_modifiers); + return 0; } int zmk_hid_implicit_modifiers_release() { - implicit_modifiers = 0; - zmk_mod_flags_t current = GET_MODIFIERS; SET_MODIFIERS(explicit_modifiers); - return current == GET_MODIFIERS ? 0 : 1; -} - -int zmk_hid_masked_modifiers_set(zmk_mod_flags_t new_masked_modifiers) { - masked_modifiers = new_masked_modifiers; - zmk_mod_flags_t current = GET_MODIFIERS; - SET_MODIFIERS(explicit_modifiers); - return current == GET_MODIFIERS ? 0 : 1; -} - -int zmk_hid_masked_modifiers_clear() { - masked_modifiers = 0; - zmk_mod_flags_t current = GET_MODIFIERS; - SET_MODIFIERS(explicit_modifiers); - return current == GET_MODIFIERS ? 0 : 1; + return 0; } int zmk_hid_keyboard_press(zmk_key_t code) { if (code >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL && code <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI) { return zmk_hid_register_mod(code - HID_USAGE_KEY_KEYBOARD_LEFTCONTROL); } - select_keyboard_usage(code); + TOGGLE_KEYBOARD(0U, code); return 0; }; @@ -200,17 +116,10 @@ int zmk_hid_keyboard_release(zmk_key_t code) { if (code >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL && code <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI) { return zmk_hid_unregister_mod(code - HID_USAGE_KEY_KEYBOARD_LEFTCONTROL); } - deselect_keyboard_usage(code); + TOGGLE_KEYBOARD(code, 0U); return 0; }; -bool zmk_hid_keyboard_is_pressed(zmk_key_t code) { - if (code >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL && code <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI) { - return zmk_hid_mod_is_pressed(code - HID_USAGE_KEY_KEYBOARD_LEFTCONTROL); - } - return check_keyboard_usage(code); -} - void zmk_hid_keyboard_clear() { memset(&keyboard_report.body, 0, sizeof(keyboard_report.body)); } int zmk_hid_consumer_press(zmk_key_t code) { @@ -225,45 +134,85 @@ int zmk_hid_consumer_release(zmk_key_t code) { void zmk_hid_consumer_clear() { memset(&consumer_report.body, 0, sizeof(consumer_report.body)); } -bool zmk_hid_consumer_is_pressed(zmk_key_t key) { - for (int idx = 0; idx < CONFIG_ZMK_HID_CONSUMER_REPORT_SIZE; idx++) { - if (consumer_report.body.keys[idx] == key) { - return true; +// Keep track of how often a button was pressed. +// Only release the button if the count is 0. +static int explicit_button_counts[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; +static zmk_mod_flags_t explicit_buttons = 0; + +#define SET_MOUSE_BUTTONS(btns) \ + { \ + mouse_report.body.buttons = btns; \ + LOG_DBG("Mouse buttons set to 0x%02X", mouse_report.body.buttons); \ + } + +int zmk_hid_mouse_button_press(zmk_mouse_button_t button) { + explicit_button_counts[button]++; + LOG_DBG("Button %d count %d", button, explicit_button_counts[button]); + WRITE_BIT(explicit_buttons, button, true); + SET_MOUSE_BUTTONS(explicit_buttons); + return 0; +} + +int zmk_hid_mouse_button_release(zmk_mouse_button_t button) { + if (explicit_button_counts[button] <= 0) { + LOG_ERR("Tried to release button %d too often", button); + return -EINVAL; + } + explicit_button_counts[button]--; + LOG_DBG("Button %d count: %d", button, explicit_button_counts[button]); + if (explicit_button_counts[button] == 0) { + LOG_DBG("Button %d released", button); + WRITE_BIT(explicit_buttons, button, false); + } + SET_MOUSE_BUTTONS(explicit_buttons); + return 0; +} + +int zmk_hid_mouse_buttons_press(zmk_mouse_button_flags_t buttons) { + for (zmk_mod_t i = 0; i < 16; i++) { + if (buttons & (1 << i)) { + zmk_hid_mouse_button_press(i); } } - return false; + return 0; } -int zmk_hid_press(uint32_t usage) { - switch (ZMK_HID_USAGE_PAGE(usage)) { - case HID_USAGE_KEY: - return zmk_hid_keyboard_press(ZMK_HID_USAGE_ID(usage)); - case HID_USAGE_CONSUMER: - return zmk_hid_consumer_press(ZMK_HID_USAGE_ID(usage)); +int zmk_hid_mouse_buttons_release(zmk_mouse_button_flags_t buttons) { + for (zmk_mod_t i = 0; i < 16; i++) { + if (buttons & (1 << i)) { + zmk_hid_mouse_button_release(i); + } } - return -EINVAL; + return 0; } -int zmk_hid_release(uint32_t usage) { - switch (ZMK_HID_USAGE_PAGE(usage)) { - case HID_USAGE_KEY: - return zmk_hid_keyboard_release(ZMK_HID_USAGE_ID(usage)); - case HID_USAGE_CONSUMER: - return zmk_hid_consumer_release(ZMK_HID_USAGE_ID(usage)); - } - return -EINVAL; +void zmk_hid_mouse_movement_set(int16_t x, int16_t y) { + mouse_report.body.x = x; + mouse_report.body.y = y; + LOG_DBG("Mouse movement set to 0x%02X 0x%02X ", mouse_report.body.x, mouse_report.body.y); } -bool zmk_hid_is_pressed(uint32_t usage) { - switch (ZMK_HID_USAGE_PAGE(usage)) { - case HID_USAGE_KEY: - return zmk_hid_keyboard_is_pressed(ZMK_HID_USAGE_ID(usage)); - case HID_USAGE_CONSUMER: - return zmk_hid_consumer_is_pressed(ZMK_HID_USAGE_ID(usage)); - } - return false; +void zmk_hid_mouse_movement_update(int16_t x, int16_t y) { + mouse_report.body.x += x; + mouse_report.body.y += y; + LOG_DBG("Mouse movement updated to 0x%02X 0x%02X ", mouse_report.body.x, mouse_report.body.y); } +void zmk_hid_mouse_scroll_set(int8_t x, int8_t y) { + mouse_report.body.scroll_x = x; + mouse_report.body.scroll_y = y; + LOG_DBG("Mouse scroll set to 0x%02X 0x%02X ", mouse_report.body.scroll_x, + mouse_report.body.scroll_y); +} + +void zmk_hid_mouse_scroll_update(int8_t x, int8_t y) { + mouse_report.body.scroll_x += x; + mouse_report.body.scroll_y += y; + LOG_DBG("Mouse scroll updated to 0x%02X 0x%02X ", mouse_report.body.scroll_x, + mouse_report.body.scroll_y); +} +void zmk_hid_mouse_clear() { memset(&mouse_report.body, 0, sizeof(mouse_report.body)); } + struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report() { return &keyboard_report; } @@ -271,3 +220,7 @@ struct zmk_hid_keyboard_report *zmk_hid_get_keyboard_report() { struct zmk_hid_consumer_report *zmk_hid_get_consumer_report() { return &consumer_report; } + +struct zmk_hid_mouse_report *zmk_hid_get_mouse_report() { + return &mouse_report; +} diff --git a/app/src/hid_listener.c b/app/src/hid_listener.c index e233b0b8..af7c38d8 100644 --- a/app/src/hid_listener.c +++ b/app/src/hid_listener.c @@ -11,76 +11,76 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); #include #include -#include #include #include #include static int hid_listener_keycode_pressed(const struct zmk_keycode_state_changed *ev) { - int err, explicit_mods_changed, implicit_mods_changed; - + int err; LOG_DBG("usage_page 0x%02X keycode 0x%02X implicit_mods 0x%02X explicit_mods 0x%02X", ev->usage_page, ev->keycode, ev->implicit_modifiers, ev->explicit_modifiers); - err = zmk_hid_press(ZMK_HID_USAGE(ev->usage_page, ev->keycode)); - if (err < 0) { - LOG_DBG("Unable to press keycode"); - return err; - } - explicit_mods_changed = zmk_hid_register_mods(ev->explicit_modifiers); - implicit_mods_changed = zmk_hid_implicit_modifiers_press(ev->implicit_modifiers); - if (ev->usage_page != HID_USAGE_KEY && - (explicit_mods_changed > 0 || implicit_mods_changed > 0)) { - err = zmk_endpoints_send_report(HID_USAGE_KEY); - if (err < 0) { - LOG_ERR("Failed to send key report for changed mofifiers for consumer page event (%d)", - err); + switch (ev->usage_page) { + case HID_USAGE_KEY: + err = zmk_hid_keyboard_press(ev->keycode); + if (err) { + LOG_ERR("Unable to press keycode"); + return err; } + break; + case HID_USAGE_CONSUMER: + err = zmk_hid_consumer_press(ev->keycode); + if (err) { + LOG_ERR("Unable to press keycode"); + return err; + } + break; } - + zmk_hid_register_mods(ev->explicit_modifiers); + zmk_hid_implicit_modifiers_press(ev->implicit_modifiers); return zmk_endpoints_send_report(ev->usage_page); } static int hid_listener_keycode_released(const struct zmk_keycode_state_changed *ev) { - int err, explicit_mods_changed, implicit_mods_changed; - + int err; LOG_DBG("usage_page 0x%02X keycode 0x%02X implicit_mods 0x%02X explicit_mods 0x%02X", ev->usage_page, ev->keycode, ev->implicit_modifiers, ev->explicit_modifiers); - err = zmk_hid_release(ZMK_HID_USAGE(ev->usage_page, ev->keycode)); - if (err < 0) { - LOG_DBG("Unable to release keycode"); - return err; + switch (ev->usage_page) { + case HID_USAGE_KEY: + err = zmk_hid_keyboard_release(ev->keycode); + if (err) { + LOG_ERR("Unable to release keycode"); + return err; + } + break; + case HID_USAGE_CONSUMER: + err = zmk_hid_consumer_release(ev->keycode); + if (err) { + LOG_ERR("Unable to release keycode"); + return err; + } } - - explicit_mods_changed = zmk_hid_unregister_mods(ev->explicit_modifiers); + zmk_hid_unregister_mods(ev->explicit_modifiers); // There is a minor issue with this code. // If LC(A) is pressed, then LS(B), then LC(A) is released, the shift for B will be released // prematurely. This causes if LS(B) to repeat like Bbbbbbbb when pressed for a long time. // Solving this would require keeping track of which key's implicit modifiers are currently // active and only releasing modifiers at that time. - implicit_mods_changed = zmk_hid_implicit_modifiers_release(); - ; - if (ev->usage_page != HID_USAGE_KEY && - (explicit_mods_changed > 0 || implicit_mods_changed > 0)) { - err = zmk_endpoints_send_report(HID_USAGE_KEY); - if (err < 0) { - LOG_ERR("Failed to send key report for changed mofifiers for consumer page event (%d)", - err); - } - } + zmk_hid_implicit_modifiers_release(); return zmk_endpoints_send_report(ev->usage_page); } int hid_listener(const zmk_event_t *eh) { - const struct zmk_keycode_state_changed *ev = as_zmk_keycode_state_changed(eh); - if (ev) { - if (ev->state) { - hid_listener_keycode_pressed(ev); + const struct zmk_keycode_state_changed *kc_ev = as_zmk_keycode_state_changed(eh); + if (kc_ev) { + if (kc_ev->state) { + hid_listener_keycode_pressed(kc_ev); } else { - hid_listener_keycode_released(ev); + hid_listener_keycode_released(kc_ev); } + return 0; } return 0; } ZMK_LISTENER(hid_listener, hid_listener); -ZMK_SUBSCRIPTION(hid_listener, zmk_keycode_state_changed); +ZMK_SUBSCRIPTION(hid_listener, zmk_keycode_state_changed); \ No newline at end of file diff --git a/app/src/hog.c b/app/src/hog.c index 3dd3e874..1b7850c8 100644 --- a/app/src/hog.c +++ b/app/src/hog.c @@ -37,7 +37,7 @@ struct hids_report { static struct hids_info info = { .version = 0x0000, .code = 0x00, - .flags = HIDS_NORMALLY_CONNECTABLE | HIDS_REMOTE_WAKE, + .flags = HIDS_NORMALLY_CONNECTABLE & HIDS_REMOTE_WAKE, }; enum { @@ -56,6 +56,11 @@ static struct hids_report consumer_input = { .type = HIDS_INPUT, }; +static struct hids_report mouse_input = { + .id = 0x04, + .type = HIDS_INPUT, +}; + static bool host_requests_notification = false; static uint8_t ctrl_point; // static uint8_t proto_mode; @@ -93,6 +98,13 @@ static ssize_t read_hids_consumer_input_report(struct bt_conn *conn, sizeof(struct zmk_hid_consumer_report_body)); } +static ssize_t read_hids_mouse_input_report(struct bt_conn *conn, const struct bt_gatt_attr *attr, + void *buf, uint16_t len, uint16_t offset) { + struct zmk_hid_mouse_report_body *report_body = &zmk_hid_get_mouse_report()->body; + return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body, + sizeof(struct zmk_hid_mouse_report_body)); +} + // static ssize_t write_proto_mode(struct bt_conn *conn, // const struct bt_gatt_attr *attr, // const void *buf, uint16_t len, uint16_t offset, @@ -139,6 +151,13 @@ BT_GATT_SERVICE_DEFINE( BT_GATT_CCC(input_ccc_changed, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT), BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ_ENCRYPT, read_hids_report_ref, NULL, &consumer_input), + + BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_REPORT, BT_GATT_CHRC_READ | BT_GATT_CHRC_NOTIFY, + BT_GATT_PERM_READ_ENCRYPT, read_hids_mouse_input_report, NULL, NULL), + BT_GATT_CCC(input_ccc_changed, BT_GATT_PERM_READ_ENCRYPT | BT_GATT_PERM_WRITE_ENCRYPT), + BT_GATT_DESCRIPTOR(BT_UUID_HIDS_REPORT_REF, BT_GATT_PERM_READ_ENCRYPT, read_hids_report_ref, + NULL, &mouse_input), + BT_GATT_CHARACTERISTIC(BT_UUID_HIDS_CTRL_POINT, BT_GATT_CHRC_WRITE_WITHOUT_RESP, BT_GATT_PERM_WRITE, NULL, write_ctrl_point, &ctrl_point)); @@ -261,10 +280,79 @@ int zmk_hog_send_consumer_report(struct zmk_hid_consumer_report_body *report) { return 0; }; +K_MSGQ_DEFINE(zmk_hog_mouse_msgq, sizeof(struct zmk_hid_mouse_report_body), + CONFIG_ZMK_BLE_MOUSE_REPORT_QUEUE_SIZE, 4); + +void send_mouse_report_callback(struct k_work *work) { + struct zmk_hid_mouse_report_body report; + while (k_msgq_get(&zmk_hog_mouse_msgq, &report, K_NO_WAIT) == 0) { + struct bt_conn *conn = destination_connection(); + if (conn == NULL) { + return; + } + + struct bt_gatt_notify_params notify_params = { + .attr = &hog_svc.attrs[13], + .data = &report, + .len = sizeof(report), + }; + + int err = bt_gatt_notify_cb(conn, ¬ify_params); + if (err) { + LOG_DBG("Error notifying %d", err); + } + + bt_conn_unref(conn); + } +}; + +K_WORK_DEFINE(hog_mouse_work, send_mouse_report_callback); + +int zmk_hog_send_mouse_report(struct zmk_hid_mouse_report_body *report) { + int err = k_msgq_put(&zmk_hog_mouse_msgq, report, K_NO_WAIT); + if (err) { + switch (err) { + case -EAGAIN: { + LOG_WRN("Mouse message queue full, dropping report"); + return err; + } + default: + LOG_WRN("Failed to queue mouse report to send (%d)", err); + return err; + } + } + + k_work_submit_to_queue(&hog_work_q, &hog_mouse_work); + + return 0; +}; + +int zmk_hog_send_mouse_report_direct(struct zmk_hid_mouse_report_body *report) { + struct bt_conn *conn = destination_connection(); + if (conn == NULL) { + return 1; + } + + struct bt_gatt_notify_params notify_params = { + .attr = &hog_svc.attrs[13], + .data = report, + .len = sizeof(*report), + }; + + int err = bt_gatt_notify_cb(conn, ¬ify_params); + if (err) { + LOG_DBG("Error notifying %d", err); + return err; + } + + bt_conn_unref(conn); + + return 0; +}; + int zmk_hog_init(const struct device *_arg) { - static const struct k_work_queue_config queue_config = {.name = "HID Over GATT Send Work"}; - k_work_queue_start(&hog_work_q, hog_q_stack, K_THREAD_STACK_SIZEOF(hog_q_stack), - CONFIG_ZMK_BLE_THREAD_PRIORITY, &queue_config); + k_work_q_start(&hog_work_q, hog_q_stack, K_THREAD_STACK_SIZEOF(hog_q_stack), + CONFIG_ZMK_BLE_THREAD_PRIORITY); return 0; } diff --git a/app/src/main.c b/app/src/main.c index ae604a7b..d3b3e578 100644 --- a/app/src/main.c +++ b/app/src/main.c @@ -17,6 +17,10 @@ LOG_MODULE_REGISTER(zmk, CONFIG_ZMK_LOG_LEVEL); #include #include +#ifdef CONFIG_ZMK_MOUSE +#include +#endif /* CONFIG_ZMK_MOUSE */ + #define ZMK_KSCAN_DEV DT_LABEL(ZMK_MATRIX_NODE_ID) void main(void) { @@ -29,4 +33,8 @@ void main(void) { #ifdef CONFIG_ZMK_DISPLAY zmk_display_init(); #endif /* CONFIG_ZMK_DISPLAY */ + +#ifdef CONFIG_ZMK_MOUSE + zmk_mouse_init(); +#endif /* CONFIG_ZMK_MOUSE */ }