pwarren/zmk_mf68
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Fix consumer keys w/ refactored behaviors.

Browse source
This commit is contained in:
Pete Johanson 2020-06-22 11:06:01 -04:00
parent 8027be106e
commit 55cf9db564
20 changed files with 193 additions and 238 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
app/boards/native_posix.overlay
View file

@ -56,7 +56,7 @@
label = "DEFAULT"; label = "DEFAULT";
bindings = < bindings = <
&kp B &mo A &kp C &kp E &kp B &mo 1 &kp C &kp E
&kp D &kp G &kp F &kp Q>; &kp D &kp G &kp F &kp Q>;
}; };
@ -64,7 +64,7 @@
label = "LOWER"; label = "LOWER";
bindings = < bindings = <
&kp N &trans &kp O &kp Q &cp M_NEXT &trans &kp O &kp Q
&kp L &kp J &kp P &kp K>; &kp L &kp J &kp P &kp K>;
}; };

5
app/boards/shields/petejohanson_handwire/keymap/include/keymap.h
View file

@ -1,5 +0,0 @@
#include <dt-bindings/zmk/keys.h>
#define CC_RAIS ZC_CSTM(1)
#define CC_LOWR ZC_CSTM(2)

34
app/boards/shields/petejohanson_handwire/keymap/keymap.c
View file

@ -1,34 +0,0 @@
#include <zmk/keys.h>
#include <zmk/keymap.h>
#include <keymap.h>
bool zmk_handle_key_user(struct zmk_key_event *key_event)
{
switch (key_event->key)
{
case CC_LOWR:
if (key_event->pressed)
{
zmk_keymap_layer_activate(1);
}
else
{
zmk_keymap_layer_deactivate(1);
}
return false;
case CC_RAIS:
if (key_event->pressed)
{
zmk_keymap_layer_activate(2);
}
else
{
zmk_keymap_layer_deactivate(2);
}
return false;
}
return true;
};

26
app/boards/shields/petejohanson_handwire/keymap/keymap.overlay
View file

@ -1,6 +1,5 @@
#include <dt-bindings/zmk/keys.h> #include <dt-bindings/zmk/keys.h>
#include <behaviors.dtsi> #include <behaviors.dtsi>
#include <keymap.h>
/ { / {
chosen { chosen {
@ -18,37 +17,24 @@
default: layer_0 { default: layer_0 {
label = "DEFAULT"; label = "DEFAULT";
keys =
<
KC_A MT(MOD_LSFT, KC_B) ZC_NO ZC_NO
CC_RAIS CC_LOWR ZC_NO ZC_NO
>;
bindings = < bindings = <
&reset &kp 0 &cp M_NEXT &mt MOD_LSFT B &trans &trans
&kp 1 &kp 2>; &mo 1 &mo 2 &trans &trans>;
}; };
lower: layer_1 { lower: layer_1 {
label = "LOWER"; label = "LOWER";
keys = <
KC_MPLY KC_MNXT ZC_NO ZC_NO
ZC_TRNS ZC_TRNS ZC_NO ZC_NO
>;
bindings = < bindings = <
&reset &kp 0 &cp M_PLAY &cp M_NEXT &trans &trans
&kp 1 &kp 2>; &trans &trans &trans &trans>;
}; };
raise: layer_2 { raise: layer_2 {
label = "RAISE"; label = "RAISE";
keys = <
KC_C KC_D ZC_NO ZC_NO
ZC_TRNS ZC_TRNS ZC_NO ZC_NO>;
bindings = < bindings = <
&reset &kp 0 &kp C &kp D &trans &trans
&kp 1 &kp 2>; &trans &kp E &trans &trans>;
}; };
}; };
}; };

10
app/dts/behaviors/key_press.dtsi
View file

@ -1,8 +1,18 @@
#include <dt-bindings/zmk/keys.h>
/ { / {
behaviors { behaviors {
kp: behavior_key_press { kp: behavior_key_press {
compatible = "zmk,behavior-key-press"; compatible = "zmk,behavior-key-press";
label = "KEY_PRESS"; label = "KEY_PRESS";
usage_page = <USAGE_KEYPAD>;
#binding-cells = <1>;
};
cp: behavior_consumer_press {
compatible = "zmk,behavior-key-press";
label = "CONSUMER_PRESS";
usage_page = <USAGE_CONSUMER>;
#binding-cells = <1>; #binding-cells = <1>;
}; };
}; };

5
app/dts/bindings/behaviors/zmk,behavior-key-press.yaml
View file

@ -6,3 +6,8 @@ description: Key press/release behavior
compatible: "zmk,behavior-key-press" compatible: "zmk,behavior-key-press"
include: one_param.yaml include: one_param.yaml
properties:
usage_page:
type: int
default: 0

16
app/include/drivers/behavior.h
View file

@ -25,7 +25,7 @@ extern "C" {
typedef int (*behavior_position_callback_t)(struct device *dev, u32_t position); typedef int (*behavior_position_callback_t)(struct device *dev, u32_t position);
typedef int (*behavior_keymap_binding_callback_t)(struct device *dev, u32_t position, u32_t param1, u32_t param2); typedef int (*behavior_keymap_binding_callback_t)(struct device *dev, u32_t position, u32_t param1, u32_t param2);
typedef int (*behavior_keycode_callback_t)(struct device *dev, u32_t keycode); typedef int (*behavior_keycode_callback_t)(struct device *dev, u8_t usage_page, u32_t keycode);
typedef int (*behavior_modifiers_callback_t)(struct device *dev, zmk_mod_flags modifiers); typedef int (*behavior_modifiers_callback_t)(struct device *dev, zmk_mod_flags modifiers);
__subsystem struct behavior_driver_api { __subsystem struct behavior_driver_api {
@ -135,14 +135,15 @@ static inline int z_impl_behavior_keymap_binding_released(struct device *dev, u3
/** /**
* @brief Handle the keycode being pressed * @brief Handle the keycode being pressed
* @param dev Pointer to the device structure for the driver instance. * @param dev Pointer to the device structure for the driver instance.
* @param usage_page The usage page for the keycode.
* @param keycode The keycode that is being pressed. * @param keycode The keycode that is being pressed.
* *
* @retval 0 If successful. * @retval 0 If successful.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int behavior_keycode_pressed(struct device *dev, u32_t keycode); __syscall int behavior_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode);
static inline int z_impl_behavior_keycode_pressed(struct device *dev, u32_t keycode) static inline int z_impl_behavior_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode)
{ {
const struct behavior_driver_api *api = const struct behavior_driver_api *api =
(const struct behavior_driver_api *)dev->driver_api; (const struct behavior_driver_api *)dev->driver_api;
@ -151,21 +152,22 @@ static inline int z_impl_behavior_keycode_pressed(struct device *dev, u32_t keyc
return -ENOTSUP; return -ENOTSUP;
} }
return api->keycode_pressed(dev, keycode); return api->keycode_pressed(dev, usage_page, keycode);
} }
/** /**
* @brief Handle the keycode being released * @brief Handle the keycode being released
* @param dev Pointer to the device structure for the driver instance. * @param dev Pointer to the device structure for the driver instance.
* @param usage_page The usage page for the keycode.
* @param keycode The keycode that is being pressed. * @param keycode The keycode that is being pressed.
* *
* @retval 0 If successful. * @retval 0 If successful.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int behavior_keycode_released(struct device *dev, u32_t keycode); __syscall int behavior_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode);
static inline int z_impl_behavior_keycode_released(struct device *dev, u32_t keycode) static inline int z_impl_behavior_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode)
{ {
const struct behavior_driver_api *api = const struct behavior_driver_api *api =
(const struct behavior_driver_api *)dev->driver_api; (const struct behavior_driver_api *)dev->driver_api;
@ -174,7 +176,7 @@ static inline int z_impl_behavior_keycode_released(struct device *dev, u32_t key
return -ENOTSUP; return -ENOTSUP;
} }
return api->keycode_released(dev, keycode); return api->keycode_released(dev, usage_page, keycode);
} }

19
app/include/dt-bindings/zmk/keys.h
View file

@ -1,6 +1,9 @@
#pragma once #pragma once
#define USAGE_KEYPAD 0x07
#define USAGE_CONSUMER 0x0C
#define A 0x04 #define A 0x04
#define B 0x05 #define B 0x05
#define C 0x06 #define C 0x06
@ -104,14 +107,14 @@
/* The following are select consumer page usages */ /* The following are select consumer page usages */
#define MNXT 0x100 #define M_NEXT 0xB5
#define MPRV 0x101 #define M_PREV 0xB6
#define MSTP 0x102 #define M_STOP 0xB7
#define MJCT 0x103 #define M_EJCT 0xB8
#define MPLY 0x104 #define M_PLAY 0xCD
#define MMUT 0x105 #define M_MUTE 0xE2
#define MVLU 0x106 #define M_VOLU 0xE9
#define MVLD 0x107 #define M_VOLD 0xEA
#define MOD_LCTL (1 << 0x00) #define MOD_LCTL (1 << 0x00)
#define MOD_LSFT (1 << 0x01) #define MOD_LSFT (1 << 0x01)

3
app/include/zmk/endpoints.h
View file

@ -4,5 +4,4 @@
#include <zmk/hid.h> #include <zmk/hid.h>
int zmk_endpoints_init(); int zmk_endpoints_init();
int zmk_endpoints_send_report(enum zmk_hid_report_changes changes); int zmk_endpoints_send_report(u8_t usage_report);
int zmk_endpoints_send_key_event(struct zmk_key_event key_event);

4
app/include/zmk/events.h
View file

@ -4,8 +4,8 @@
int zmk_events_position_pressed(u32_t position); int zmk_events_position_pressed(u32_t position);
int zmk_events_position_released(u32_t position); int zmk_events_position_released(u32_t position);
int zmk_events_keycode_pressed(u32_t keycode); int zmk_events_keycode_pressed(u8_t usage_page, u32_t keycode);
int zmk_events_keycode_released(u32_t keycode); int zmk_events_keycode_released(u8_t usage_page, u32_t keycode);
int zmk_events_modifiers_pressed(zmk_mod_flags modifiers); int zmk_events_modifiers_pressed(zmk_mod_flags modifiers);
int zmk_events_modifiers_released(zmk_mod_flags modifiers); int zmk_events_modifiers_released(zmk_mod_flags modifiers);
int zmk_events_consumer_key_pressed(u32_t usage); int zmk_events_consumer_key_pressed(u32_t usage);

55
app/include/zmk/hid.h
View file

@ -108,40 +108,21 @@ static const u8_t zmk_hid_report_desc[] = {
0x00, 0x00,
/* LOGICAL_MAXIMUM (1) */ /* LOGICAL_MAXIMUM (1) */
HID_GI_LOGICAL_MAX(1), HID_GI_LOGICAL_MAX(1),
0x01, 0xFF,
/* USAGE (Scan Next Track) */ HID_LI_USAGE_MIN(1),
HID_LI_USAGE, 0x00,
0xB5, /* USAGE_MAXIMUM (Keyboard Application) */
/* USAGE (Scan Previous Track) */ HID_LI_USAGE_MAX(1),
HID_LI_USAGE, 0xFF,
0xB6,
/* USAGE (Stop) */
HID_LI_USAGE,
0xB7,
/* USAGE (Eject) */
HID_LI_USAGE,
0xB8,
/* USAGE (Media Play/Pause) */
HID_LI_USAGE,
0xCD,
/* USAGE (Mute) */
HID_LI_USAGE,
0xE2,
/* USAGE (Volume Increment) */
HID_LI_USAGE,
0xE9,
/* USAGE (Volume Decrement) */
HID_LI_USAGE,
0xEA,
/* INPUT (Data,Ary,Abs) */ /* INPUT (Data,Ary,Abs) */
/* REPORT_SIZE (1) */ /* REPORT_SIZE (8) */
HID_GI_REPORT_SIZE, HID_GI_REPORT_SIZE,
0x01, 0x08,
/* REPORT_COUNT (8) */ /* REPORT_COUNT (8) */
HID_GI_REPORT_COUNT, HID_GI_REPORT_COUNT,
0x08, 0x06,
HID_MI_INPUT, HID_MI_INPUT,
0x02, 0x00,
/* END COLLECTION */ /* END COLLECTION */
HID_MI_COLLECTION_END, HID_MI_COLLECTION_END,
}; };
@ -167,7 +148,7 @@ struct zmk_hid_keypad_report
struct zmk_hid_consumer_report_body struct zmk_hid_consumer_report_body
{ {
u8_t keys; u8_t keys[6];
} __packed; } __packed;
struct zmk_hid_consumer_report struct zmk_hid_consumer_report
@ -176,19 +157,15 @@ struct zmk_hid_consumer_report
struct zmk_hid_consumer_report_body body; struct zmk_hid_consumer_report_body body;
} __packed; } __packed;
enum zmk_hid_report_changes
{
None = 0x00,
Keypad = (0x01 << 0x00),
Consumer = (0x01 << 0x01)
};
int zmk_hid_register_mod(zmk_mod modifier); int zmk_hid_register_mod(zmk_mod modifier);
int zmk_hid_unregister_mod(zmk_mod modifier); int zmk_hid_unregister_mod(zmk_mod modifier);
int zmk_hid_register_mods(zmk_mod_flags modifiers); int zmk_hid_register_mods(zmk_mod_flags modifiers);
int zmk_hid_unregister_mods(zmk_mod_flags modifiers); int zmk_hid_unregister_mods(zmk_mod_flags modifiers);
enum zmk_hid_report_changes zmk_hid_press_key(zmk_key key); int zmk_hid_keypad_press(zmk_key key);
enum zmk_hid_report_changes zmk_hid_release_key(zmk_key key); int zmk_hid_keypad_release(zmk_key key);
int zmk_hid_consumer_press(zmk_key key);
int zmk_hid_consumer_release(zmk_key key);
struct zmk_hid_keypad_report *zmk_hid_get_keypad_report(); struct zmk_hid_keypad_report *zmk_hid_get_keypad_report();
struct zmk_hid_consumer_report *zmk_hid_get_consumer_report(); struct zmk_hid_consumer_report *zmk_hid_get_consumer_report();

4
app/include/zmk/keymap.h
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
bool zmk_keymap_layer_activate(u8_t layer); int zmk_keymap_layer_activate(u8_t layer);
bool zmk_keymap_layer_deactivate(u8_t layer); int zmk_keymap_layer_deactivate(u8_t layer);
int zmk_keymap_position_state_changed(u32_t position, bool pressed); int zmk_keymap_position_state_changed(u32_t position, bool pressed);

51
app/src/behaviors/behavior_hid.c
View file

@ -24,22 +24,53 @@ static int behavior_hid_init(struct device *dev)
return 0; return 0;
}; };
static int on_keycode_pressed(struct device *dev, u32_t keycode) static int on_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode)
{ {
enum zmk_hid_report_changes changes; int err;
LOG_DBG("keycode %d", keycode); LOG_DBG("keycode %d", keycode);
changes = zmk_hid_press_key(keycode); switch (usage_page) {
return zmk_endpoints_send_report(changes); case USAGE_KEYPAD:
err = zmk_hid_keypad_press(keycode);
if (err) {
LOG_ERR("Unable to press keycode");
return err;
}
break;
case USAGE_CONSUMER:
err = zmk_hid_consumer_press(keycode);
if (err) {
LOG_ERR("Unable to press keycode");
return err;
}
break;
}
return zmk_endpoints_send_report(usage_page);
} }
static int on_keycode_released(struct device *dev, u32_t keycode) static int on_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode)
{ {
enum zmk_hid_report_changes changes; int err;
LOG_DBG("keycode %d", keycode); LOG_DBG("keycode %d", keycode);
changes = zmk_hid_release_key(keycode); switch (usage_page) {
return zmk_endpoints_send_report(changes); case USAGE_KEYPAD:
err = zmk_hid_keypad_release(keycode);
if (err) {
LOG_ERR("Unable to press keycode");
return err;
}
break;
case USAGE_CONSUMER:
err = zmk_hid_consumer_release(keycode);
if (err) {
LOG_ERR("Unable to press keycode");
return err;
}
break;
}
return zmk_endpoints_send_report(usage_page);
} }
static int on_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers) static int on_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers)
@ -47,7 +78,7 @@ static int on_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers)
LOG_DBG("modifiers %d", modifiers); LOG_DBG("modifiers %d", modifiers);
zmk_hid_register_mods(modifiers); zmk_hid_register_mods(modifiers);
return zmk_endpoints_send_report(Keypad); return zmk_endpoints_send_report(USAGE_KEYPAD);
} }
static int on_modifiers_released(struct device *dev, zmk_mod_flags modifiers) static int on_modifiers_released(struct device *dev, zmk_mod_flags modifiers)
@ -55,7 +86,7 @@ static int on_modifiers_released(struct device *dev, zmk_mod_flags modifiers)
LOG_DBG("modifiers %d", modifiers); LOG_DBG("modifiers %d", modifiers);
zmk_hid_unregister_mods(modifiers); zmk_hid_unregister_mods(modifiers);
return zmk_endpoints_send_report(Keypad); return zmk_endpoints_send_report(USAGE_KEYPAD);
} }
static const struct behavior_driver_api behavior_hid_driver_api = { static const struct behavior_driver_api behavior_hid_driver_api = {

48
app/src/behaviors/behavior_key_press.c
View file

@ -14,7 +14,9 @@
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct behavior_key_press_config { }; struct behavior_key_press_config {
u8_t usage_page;
};
struct behavior_key_press_data { }; struct behavior_key_press_data { };
static int behavior_key_press_init(struct device *dev) static int behavior_key_press_init(struct device *dev)
@ -22,44 +24,34 @@ static int behavior_key_press_init(struct device *dev)
return 0; return 0;
}; };
// They keycode is passed by the "keymap" based on the parameter created as part of the assignment.
// Other drivers instead might activate a layer, update the consumer page state, or update the RGB state, etc.
// Returns:
// * > 0 - indicate successful processing, and halt further handling,
// * 0 - Indicate successful processing, and continue propagation.
// * < 0 - Indicate error processing, report and halt further propagation.
static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t keycode, u32_t _) static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t keycode, u32_t _)
{ {
LOG_DBG("position %d keycode %d", position, keycode); const struct behavior_key_press_config *cfg = dev->config_info;
return zmk_events_keycode_pressed(keycode); LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", position, cfg->usage_page, keycode);
return zmk_events_keycode_pressed(cfg->usage_page, keycode);
} }
// They keycode is passed by the "keymap" based on the parameter created as part of the assignment.
static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t keycode, u32_t _) static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t keycode, u32_t _)
{ {
LOG_DBG("position %d keycode %d", position, keycode); const struct behavior_key_press_config *cfg = dev->config_info;
return zmk_events_keycode_released(keycode); LOG_DBG("position %d usage_page 0x%02X keycode 0x%02X", position, cfg->usage_page, keycode);
return zmk_events_keycode_released(cfg->usage_page, keycode);
} }
static const struct behavior_driver_api behavior_key_press_driver_api = { static const struct behavior_driver_api behavior_key_press_driver_api = {
// These callbacks are all optional, and define which kinds of events the behavior can handle.
// They can reference local functions defined here, or shared event handlers.
.binding_pressed = on_keymap_binding_pressed, .binding_pressed = on_keymap_binding_pressed,
.binding_released = on_keymap_binding_released .binding_released = on_keymap_binding_released
// Other optional callbacks a behavior can implement
// .on_mouse_moved
// .on_sensor_data - Any behaviour that wants to be linked to a censor can implement this behavior
}; };
#define KP_INST(n) \
static const struct behavior_key_press_config behavior_key_press_config_##n = { \
.usage_page = DT_INST_PROP(n, usage_page) \
}; \
static struct behavior_key_press_data behavior_key_press_data_##n; \
DEVICE_AND_API_INIT(behavior_key_press_##n, DT_INST_LABEL(n), behavior_key_press_init, \
&behavior_key_press_data_##n, \
&behavior_key_press_config_##n, \
APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, \
&behavior_key_press_driver_api);
static const struct behavior_key_press_config behavior_key_press_config = {}; DT_INST_FOREACH_STATUS_OKAY(KP_INST)
static struct behavior_key_press_data behavior_key_press_data;
DEVICE_AND_API_INIT(behavior_key_press, DT_INST_LABEL(0), behavior_key_press_init,
&behavior_key_press_data,
&behavior_key_press_config,
APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
&behavior_key_press_driver_api);

11
app/src/behaviors/behavior_mod_tap.c
View file

@ -40,17 +40,17 @@ static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t
struct behavior_mod_tap_data *data = dev->driver_data; struct behavior_mod_tap_data *data = dev->driver_data;
LOG_DBG("mods: %d, keycode: %d", mods, keycode); LOG_DBG("mods: %d, keycode: %d", mods, keycode);
zmk_events_modifiers_released(mods); zmk_events_modifiers_released(mods);
if (data->pending_press_positions & BIT(position)) { if (data->pending_press_positions & BIT(position)) {
zmk_events_keycode_pressed(keycode); zmk_events_keycode_pressed(USAGE_KEYPAD, keycode);
k_msleep(10); k_msleep(10);
zmk_events_keycode_released(keycode); zmk_events_keycode_released(USAGE_KEYPAD, keycode);
} }
return 0; return 0;
} }
static int on_keycode_pressed(struct device *dev, u32_t keycode) static int on_keycode_pressed(struct device *dev, u8_t usage_page, u32_t keycode)
{ {
struct behavior_mod_tap_data *data = dev->driver_data; struct behavior_mod_tap_data *data = dev->driver_data;
data->pending_press_positions = 0; data->pending_press_positions = 0;
@ -58,8 +58,7 @@ static int on_keycode_pressed(struct device *dev, u32_t keycode)
return 0; return 0;
} }
static int on_keycode_released(struct device *dev, u8_t usage_page, u32_t keycode)
static int on_keycode_released(struct device *dev, u32_t keycode)
{ {
LOG_DBG("releasing: %d", keycode); LOG_DBG("releasing: %d", keycode);
return 0; return 0;

8
app/src/behaviors/behavior_momentary_layer.c
View file

@ -24,14 +24,14 @@ static int behavior_mo_init(struct device *dev)
}; };
static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _) static int mo_keymap_binding_pressed(struct device *dev, u32_t position, u32_t layer, u32_t _)
{ {
LOG_DBG("position %d layer %d", position, layer); LOG_DBG("position %d layer %d", position, layer);
return zmk_keymap_layer_activate(layer); return zmk_keymap_layer_activate(layer);
} }
static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _) static int mo_keymap_binding_released(struct device *dev, u32_t position, u32_t layer, u32_t _)
{ {
LOG_DBG("position %d layer %d", position, layer); LOG_DBG("position %d layer %d", position, layer);
@ -39,8 +39,8 @@ static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t
} }
static const struct behavior_driver_api behavior_mo_driver_api = { static const struct behavior_driver_api behavior_mo_driver_api = {
.binding_pressed = on_keymap_binding_pressed, .binding_pressed = mo_keymap_binding_pressed,
.binding_released = on_keymap_binding_released .binding_released = mo_keymap_binding_released
}; };

32
app/src/endpoints.c
View file

@ -3,6 +3,7 @@
#include <zmk/hid.h> #include <zmk/hid.h>
#include <zmk/usb_hid.h> #include <zmk/usb_hid.h>
#include <zmk/hog.h> #include <zmk/hog.h>
#
#include <logging/log.h> #include <logging/log.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
@ -35,15 +36,15 @@ int zmk_endpoints_init()
return 0; return 0;
} }
int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type) int zmk_endpoints_send_report(u8_t usage_page)
{ {
int err; int err;
struct zmk_hid_keypad_report *keypad_report; struct zmk_hid_keypad_report *keypad_report;
struct zmk_hid_consumer_report *consumer_report; struct zmk_hid_consumer_report *consumer_report;
LOG_DBG(""); LOG_DBG("usage page 0x%02X", usage_page);
switch (report_type) switch (usage_page)
{ {
case Keypad: case USAGE_KEYPAD:
keypad_report = zmk_hid_get_keypad_report(); keypad_report = zmk_hid_get_keypad_report();
#ifdef CONFIG_ZMK_USB #ifdef CONFIG_ZMK_USB
if (zmk_usb_hid_send_report((u8_t *)keypad_report, sizeof(struct zmk_hid_keypad_report)) != 0) if (zmk_usb_hid_send_report((u8_t *)keypad_report, sizeof(struct zmk_hid_keypad_report)) != 0)
@ -61,7 +62,7 @@ int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type)
#endif /* CONFIG_ZMK_BLE */ #endif /* CONFIG_ZMK_BLE */
break; break;
case Consumer: case USAGE_CONSUMER:
consumer_report = zmk_hid_get_consumer_report(); consumer_report = zmk_hid_get_consumer_report();
#ifdef CONFIG_ZMK_USB #ifdef CONFIG_ZMK_USB
if (zmk_usb_hid_send_report((u8_t *)consumer_report, sizeof(struct zmk_hid_consumer_report)) != 0) if (zmk_usb_hid_send_report((u8_t *)consumer_report, sizeof(struct zmk_hid_consumer_report)) != 0)
@ -80,27 +81,10 @@ int zmk_endpoints_send_report(enum zmk_hid_report_changes report_type)
break; break;
default: default:
LOG_ERR("Unknown report change type %d", report_type); LOG_ERR("Unsupported usage page %d", usage_page);
return -EINVAL; return -ENOTSUP;
} }
return 0; return 0;
} }
int zmk_endpoints_send_key_event(struct zmk_key_event key_event)
{
enum zmk_hid_report_changes changes;
LOG_DBG("key %d, state %d\n", key_event.key, key_event.pressed);
if (key_event.pressed)
{
changes = zmk_hid_press_key(key_event.key);
}
else
{
changes = zmk_hid_release_key(key_event.key);
}
return zmk_endpoints_send_report(changes);
}

8
app/src/events.c
View file

@ -33,22 +33,22 @@ int zmk_events_position_released(u32_t position)
return 0; return 0;
}; };
int zmk_events_keycode_pressed(u32_t keycode) int zmk_events_keycode_pressed(u8_t usage_page, u32_t keycode)
{ {
for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const char* label = global_behaviors[i]; const char* label = global_behaviors[i];
struct device *dev = device_get_binding(label); struct device *dev = device_get_binding(label);
behavior_keycode_pressed(dev, keycode); behavior_keycode_pressed(dev, usage_page, keycode);
} }
return 0; return 0;
}; };
int zmk_events_keycode_released(u32_t keycode) int zmk_events_keycode_released(u8_t usage_page, u32_t keycode)
{ {
for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) { for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const char* label = global_behaviors[i]; const char* label = global_behaviors[i];
struct device *dev = device_get_binding(label); struct device *dev = device_get_binding(label);
behavior_keycode_released(dev, keycode); behavior_keycode_released(dev, usage_page, keycode);
} }
return 0; return 0;
}; };

78
app/src/hid.c
View file

@ -12,7 +12,7 @@ static struct zmk_hid_keypad_report kp_report = {
static struct zmk_hid_consumer_report consumer_report = { static struct zmk_hid_consumer_report consumer_report = {
.report_id = 2, .report_id = 2,
.body = { .body = {
.keys = 0x00}}; .keys = {0,0,0,0,0,0}}};
#define _TOGGLE_MOD(mod, state) \ #define _TOGGLE_MOD(mod, state) \
if (modifier > MOD_RGUI) \ if (modifier > MOD_RGUI) \
@ -61,62 +61,68 @@ int zmk_hid_unregister_mods(zmk_mod_flags modifiers)
#define TOGGLE_KEY(code, val) WRITE_BIT(kp_report.body.keys[code / 8], code % 8, val) #define TOGGLE_KEY(code, val) WRITE_BIT(kp_report.body.keys[code / 8], code % 8, val)
#define TOGGLE_CONSUMER(key, state) \ #define TOGGLE_CONSUMER(match, val) \
WRITE_BIT(consumer_report.body.keys, (key - 0x100), state); for (int idx = 0; idx < MAX_KEYS; idx++) \
{ \
if (consumer_report.body.keys[idx] != match) \
{ \
continue; \
} \
consumer_report.body.keys[idx] = val; \
break; \
}
enum zmk_hid_report_changes zmk_hid_press_key(zmk_key code)
int zmk_hid_keypad_press(zmk_key code)
{ {
if (code >= LCTL && code <= RGUI) if (code >= LCTL && code <= RGUI)
{ {
return zmk_hid_register_mod(code - LCTL); return zmk_hid_register_mod(code - LCTL);
} }
// if (ZK_IS_CONSUMER(code))
// {
// LOG_DBG("Toggling a consumer key!");
// TOGGLE_CONSUMER(code, true);
// return Consumer;
// }
// else
// {
if (code > ZMK_HID_MAX_KEYCODE)
{
return -EINVAL;
}
// TOGGLE_BOOT_KEY(0U, code); if (code > ZMK_HID_MAX_KEYCODE)
{
return -EINVAL;
}
TOGGLE_KEY(code, true); // TOGGLE_BOOT_KEY(0U, code);
return Keypad; TOGGLE_KEY(code, true);
// }
return 0;
}; };
enum zmk_hid_report_changes zmk_hid_release_key(zmk_key code) int zmk_hid_keypad_release(zmk_key code)
{ {
if (code >= LCTL && code <= RGUI) if (code >= LCTL && code <= RGUI)
{ {
return zmk_hid_unregister_mod(code - LCTL); return zmk_hid_unregister_mod(code - LCTL);
} }
// if (ZK_IS_CONSUMER(code)) if (code > ZMK_HID_MAX_KEYCODE)
// { {
// TOGGLE_CONSUMER(code, false); return -EINVAL;
// return Consumer; }
// }
// else
// {
if (code > ZMK_HID_MAX_KEYCODE)
{
return -EINVAL;
}
// TOGGLE_BOOT_KEY(0U, code); // TOGGLE_BOOT_KEY(0U, code);
TOGGLE_KEY(code, false); TOGGLE_KEY(code, false);
return Keypad; return 0;
// } };
int zmk_hid_consumer_press(zmk_key code)
{
TOGGLE_CONSUMER(0U, code);
return 0;
};
int zmk_hid_consumer_release(zmk_key code)
{
TOGGLE_CONSUMER(code, 0U);
return 0;
}; };
struct zmk_hid_keypad_report *zmk_hid_get_keypad_report() struct zmk_hid_keypad_report *zmk_hid_get_keypad_report()

10
app/src/keymap.c
View file

@ -62,17 +62,17 @@ static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_MATRIX_
#define SET_LAYER_STATE(layer, state) \ #define SET_LAYER_STATE(layer, state) \
if (layer >= 32) \ if (layer >= 32) \
{ \ { \
return false; \ return -EINVAL; \
} \ } \
WRITE_BIT(zmk_keymap_layer_state, layer, state); \ WRITE_BIT(zmk_keymap_layer_state, layer, state); \
return true; return 0;
bool zmk_keymap_layer_activate(u8_t layer) int zmk_keymap_layer_activate(u8_t layer)
{ {
SET_LAYER_STATE(layer, true); SET_LAYER_STATE(layer, true);
}; };
bool zmk_keymap_layer_deactivate(u8_t layer) int zmk_keymap_layer_deactivate(u8_t layer)
{ {
SET_LAYER_STATE(layer, false); SET_LAYER_STATE(layer, false);
}; };
@ -87,7 +87,7 @@ int zmk_keymap_position_state_changed(u32_t position, bool pressed)
struct device *behavior; struct device *behavior;
int ret; int ret;
LOG_DBG("position: %d, binding name: %s", position, binding->behavior_dev); LOG_DBG("layer: %d position: %d, binding name: %s", layer, position, binding->behavior_dev);
behavior = device_get_binding(binding->behavior_dev); behavior = device_get_binding(binding->behavior_dev);