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

Fix consumer keys w/ refactored behaviors.

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

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"
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_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);
__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
* @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.
*
* @retval 0 If successful.
* @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 *)dev->driver_api;
@ -151,21 +152,22 @@ static inline int z_impl_behavior_keycode_pressed(struct device *dev, u32_t keyc
return -ENOTSUP;
}
return api->keycode_pressed(dev, keycode);
return api->keycode_pressed(dev, usage_page, keycode);
}
/**
* @brief Handle the keycode being released
* @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.
*
* @retval 0 If successful.
* @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 *)dev->driver_api;
@ -174,7 +176,7 @@ static inline int z_impl_behavior_keycode_released(struct device *dev, u32_t key
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
#define USAGE_KEYPAD 0x07
#define USAGE_CONSUMER 0x0C
#define A 0x04
#define B 0x05
#define C 0x06
@ -104,14 +107,14 @@
/* The following are select consumer page usages */
#define MNXT 0x100
#define MPRV 0x101
#define MSTP 0x102
#define MJCT 0x103
#define MPLY 0x104
#define MMUT 0x105
#define MVLU 0x106
#define MVLD 0x107
#define M_NEXT 0xB5
#define M_PREV 0xB6
#define M_STOP 0xB7
#define M_EJCT 0xB8
#define M_PLAY 0xCD
#define M_MUTE 0xE2
#define M_VOLU 0xE9
#define M_VOLD 0xEA
#define MOD_LCTL (1 << 0x00)
#define MOD_LSFT (1 << 0x01)

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

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

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

@ -4,8 +4,8 @@
int zmk_events_position_pressed(u32_t position);
int zmk_events_position_released(u32_t position);
int zmk_events_keycode_pressed(u32_t keycode);
int zmk_events_keycode_released(u32_t keycode);
int zmk_events_keycode_pressed(u8_t usage_page, 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_released(zmk_mod_flags modifiers);
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,
/* LOGICAL_MAXIMUM (1) */
HID_GI_LOGICAL_MAX(1),
0x01,
/* USAGE (Scan Next Track) */
HID_LI_USAGE,
0xB5,
/* USAGE (Scan Previous Track) */
HID_LI_USAGE,
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,
0xFF,
HID_LI_USAGE_MIN(1),
0x00,
/* USAGE_MAXIMUM (Keyboard Application) */
HID_LI_USAGE_MAX(1),
0xFF,
/* INPUT (Data,Ary,Abs) */
/* REPORT_SIZE (1) */
/* REPORT_SIZE (8) */
HID_GI_REPORT_SIZE,
0x01,
0x08,
/* REPORT_COUNT (8) */
HID_GI_REPORT_COUNT,
0x08,
0x06,
HID_MI_INPUT,
0x02,
0x00,
/* END COLLECTION */
HID_MI_COLLECTION_END,
};
@ -167,7 +148,7 @@ struct zmk_hid_keypad_report
struct zmk_hid_consumer_report_body
{
u8_t keys;
u8_t keys[6];
} __packed;
struct zmk_hid_consumer_report
@ -176,19 +157,15 @@ struct zmk_hid_consumer_report
struct zmk_hid_consumer_report_body body;
} __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_unregister_mod(zmk_mod modifier);
int zmk_hid_register_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);
enum zmk_hid_report_changes zmk_hid_release_key(zmk_key key);
int zmk_hid_keypad_press(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_consumer_report *zmk_hid_get_consumer_report();

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

@ -1,6 +1,6 @@
#pragma once
bool zmk_keymap_layer_activate(u8_t layer);
bool zmk_keymap_layer_deactivate(u8_t layer);
int zmk_keymap_layer_activate(u8_t layer);
int zmk_keymap_layer_deactivate(u8_t layer);
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;
};
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);
changes = zmk_hid_press_key(keycode);
return zmk_endpoints_send_report(changes);
switch (usage_page) {
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);
changes = zmk_hid_release_key(keycode);
return zmk_endpoints_send_report(changes);
switch (usage_page) {
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)
@ -47,7 +78,7 @@ static int on_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers)
LOG_DBG("modifiers %d", 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)
@ -55,7 +86,7 @@ static int on_modifiers_released(struct device *dev, zmk_mod_flags modifiers)
LOG_DBG("modifiers %d", 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 = {

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

@ -14,7 +14,9 @@
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 { };
static int behavior_key_press_init(struct device *dev)
@ -22,44 +24,34 @@ static int behavior_key_press_init(struct device *dev)
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 _)
{
LOG_DBG("position %d keycode %d", position, keycode);
return zmk_events_keycode_pressed(keycode);
const struct behavior_key_press_config *cfg = dev->config_info;
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 _)
{
LOG_DBG("position %d keycode %d", position, keycode);
return zmk_events_keycode_released(keycode);
const struct behavior_key_press_config *cfg = dev->config_info;
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 = {
// 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_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 = {};
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);
DT_INST_FOREACH_STATUS_OKAY(KP_INST)

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;
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)) {
zmk_events_keycode_pressed(keycode);
zmk_events_keycode_pressed(USAGE_KEYPAD, keycode);
k_msleep(10);
zmk_events_keycode_released(keycode);
zmk_events_keycode_released(USAGE_KEYPAD, keycode);
}
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;
data->pending_press_positions = 0;
@ -58,8 +58,7 @@ static int on_keycode_pressed(struct device *dev, u32_t keycode)
return 0;
}
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)
{
LOG_DBG("releasing: %d", keycode);
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);
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);
@ -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 = {
.binding_pressed = on_keymap_binding_pressed,
.binding_released = on_keymap_binding_released
.binding_pressed = mo_keymap_binding_pressed,
.binding_released = mo_keymap_binding_released
};

32
app/src/endpoints.c
View File

@ -3,6 +3,7 @@
#include <zmk/hid.h>
#include <zmk/usb_hid.h>
#include <zmk/hog.h>
#
#include <logging/log.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
@ -35,15 +36,15 @@ int zmk_endpoints_init()
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;
struct zmk_hid_keypad_report *keypad_report;
struct zmk_hid_consumer_report *consumer_report;
LOG_DBG("");
switch (report_type)
LOG_DBG("usage page 0x%02X", usage_page);
switch (usage_page)
{
case Keypad:
case USAGE_KEYPAD:
keypad_report = zmk_hid_get_keypad_report();
#ifdef CONFIG_ZMK_USB
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 */
break;
case Consumer:
case USAGE_CONSUMER:
consumer_report = zmk_hid_get_consumer_report();
#ifdef CONFIG_ZMK_USB
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;
default:
LOG_ERR("Unknown report change type %d", report_type);
return -EINVAL;
LOG_ERR("Unsupported usage page %d", usage_page);
return -ENOTSUP;
}
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;
};
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++) {
const char* label = global_behaviors[i];
struct device *dev = device_get_binding(label);
behavior_keycode_pressed(dev, keycode);
behavior_keycode_pressed(dev, usage_page, keycode);
}
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++) {
const char* label = global_behaviors[i];
struct device *dev = device_get_binding(label);
behavior_keycode_released(dev, keycode);
behavior_keycode_released(dev, usage_page, keycode);
}
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 = {
.report_id = 2,
.body = {
.keys = 0x00}};
.keys = {0,0,0,0,0,0}}};
#define _TOGGLE_MOD(mod, state) \
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_CONSUMER(key, state) \
WRITE_BIT(consumer_report.body.keys, (key - 0x100), state);
#define TOGGLE_CONSUMER(match, val) \
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)
{
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;
}
if (code > ZMK_HID_MAX_KEYCODE)
{
return -EINVAL;
}
// TOGGLE_BOOT_KEY(0U, code);
// TOGGLE_BOOT_KEY(0U, code);
TOGGLE_KEY(code, true);
TOGGLE_KEY(code, true);
return Keypad;
// }
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)
{
return zmk_hid_unregister_mod(code - LCTL);
}
// if (ZK_IS_CONSUMER(code))
// {
// TOGGLE_CONSUMER(code, false);
// return Consumer;
// }
// else
// {
if (code > ZMK_HID_MAX_KEYCODE)
{
return -EINVAL;
}
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()

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) \
if (layer >= 32) \
{ \
return false; \
return -EINVAL; \
} \
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);
};
bool zmk_keymap_layer_deactivate(u8_t layer)
int zmk_keymap_layer_deactivate(u8_t layer)
{
SET_LAYER_STATE(layer, false);
};
@ -87,7 +87,7 @@ int zmk_keymap_position_state_changed(u32_t position, bool pressed)
struct device *behavior;
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);