Browse Source

Refactor global bindings, implement mod-tap.

* Use extra comptible = "zmk,behavior-global" to add
   behaviors to global bindings for event notification.
* Implement mod-tap, as a keymap binding and global one
  to skip tap if other keycode pressed while held.
xmkb
Pete Johanson 4 years ago
parent
commit
223edf05ad
  1. 1
      app/CMakeLists.txt
  2. 9
      app/boards/native_posix.overlay
  3. 6
      app/boards/shields/kyria/kyria.overlay
  4. 5
      app/boards/shields/petejohanson_handwire/keymap/keymap.overlay
  5. 2
      app/dts/behaviors/hid.dtsi
  6. 2
      app/dts/behaviors/keymap.dtsi
  7. 9
      app/dts/behaviors/mod_tap.dtsi
  8. 8
      app/dts/bindings/behaviors/zmk,behavior-mod-tap.yaml
  9. 9
      app/dts/bindings/zmk,global-bindings.yaml
  10. 119
      app/include/drivers/behavior.h
  11. 6
      app/include/zmk/events.h
  12. 8
      app/include/zmk/keymap.h
  13. 2
      app/include/zmk/matrix.h
  14. 20
      app/src/behaviors/behavior_hid.c
  15. 12
      app/src/behaviors/behavior_key_press.c
  16. 6
      app/src/behaviors/behavior_keymap.c
  17. 89
      app/src/behaviors/behavior_mod_tap.c
  18. 10
      app/src/behaviors/behavior_reset.c
  19. 67
      app/src/events.c
  20. 13
      app/src/keymap.c

1
app/CMakeLists.txt

@ -36,6 +36,7 @@ target_sources(app PRIVATE src/behaviors/behavior_keymap.c)
target_sources(app PRIVATE src/behaviors/behavior_hid.c) target_sources(app PRIVATE src/behaviors/behavior_hid.c)
target_sources(app PRIVATE src/behaviors/behavior_key_press.c) target_sources(app PRIVATE src/behaviors/behavior_key_press.c)
target_sources(app PRIVATE src/behaviors/behavior_reset.c) target_sources(app PRIVATE src/behaviors/behavior_reset.c)
target_sources(app PRIVATE src/behaviors/behavior_mod_tap.c)
target_sources_ifdef(CONFIG_ZMK_BLE app PRIVATE src/ble.c) target_sources_ifdef(CONFIG_ZMK_BLE app PRIVATE src/ble.c)
target_sources_ifdef(CONFIG_ZMK_KSCAN_MOCK_DRIVER app PRIVATE src/kscan_mock.c) target_sources_ifdef(CONFIG_ZMK_KSCAN_MOCK_DRIVER app PRIVATE src/kscan_mock.c)
target_sources_ifdef(CONFIG_ZMK_KSCAN_COMPOSITE_DRIVER app PRIVATE src/kscan_composite.c) target_sources_ifdef(CONFIG_ZMK_KSCAN_COMPOSITE_DRIVER app PRIVATE src/kscan_composite.c)

9
app/boards/native_posix.overlay

@ -1,5 +1,6 @@
#include <dt-bindings/zmk/keys.h> #include <dt-bindings/zmk/keys.h>
#include <behaviors/key_press.dtsi> #include <behaviors/key_press.dtsi>
#include <behaviors/mod_tap.dtsi>
#include <behaviors/reset.dtsi> #include <behaviors/reset.dtsi>
#include <behaviors/keymap.dtsi> #include <behaviors/keymap.dtsi>
#include <behaviors/hid.dtsi> #include <behaviors/hid.dtsi>
@ -9,12 +10,6 @@
chosen { chosen {
zmk,kscan = &kscan0; zmk,kscan = &kscan0;
zmk,keymap = &keymap0; zmk,keymap = &keymap0;
zmk,global_bindings = &bindings;
};
bindings: global_bindings {
compatible = "zmk,global-bindings";
bindings = <&keymap_behavior &hid_behavior>;
}; };
kscan0: kscan_0 { kscan0: kscan_0 {
@ -70,7 +65,7 @@
>; >;
bindings = < bindings = <
&kp 5 &kp 0 &kp 10 &kp 11 &kp 5 &mt MOD_LSFT KC_B &kp 10 &kp 11
&kp 1 &kp 2 &kp 4 &kp 89>; &kp 1 &kp 2 &kp 4 &kp 89>;
}; };

6
app/boards/shields/kyria/kyria.overlay

@ -12,12 +12,6 @@
chosen { chosen {
zmk,kscan = &kscan0; zmk,kscan = &kscan0;
zmk,matrix_transform = &default_transform; zmk,matrix_transform = &default_transform;
zmk,global_bindings = &bindings;
};
bindings: global_bindings {
compatible = "zmk,global-bindings";
bindings = <&keymap_behavior &hid_behavior>;
}; };
kscan0: kscan_comp { kscan0: kscan_comp {

5
app/boards/shields/petejohanson_handwire/keymap/keymap.overlay

@ -7,13 +7,8 @@
/ { / {
chosen { chosen {
zmk,keymap = &keymap0; zmk,keymap = &keymap0;
zmk,global_bindings = &bindings;
}; };
bindings: global_bindings {
compatible = "zmk,global-bindings";
bindings = <&reset>;
};
keymap0: keymap { keymap0: keymap {
compatible = "zmk,keymap"; compatible = "zmk,keymap";
label ="Default keymap"; label ="Default keymap";

2
app/dts/behaviors/hid.dtsi

@ -1,7 +1,7 @@
/ { / {
behaviors { behaviors {
hid_behavior: behavior_hid { hid_behavior: behavior_hid {
compatible = "zmk,behavior-hid"; compatible = "zmk,behavior-hid", "zmk,behavior-global";
label = "HID"; label = "HID";
#binding-cells = <0>; #binding-cells = <0>;
}; };

2
app/dts/behaviors/keymap.dtsi

@ -1,7 +1,7 @@
/ { / {
behaviors { behaviors {
keymap_behavior: behavior_keymap { keymap_behavior: behavior_keymap {
compatible = "zmk,behavior-keymap"; compatible = "zmk,behavior-keymap", "zmk,behavior-global";
label = "KEYMAP"; label = "KEYMAP";
#binding-cells = <0>; #binding-cells = <0>;
}; };

9
app/dts/behaviors/mod_tap.dtsi

@ -0,0 +1,9 @@
/ {
behaviors {
mt: behavior_mod_tap {
compatible = "zmk,behavior-mod-tap", "zmk,behavior-global";
label = "MOD_TAP";
#binding-cells = <2>;
};
};
};

8
app/dts/bindings/behaviors/zmk,behavior-mod-tap.yaml

@ -0,0 +1,8 @@
# Copyright (c) 2020, Pete Johanson
# SPDX-License-Identifier: MIT
description: Mod-Tap Beavhior
compatible: "zmk,behavior-mod-tap"
include: two_param.yaml

9
app/dts/bindings/zmk,global-bindings.yaml

@ -1,9 +0,0 @@
description: |
Specify the the global behaviors bound to state changes
compatible: "zmk,global-bindings"
properties:
bindings:
type: phandles
required: true

119
app/include/drivers/behavior.h

@ -9,6 +9,7 @@
#include <zephyr/types.h> #include <zephyr/types.h>
#include <stddef.h> #include <stddef.h>
#include <device.h> #include <device.h>
#include <zmk/keys.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -22,30 +23,36 @@ extern "C" {
* (Internal use only.) * (Internal use only.)
*/ */
typedef int (*behavior_position_callback_t)(struct device *dev, u32_t param1, u32_t param2); 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, u32_t keycode);
typedef int (*behavior_modifiers_callback_t)(struct device *dev, zmk_mod_flags modifiers);
__subsystem struct behavior_driver_api { __subsystem struct behavior_driver_api {
behavior_position_callback_t position_pressed; behavior_position_callback_t position_pressed;
behavior_position_callback_t position_released; behavior_position_callback_t position_released;
behavior_keymap_binding_callback_t binding_pressed;
behavior_keymap_binding_callback_t binding_released;
behavior_keycode_callback_t keycode_pressed; behavior_keycode_callback_t keycode_pressed;
behavior_keycode_callback_t keycode_released; behavior_keycode_callback_t keycode_released;
behavior_modifiers_callback_t modifiers_pressed;
behavior_modifiers_callback_t modifiers_released;
}; };
/** /**
* @endcond * @endcond
*/ */
/** /**
* @brief Handle the assigned position being pressed * @brief Handle the key position 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 param1 User parameter specified at time of behavior assignment. * @param position They key position that was pressed
* *
* @retval 0 If successful. * @retval 0 If successful.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int behavior_position_pressed(struct device *dev, u32_t param1, u32_t param2); __syscall int behavior_position_pressed(struct device *dev, u32_t position);
static inline int z_impl_behavior_position_pressed(struct device *dev, u32_t param1, u32_t param2) static inline int z_impl_behavior_position_pressed(struct device *dev, u32_t position)
{ {
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;
@ -54,7 +61,52 @@ static inline int z_impl_behavior_position_pressed(struct device *dev, u32_t par
return -ENOTSUP; return -ENOTSUP;
} }
return api->position_pressed(dev, param1, param2); return api->position_pressed(dev, position);
}
/**
* @brief Handle the key position being released
* @param dev Pointer to the device structure for the driver instance.
* @param position They key position that was released
*
* @retval 0 If successful.
* @retval Negative errno code if failure.
*/
__syscall int behavior_position_released(struct device *dev, u32_t position);
static inline int z_impl_behavior_position_released(struct device *dev, u32_t position)
{
const struct behavior_driver_api *api =
(const struct behavior_driver_api *)dev->driver_api;
if (api->position_released == NULL) {
return -ENOTSUP;
}
return api->position_released(dev, position);
}
/**
* @brief Handle the keymap binding being pressed
* @param dev Pointer to the device structure for the driver instance.
* @param param1 User parameter specified at time of behavior binding.
* @param param2 User parameter specified at time of behavior binding.
*
* @retval 0 If successful.
* @retval Negative errno code if failure.
*/
__syscall int behavior_keymap_binding_pressed(struct device *dev, u32_t position, u32_t param1, u32_t param2);
static inline int z_impl_behavior_keymap_binding_pressed(struct device *dev, u32_t position, u32_t param1, u32_t param2)
{
const struct behavior_driver_api *api =
(const struct behavior_driver_api *)dev->driver_api;
if (api->binding_pressed == NULL) {
return -ENOTSUP;
}
return api->binding_pressed(dev, position, param1, param2);
} }
/** /**
@ -65,20 +117,21 @@ static inline int z_impl_behavior_position_pressed(struct device *dev, u32_t par
* @retval 0 If successful. * @retval 0 If successful.
* @retval Negative errno code if failure. * @retval Negative errno code if failure.
*/ */
__syscall int behavior_position_released(struct device *dev, u32_t param1, u32_t param2); __syscall int behavior_keymap_binding_released(struct device *dev, u32_t position, u32_t param1, u32_t param2);
static inline int z_impl_behavior_position_released(struct device *dev, u32_t param1, u32_t param2) static inline int z_impl_behavior_keymap_binding_released(struct device *dev, u32_t position, u32_t param1, u32_t param2)
{ {
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;
if (api->position_released == NULL) { if (api->binding_released == NULL) {
return -ENOTSUP; return -ENOTSUP;
} }
return api->position_released(dev, param1, param2); return api->binding_released(dev, position, param1, param2);
} }
/** /**
* @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.
@ -124,6 +177,52 @@ static inline int z_impl_behavior_keycode_released(struct device *dev, u32_t key
return api->keycode_released(dev, keycode); return api->keycode_released(dev, keycode);
} }
/**
* @brief Handle the keycode being pressed
* @param dev Pointer to the device structure for the driver instance.
* @param keycode The keycode that is being pressed.
*
* @retval 0 If successful.
* @retval Negative errno code if failure.
*/
__syscall int behavior_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers);
static inline int z_impl_behavior_modifiers_pressed(struct device *dev, zmk_mod_flags modifiers)
{
const struct behavior_driver_api *api =
(const struct behavior_driver_api *)dev->driver_api;
if (api->modifiers_pressed == NULL) {
return -ENOTSUP;
}
return api->modifiers_pressed(dev, modifiers);
}
/**
* @brief Handle the keycode being released
* @param dev Pointer to the device structure for the driver instance.
* @param keycode The keycode that is being pressed.
*
* @retval 0 If successful.
* @retval Negative errno code if failure.
*/
__syscall int behavior_modifiers_released(struct device *dev, zmk_mod_flags modifiers);
static inline int z_impl_behavior_modifiers_released(struct device *dev, zmk_mod_flags modifiers)
{
const struct behavior_driver_api *api =
(const struct behavior_driver_api *)dev->driver_api;
if (api->modifiers_released == NULL) {
return -ENOTSUP;
}
return api->modifiers_released(dev, modifiers);
}
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
app/include/zmk/events.h

@ -1,11 +1,13 @@
#pragma once #pragma once
#include <zmk/keys.h>
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(u32_t keycode);
int zmk_events_keycode_released(u32_t keycode); int zmk_events_keycode_released(u32_t keycode);
int zmk_events_mod_pressed(u32_t modifier); int zmk_events_modifiers_pressed(zmk_mod_flags modifiers);
int zmk_events_mod_released(u32_t modifier); 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);
int zmk_events_consumer_key_released(u32_t usage); int zmk_events_consumer_key_released(u32_t usage);

8
app/include/zmk/keymap.h

@ -1,13 +1,5 @@
#pragma once #pragma once
#include <devicetree.h>
#include <usb/usb_device.h>
#include <usb/class/usb_hid.h>
#include <dt-bindings/zmk/keys.h>
#include <zmk/matrix.h>
// #include <zmk/keys.h>
bool zmk_keymap_layer_activate(u8_t layer); bool zmk_keymap_layer_activate(u8_t layer);
bool zmk_keymap_layer_deactivate(u8_t layer); bool zmk_keymap_layer_deactivate(u8_t layer);

2
app/include/zmk/matrix.h

@ -1,5 +1,7 @@
#pragma once #pragma once
#include <devicetree.h>
#define ZMK_MATRIX_NODE_ID DT_CHOSEN(zmk_kscan) #define ZMK_MATRIX_NODE_ID DT_CHOSEN(zmk_kscan)
#if DT_NODE_HAS_PROP(ZMK_MATRIX_NODE_ID,row_gpios) #if DT_NODE_HAS_PROP(ZMK_MATRIX_NODE_ID,row_gpios)

20
app/src/behaviors/behavior_hid.c

@ -42,9 +42,27 @@ static int on_keycode_released(struct device *dev, u32_t keycode)
return zmk_endpoints_send_report(changes); return zmk_endpoints_send_report(changes);
} }
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);
}
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);
}
static const struct behavior_driver_api behavior_hid_driver_api = { static const struct behavior_driver_api behavior_hid_driver_api = {
.keycode_pressed = on_keycode_pressed, .keycode_pressed = on_keycode_pressed,
.keycode_released = on_keycode_released .keycode_released = on_keycode_released,
.modifiers_pressed = on_modifiers_pressed,
.modifiers_released = on_modifiers_released
}; };

12
app/src/behaviors/behavior_key_press.c

@ -29,25 +29,25 @@ static int behavior_key_press_init(struct device *dev)
// * > 0 - indicate successful processing, and halt further handling, // * > 0 - indicate successful processing, and halt further handling,
// * 0 - Indicate successful processing, and continue propagation. // * 0 - Indicate successful processing, and continue propagation.
// * < 0 - Indicate error processing, report and halt further propagation. // * < 0 - Indicate error processing, report and halt further propagation.
static int on_position_pressed(struct device *dev, u32_t keycode, u32_t _) static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t keycode, u32_t _)
{ {
LOG_DBG("pressing: %d", keycode); LOG_DBG("position %d keycode %d", position, keycode);
return zmk_events_keycode_pressed(keycode); return zmk_events_keycode_pressed(keycode);
} }
// They keycode is passed by the "keymap" based on the parameter created as part of the assignment. // They keycode is passed by the "keymap" based on the parameter created as part of the assignment.
static int on_position_released(struct device *dev, u32_t keycode, u32_t _) static int on_keymap_binding_released(struct device *dev, u32_t position, u32_t keycode, u32_t _)
{ {
LOG_DBG("releasing: %d", keycode); LOG_DBG("position %d keycode %d", position, keycode);
return zmk_events_keycode_released(keycode); return zmk_events_keycode_released(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. // 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. // They can reference local functions defined here, or shared event handlers.
.position_pressed = on_position_pressed, .binding_pressed = on_keymap_binding_pressed,
.position_released = on_position_released .binding_released = on_keymap_binding_released
// Other optional callbacks a behavior can implement // Other optional callbacks a behavior can implement
// .on_mouse_moved // .on_mouse_moved
// .on_sensor_data - Any behaviour that wants to be linked to a censor can implement this behavior // .on_sensor_data - Any behaviour that wants to be linked to a censor can implement this behavior

6
app/src/behaviors/behavior_keymap.c

@ -23,19 +23,19 @@ static int behavior_keymap_init(struct device *dev)
return 0; return 0;
}; };
static int on_position_pressed(struct device *dev, u32_t position, u32_t _) static int on_position_pressed(struct device *dev, u32_t position)
{ {
return zmk_keymap_position_state_changed(position, true); return zmk_keymap_position_state_changed(position, true);
} }
static int on_position_released(struct device *dev, u32_t position, u32_t _) static int on_position_released(struct device *dev, u32_t position)
{ {
return zmk_keymap_position_state_changed(position, false); return zmk_keymap_position_state_changed(position, false);
} }
static const struct behavior_driver_api behavior_keymap_driver_api = { static const struct behavior_driver_api behavior_keymap_driver_api = {
.position_pressed = on_position_pressed, .position_pressed = on_position_pressed,
.position_released = on_position_released .position_released = on_position_released,
}; };

89
app/src/behaviors/behavior_mod_tap.c

@ -0,0 +1,89 @@
/*
* Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
*
* SPDX-License-Identifier: MIT
*/
#define DT_DRV_COMPAT zmk_behavior_mod_tap
#include <device.h>
#include <drivers/behavior.h>
#include <logging/log.h>
#include <zmk/events.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct behavior_mod_tap_config { };
struct behavior_mod_tap_data {
u16_t pending_press_positions;
};
static int behavior_mod_tap_init(struct device *dev)
{
return 0;
};
static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t mods, u32_t keycode)
{
struct behavior_mod_tap_data *data = dev->driver_data;
LOG_DBG("mods: %d, keycode: %d", mods, keycode);
WRITE_BIT(data->pending_press_positions, position, true);
return zmk_events_modifiers_pressed(mods);
}
// 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 mods, u32_t keycode)
{
struct behavior_mod_tap_data *data = dev->driver_data;
LOG_DBG("mods: %d, keycode: %d", mods, keycode);
zmk_events_modifiers_released(mods);
if (data->pending_press_positions & BIT(position)) {
zmk_events_keycode_pressed(keycode);
k_msleep(10);
zmk_events_keycode_released(keycode);
}
return 0;
}
static int on_keycode_pressed(struct device *dev, u32_t keycode)
{
struct behavior_mod_tap_data *data = dev->driver_data;
data->pending_press_positions = 0;
LOG_DBG("pressing: %d", keycode);
return 0;
}
static int on_keycode_released(struct device *dev, u32_t keycode)
{
LOG_DBG("releasing: %d", keycode);
return 0;
}
static const struct behavior_driver_api behavior_mod_tap_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,
.keycode_pressed = on_keycode_pressed,
.keycode_released = on_keycode_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
};
static const struct behavior_mod_tap_config behavior_mod_tap_config = {};
static struct behavior_mod_tap_data behavior_mod_tap_data;
DEVICE_AND_API_INIT(behavior_key_press, DT_INST_LABEL(0), behavior_mod_tap_init,
&behavior_mod_tap_data,
&behavior_mod_tap_config,
APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,
&behavior_mod_tap_driver_api);

10
app/src/behaviors/behavior_reset.c

@ -21,7 +21,7 @@ static int behavior_reset_init(struct device *dev)
return 0; return 0;
}; };
static int on_position_pressed(struct device *dev, u32_t _param1, u32_t _param2) static int on_keymap_binding_pressed(struct device *dev, u32_t position, u32_t _param1, u32_t _param2)
{ {
// TODO: Correct magic code for going into DFU? // TODO: Correct magic code for going into DFU?
// See https://github.com/adafruit/Adafruit_nRF52_Bootloader/blob/d6b28e66053eea467166f44875e3c7ec741cb471/src/main.c#L107 // See https://github.com/adafruit/Adafruit_nRF52_Bootloader/blob/d6b28e66053eea467166f44875e3c7ec741cb471/src/main.c#L107
@ -29,14 +29,8 @@ static int on_position_pressed(struct device *dev, u32_t _param1, u32_t _param2)
return 0; return 0;
} }
static int on_position_released(struct device *dev, u32_t _param1, u32_t _param2)
{
return 0;
}
static const struct behavior_driver_api behavior_reset_driver_api = { static const struct behavior_driver_api behavior_reset_driver_api = {
.position_pressed = on_position_pressed, .binding_pressed = on_keymap_binding_pressed,
.position_released = on_position_released
}; };

67
app/src/events.c

@ -5,63 +5,74 @@
#include <zmk/events.h> #include <zmk/events.h>
#include <sys/util.h> #include <sys/util.h>
#define BINDINGS_NODE DT_CHOSEN(zmk_global_bindings) #define DT_DRV_COMPAT zmk_behavior_global
#define BINDING_COUNT DT_PROP_LEN(BINDINGS_NODE, bindings) #define GLOBAL_BEHAVIOR_LEN DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT)
#define BINDING_GEN(idx,_) \ #define LABEL_ENTRY(i) DT_INST_LABEL(i),
{ .behavior_dev = DT_LABEL(DT_PHANDLE_BY_IDX(BINDINGS_NODE, bindings, idx)), \ static const char *global_behaviors[] = {
.param1 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(BINDINGS_NODE, bindings, idx, param1), (0), (DT_PHA_BY_IDX(BINDINGS_NODE, bindings, idx, param1))), \ DT_INST_FOREACH_STATUS_OKAY(LABEL_ENTRY)
.param2 = COND_CODE_0(DT_PHA_HAS_CELL_AT_IDX(BINDINGS_NODE, bindings, idx, param2), (0), (DT_PHA_BY_IDX(BINDINGS_NODE, bindings, idx, param2))), \ };
},
static const struct zmk_behavior_binding bindings[] =
{ UTIL_LISTIFY(BINDING_COUNT, BINDING_GEN, 0) };
int zmk_events_position_pressed(u32_t position) int zmk_events_position_pressed(u32_t position)
{ {
for (int i = 0; i < BINDING_COUNT; i++) { for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const struct zmk_behavior_binding *b = &bindings[i]; const char* label = global_behaviors[i];
struct device *dev = device_get_binding(b->behavior_dev); struct device *dev = device_get_binding(label);
behavior_position_pressed(dev, position, 0); behavior_position_pressed(dev, position);
} }
return 0; return 0;
}; };
int zmk_events_position_released(u32_t position) int zmk_events_position_released(u32_t position)
{ {
for (int i = 0; i < BINDING_COUNT; i++) { for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const struct zmk_behavior_binding *b = &bindings[i]; const char* label = global_behaviors[i];
struct device *dev = device_get_binding(b->behavior_dev); struct device *dev = device_get_binding(label);
behavior_position_released(dev, position, 0); behavior_position_released(dev, position);
} }
return 0; return 0;
} };
int zmk_events_keycode_pressed(u32_t keycode) int zmk_events_keycode_pressed(u32_t keycode)
{ {
for (int i = 0; i < BINDING_COUNT; i++) { for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const struct zmk_behavior_binding *b = &bindings[i]; const char* label = global_behaviors[i];
struct device *dev = device_get_binding(b->behavior_dev); struct device *dev = device_get_binding(label);
behavior_keycode_pressed(dev, keycode); behavior_keycode_pressed(dev, keycode);
} }
return 0; return 0;
} };
int zmk_events_keycode_released(u32_t keycode) int zmk_events_keycode_released(u32_t keycode)
{ {
for (int i = 0; i < BINDING_COUNT; i++) { for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const struct zmk_behavior_binding *b = &bindings[i]; const char* label = global_behaviors[i];
struct device *dev = device_get_binding(b->behavior_dev); struct device *dev = device_get_binding(label);
behavior_keycode_released(dev, keycode); behavior_keycode_released(dev, keycode);
} }
return 0; return 0;
}; };
int zmk_events_mod_pressed(u32_t modifier)
int zmk_events_modifiers_pressed(zmk_mod_flags modifiers)
{ {
for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const char* label = global_behaviors[i];
struct device *dev = device_get_binding(label);
behavior_modifiers_pressed(dev, modifiers);
}
return 0; return 0;
}; };
int zmk_events_mod_released(u32_t modifier)
int zmk_events_modifiers_released(zmk_mod_flags modifiers)
{ {
for (int i = 0; i < GLOBAL_BEHAVIOR_LEN; i++) {
const char* label = global_behaviors[i];
struct device *dev = device_get_binding(label);
behavior_modifiers_released(dev, modifiers);
}
return 0; return 0;
}; };
int zmk_events_consumer_key_pressed(u32_t usage) int zmk_events_consumer_key_pressed(u32_t usage)
{ {
return 0; return 0;

13
app/src/keymap.c

@ -1,11 +1,13 @@
#include <sys/util.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);
#include <zmk/matrix.h>
#include <zmk/keymap.h> #include <zmk/keymap.h>
#include <dt-bindings/zmk/matrix-transform.h> #include <dt-bindings/zmk/matrix-transform.h>
#include <drivers/behavior.h> #include <drivers/behavior.h>
#include <zmk/behavior.h> #include <zmk/behavior.h>
#include <sys/util.h>
static u32_t zmk_keymap_layer_state = 0; static u32_t zmk_keymap_layer_state = 0;
static u8_t zmk_keymap_layer_default = 0; static u8_t zmk_keymap_layer_default = 0;
@ -88,10 +90,15 @@ int zmk_keymap_position_state_changed(u32_t position, bool pressed)
LOG_DBG("position: %d, binding name: %s", position, binding->behavior_dev); LOG_DBG("position: %d, binding name: %s", position, binding->behavior_dev);
behavior = device_get_binding(binding->behavior_dev); behavior = device_get_binding(binding->behavior_dev);
if (!behavior) {
LOG_DBG("No behavior assigned to %d on layer %d", position, layer);
continue;
}
if (pressed) { if (pressed) {
ret = behavior_position_pressed(behavior, binding->param1, binding->param2); ret = behavior_keymap_binding_pressed(behavior, position, binding->param1, binding->param2);
} else { } else {
ret = behavior_position_released(behavior, binding->param1, binding->param2); ret = behavior_keymap_binding_released(behavior, position, binding->param1, binding->param2);
} }

Loading…
Cancel
Save