Merge https://github.com/zmkfirmware/zmk into main

app/CMakeLists.txt

@@ -28,6 +28,7 @@ target_sources(app PRIVATE src/kscan.c)
 target_sources(app PRIVATE src/matrix_transform.c)
 target_sources(app PRIVATE src/hid.c)
 target_sources(app PRIVATE src/sensors.c)
+target_sources_ifdef(CONFIG_ZMK_WPM app PRIVATE src/wpm.c)
 target_sources(app PRIVATE src/event_manager.c)
 target_sources_ifdef(CONFIG_ZMK_EXT_POWER app PRIVATE src/ext_power_generic.c)
 target_sources(app PRIVATE src/events/activity_state_changed.c)
@@ -36,6 +37,7 @@ target_sources(app PRIVATE src/events/layer_state_changed.c)
 target_sources(app PRIVATE src/events/keycode_state_changed.c)
 target_sources(app PRIVATE src/events/modifiers_state_changed.c)
 target_sources(app PRIVATE src/events/sensor_event.c)
+target_sources_ifdef(CONFIG_ZMK_WPM app PRIVATE src/events/wpm_state_changed.c)
 target_sources_ifdef(CONFIG_ZMK_BLE app PRIVATE src/events/ble_active_profile_changed.c)
 target_sources_ifdef(CONFIG_ZMK_BLE app PRIVATE src/events/battery_state_changed.c)
 target_sources_ifdef(CONFIG_USB app PRIVATE src/events/usb_conn_state_changed.c)
@@ -45,6 +47,7 @@ if ((NOT CONFIG_ZMK_SPLIT) OR CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
   target_sources(app PRIVATE src/behaviors/behavior_hold_tap.c)
   target_sources(app PRIVATE src/behaviors/behavior_sticky_key.c)
   target_sources(app PRIVATE src/behaviors/behavior_momentary_layer.c)
+  target_sources(app PRIVATE src/behaviors/behavior_mod_morph.c)
   target_sources(app PRIVATE src/behaviors/behavior_outputs.c)
   target_sources(app PRIVATE src/behaviors/behavior_toggle_layer.c)
   target_sources(app PRIVATE src/behaviors/behavior_to_layer.c)

app/Kconfig

@@ -417,6 +417,10 @@ config REBOOT
 config USB
 	default y if HAS_HW_NRF_USBD
 
+config ZMK_WPM
+	bool "Calculate WPM"
+	default n
+
 module = ZMK
 module-str = zmk
 source "subsys/logging/Kconfig.template.log_config"

app/boards/shields/nibble/nibble.keymap

@@ -20,7 +20,7 @@
              &kp ESC   &kp N1    &kp N2    &kp N3    &kp N4    &kp N5    &kp N6    &kp N7    &kp N8    &kp N9    &kp N0    &kp MINUS &kp EQUAL &kp BSPC &kp HOME
 &kp C_VOL_UP &kp TAB   &kp Q     &kp W     &kp E     &kp R     &kp T     &kp Y     &kp U     &kp I     &kp O     &kp P     &kp LBKT  &kp RBKT  &kp BSLH &kp DEL
 &kp C_VOL_DN &kp CLCK  &kp A     &kp S     &kp D     &kp F     &kp G     &kp H     &kp J     &kp K     &kp L     &kp SEMI  &kp SQT             &kp RET  &kp PG_UP
-&trans       &kp LSHFT &kp Z     &kp X     &kp C     &kp V     &kp B     &kp N     &kp M     &kp COMMA &kp DOT   &kp FSLH  &kp RSHFT           &kp UP   &kp PG_DN
+&trans       &kp LSHFT &trans    &kp Z     &kp X     &kp C     &kp V     &kp B     &kp N     &kp M     &kp COMMA &kp DOT   &kp FSLH  &kp RSHFT &kp UP   &kp PG_DN
 &trans       &kp LCTRL &kp LGUI  &kp LALT                      &kp SPACE                     &mo FUNC  &kp RALT  &kp RCTRL &kp LEFT            &kp DOWN &kp RIGHT
             >;
         };
@@ -29,7 +29,7 @@
             &kp TILDE   &kp F1    &kp F2    &kp F3    &kp F4    &kp F5    &kp F6    &kp F7    &kp F8    &kp F9    &kp F10   &kp F11   &kp F12 &trans      &kp END
 &bt BT_CLR  &trans      &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans  &trans      &bootloader
 &trans      &trans      &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans            &trans      &trans
-&bt BT_PRV  &trans      &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans            &trans      &trans
+&bt BT_PRV  &trans      &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans    &trans  &trans      &trans
 &bt BT_NXT  &trans      &trans    &trans                        &trans                        &trans    &trans    &trans    &kp C_PREV        &kp C_PP    &kp C_NEXT
             >;
         };

app/boards/shields/nibble/nibble.overlay

@@ -21,7 +21,7 @@
 			, <&pro_micro_d 14 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
 			, <&pro_micro_d 16 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
 			, <&pro_micro_d 10 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
-			, <&pro_micro_d 4 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
+			, <&pro_micro_d 4  (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
 			;
 		output-gpios
 			= <&pro_micro_a 3 GPIO_ACTIVE_HIGH>
@@ -39,11 +39,11 @@
 		//TODO: Add a keymap graphic here
 
 		map = <
-		RC(0,1) RC(0,2) RC(0,3) RC(0,4) RC(0,5) RC(0,6) RC(0,7) RC(0,8) RC(0,9)  RC(0,10) RC(0,11) RC(0,12) RC(0,13) RC(0,14) RC(0,15)
+		RC(0,1) RC(0,2) RC(0,3) RC(0,4) RC(0,5) RC(0,6) RC(0,7) RC(0,8) RC(0,9) RC(0,10) RC(0,11) RC(0,12) RC(0,13) RC(0,14) RC(0,15)
-RC(1,0) RC(1,1) RC(1,2) RC(1,3) RC(1,4) RC(1,5) RC(1,6) RC(1,7) RC(1,8) RC(1,9)  RC(1,10) RC(1,11) RC(1,12) RC(1,13) RC(1,14) RC(1,15)
+RC(1,0) RC(1,1) RC(1,2) RC(1,3) RC(1,4) RC(1,5) RC(1,6) RC(1,7) RC(1,8) RC(1,9) RC(1,10) RC(1,11) RC(1,12) RC(1,13) RC(1,14) RC(1,15)
-RC(2,0) RC(2,1) RC(2,2) RC(2,3) RC(2,4) RC(2,5) RC(2,6) RC(2,7) RC(2,8) RC(2,9)  RC(2,10) RC(2,11) RC(2,12) 	     RC(2,14) RC(2,15)
+RC(2,0) RC(2,1) RC(2,2) RC(2,3) RC(2,4) RC(2,5) RC(2,6) RC(2,7) RC(2,8) RC(2,9) RC(2,10) RC(2,11) RC(2,12) 	        RC(2,14) RC(2,15)
-RC(3,0) RC(3,1) RC(3,2) RC(3,3) RC(3,4) RC(3,5) RC(3,6) RC(3,7) RC(3,8) RC(3,9)  RC(3,10) RC(3,11) RC(3,12)          RC(3,14) RC(3,15)
+RC(3,0) RC(3,1) RC(0,0) RC(3,2) RC(3,3) RC(3,4) RC(3,5) RC(3,6) RC(3,7) RC(3,8) RC(3,9)  RC(3,10) RC(3,11) RC(3,12) RC(3,14) RC(3,15)
-RC(4,0) RC(4,1) RC(4,2) RC(4,3)                 RC(4,6)                 RC(4,9)  RC(4,10) RC(4,11) RC(4,12)          RC(4,14) RC(4,15) 
+RC(4,0) RC(4,1) RC(4,2) RC(4,3)                 RC(4,6)                 RC(4,9) RC(4,10) RC(4,11) RC(4,12)          RC(4,14) RC(4,15) 
 		>;
 	};
 };

app/dts/behaviors.dtsi

@@ -3,6 +3,7 @@
 #include <behaviors/none.dtsi>
 #include <behaviors/mod_tap.dtsi>
 #include <behaviors/layer_tap.dtsi>
+#include <behaviors/gresc.dtsi>
 #include <behaviors/sticky_key.dtsi>
 #include <behaviors/momentary_layer.dtsi>
 #include <behaviors/toggle_layer.dtsi>

app/dts/behaviors/gresc.dtsi

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <dt-bindings/zmk/keys.h>
+
+/ {
+	behaviors {
+		/omit-if-no-ref/ gresc: grave_escape {
+			compatible = "zmk,behavior-mod-morph";
+			label = "GRAVE_ESCAPE";
+			#binding-cells = <0>;
+			bindings = <&kp ESC>, <&kp GRAVE>;
+            mods = <(MOD_LGUI|MOD_LSFT|MOD_RGUI|MOD_RSFT)>;
+		};
+	};
+};

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

@@ -0,0 +1,16 @@
+# Copyright (c) 2020 The ZMK Contributors
+# SPDX-License-Identifier: MIT
+
+description: Keyboard Reset Behavior
+
+compatible: "zmk,behavior-mod-morph"
+
+include: zero_param.yaml
+
+properties:
+  bindings:
+    type: phandle-array
+    required: true
+  mods:
+    type: int
+    required: true

app/include/zmk/display/widgets/wpm_status.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <lvgl.h>
+#include <kernel.h>
+
+struct zmk_widget_wpm_status {
+    sys_snode_t node;
+    lv_obj_t *obj;
+};
+
+int zmk_widget_wpm_status_init(struct zmk_widget_wpm_status *widget, lv_obj_t *parent);
+lv_obj_t *zmk_widget_wpm_status_obj(struct zmk_widget_wpm_status *widget);

app/include/zmk/event_manager.h

@@ -14,16 +14,16 @@ struct zmk_event_type {
     const char *name;
 };
 
-struct zmk_event_header {
+typedef struct {
     const struct zmk_event_type *event;
     uint8_t last_listener_index;
-};
+} zmk_event_t;
 
 #define ZMK_EV_EVENT_BUBBLE 0
 #define ZMK_EV_EVENT_HANDLED 1
 #define ZMK_EV_EVENT_CAPTURED 2
 
-typedef int (*zmk_listener_callback_t)(const struct zmk_event_header *eh);
+typedef int (*zmk_listener_callback_t)(const zmk_event_t *eh);
 struct zmk_listener {
     zmk_listener_callback_t callback;
 };
@@ -34,25 +34,28 @@ struct zmk_event_subscription {
 };
 
 #define ZMK_EVENT_DECLARE(event_type)                                                              \
-    struct event_type *new_##event_type();                                                         \
+    struct event_type##_event {                                                                    \
-    bool is_##event_type(const struct zmk_event_header *eh);                                       \
+        zmk_event_t header;                                                                        \
-    struct event_type *cast_##event_type(const struct zmk_event_header *eh);                       \
+        struct event_type data;                                                                    \
+    };                                                                                             \
+    struct event_type##_event *new_##event_type(struct event_type);                                \
+    struct event_type *as_##event_type(const zmk_event_t *eh);                                     \
     extern const struct zmk_event_type zmk_event_##event_type;
 
 #define ZMK_EVENT_IMPL(event_type)                                                                 \
     const struct zmk_event_type zmk_event_##event_type = {.name = STRINGIFY(event_type)};          \
     const struct zmk_event_type *zmk_event_ref_##event_type __used                                 \
         __attribute__((__section__(".event_type"))) = &zmk_event_##event_type;                     \
-    struct event_type *new_##event_type() {                                                        \
+    struct event_type##_event *new_##event_type(struct event_type data) {                          \
-        struct event_type *ev = (struct event_type *)k_malloc(sizeof(struct event_type));          \
+        struct event_type##_event *ev =                                                            \
+            (struct event_type##_event *)k_malloc(sizeof(struct event_type##_event));              \
         ev->header.event = &zmk_event_##event_type;                                                \
+        ev->data = data;                                                                           \
         return ev;                                                                                 \
     };                                                                                             \
-    bool is_##event_type(const struct zmk_event_header *eh) {                                      \
+    struct event_type *as_##event_type(const zmk_event_t *eh) {                                    \
-        return eh->event == &zmk_event_##event_type;                                               \
+        return (eh->event == &zmk_event_##event_type) ? &((struct event_type##_event *)eh)->data   \
-    };                                                                                             \
+                                                      : NULL;                                      \
-    struct event_type *cast_##event_type(const struct zmk_event_header *eh) {                      \
-        return (struct event_type *)eh;                                                            \
     };
 
 #define ZMK_LISTENER(mod, cb) const struct zmk_listener zmk_listener_##mod = {.callback = cb};
@@ -65,18 +68,19 @@ struct zmk_event_subscription {
             .listener = &zmk_listener_##mod,                                                       \
     };
 
-#define ZMK_EVENT_RAISE(ev) zmk_event_manager_raise((struct zmk_event_header *)ev);
+#define ZMK_EVENT_RAISE(ev) zmk_event_manager_raise((zmk_event_t *)ev);
 
 #define ZMK_EVENT_RAISE_AFTER(ev, mod)                                                             \
-    zmk_event_manager_raise_after((struct zmk_event_header *)ev, &zmk_listener_##mod);
+    zmk_event_manager_raise_after((zmk_event_t *)ev, &zmk_listener_##mod);
 
 #define ZMK_EVENT_RAISE_AT(ev, mod)                                                                \
-    zmk_event_manager_raise_at((struct zmk_event_header *)ev, &zmk_listener_##mod);
+    zmk_event_manager_raise_at((zmk_event_t *)ev, &zmk_listener_##mod);
 
-#define ZMK_EVENT_RELEASE(ev) zmk_event_manager_release((struct zmk_event_header *)ev);
+#define ZMK_EVENT_RELEASE(ev) zmk_event_manager_release((zmk_event_t *)ev);
 
-int zmk_event_manager_raise(struct zmk_event_header *event);
+#define ZMK_EVENT_FREE(ev) k_free((void *)ev);
-int zmk_event_manager_raise_after(struct zmk_event_header *event,
+
-                                  const struct zmk_listener *listener);
+int zmk_event_manager_raise(zmk_event_t *event);
-int zmk_event_manager_raise_at(struct zmk_event_header *event, const struct zmk_listener *listener);
+int zmk_event_manager_raise_after(zmk_event_t *event, const struct zmk_listener *listener);
-int zmk_event_manager_release(struct zmk_event_header *event);
+int zmk_event_manager_raise_at(zmk_event_t *event, const struct zmk_listener *listener);
+int zmk_event_manager_release(zmk_event_t *event);

app/include/zmk/events/activity_state_changed.h

@@ -10,17 +10,8 @@
 #include <zmk/event_manager.h>
 #include <zmk/activity.h>
 
-struct activity_state_changed {
+struct zmk_activity_state_changed {
-    struct zmk_event_header header;
     enum zmk_activity_state state;
 };
 
-ZMK_EVENT_DECLARE(activity_state_changed);
+ZMK_EVENT_DECLARE(zmk_activity_state_changed);
-
-static inline struct activity_state_changed *
-create_activity_state_changed(enum zmk_activity_state state) {
-    struct activity_state_changed *ev = new_activity_state_changed();
-    ev->state = state;
-
-    return ev;
-}

app/include/zmk/events/battery_state_changed.h

@@ -9,10 +9,9 @@
 #include <zephyr.h>
 #include <zmk/event_manager.h>
 
-struct battery_state_changed {
+struct zmk_battery_state_changed {
-    struct zmk_event_header header;
     // TODO: Other battery channels
     uint8_t state_of_charge;
 };
 
-ZMK_EVENT_DECLARE(battery_state_changed);
+ZMK_EVENT_DECLARE(zmk_battery_state_changed);

app/include/zmk/events/ble_active_profile_changed.h

@@ -12,10 +12,9 @@
 
 #include <zmk/ble/profile.h>
 
-struct ble_active_profile_changed {
+struct zmk_ble_active_profile_changed {
-    struct zmk_event_header header;
     uint8_t index;
     struct zmk_ble_profile *profile;
 };
 
-ZMK_EVENT_DECLARE(ble_active_profile_changed);
+ZMK_EVENT_DECLARE(zmk_ble_active_profile_changed);

app/include/zmk/events/keycode_state_changed.h

@@ -12,8 +12,7 @@
 #include <zmk/event_manager.h>
 #include <zmk/keys.h>
 
-struct keycode_state_changed {
+struct zmk_keycode_state_changed {
-    struct zmk_event_header header;
     uint16_t usage_page;
     uint32_t keycode;
     uint8_t implicit_modifiers;
@@ -21,10 +20,10 @@ struct keycode_state_changed {
     int64_t timestamp;
 };
 
-ZMK_EVENT_DECLARE(keycode_state_changed);
+ZMK_EVENT_DECLARE(zmk_keycode_state_changed);
 
-static inline struct keycode_state_changed *
+static inline struct zmk_keycode_state_changed_event *
-keycode_state_changed_from_encoded(uint32_t encoded, bool pressed, int64_t timestamp) {
+zmk_keycode_state_changed_from_encoded(uint32_t encoded, bool pressed, int64_t timestamp) {
     uint16_t page = HID_USAGE_PAGE(encoded) & 0xFF;
     uint16_t id = HID_USAGE_ID(encoded);
     zmk_mod_flags_t implicit_mods = SELECT_MODS(encoded);
@@ -33,11 +32,10 @@ keycode_state_changed_from_encoded(uint32_t encoded, bool pressed, int64_t times
         page = HID_USAGE_KEY;
     }
 
-    struct keycode_state_changed *ev = new_keycode_state_changed();
+    return new_zmk_keycode_state_changed(
-    ev->usage_page = page;
+        (struct zmk_keycode_state_changed){.usage_page = page,
-    ev->keycode = id;
+                                           .keycode = id,
-    ev->implicit_modifiers = implicit_mods;
+                                           .implicit_modifiers = implicit_mods,
-    ev->state = pressed;
+                                           .state = pressed,
-    ev->timestamp = timestamp;
+                                           .timestamp = timestamp});
-    return ev;
 }

app/include/zmk/events/layer_state_changed.h

@@ -9,20 +9,16 @@
 #include <zephyr.h>
 #include <zmk/event_manager.h>
 
-struct layer_state_changed {
+struct zmk_layer_state_changed {
-    struct zmk_event_header header;
     uint8_t layer;
     bool state;
     int64_t timestamp;
 };
 
-ZMK_EVENT_DECLARE(layer_state_changed);
+ZMK_EVENT_DECLARE(zmk_layer_state_changed);
 
-static inline struct layer_state_changed *create_layer_state_changed(uint8_t layer, bool state) {
+static inline struct zmk_layer_state_changed_event *create_layer_state_changed(uint8_t layer,
-    struct layer_state_changed *ev = new_layer_state_changed();
+                                                                               bool state) {
-    ev->layer = layer;
+    return new_zmk_layer_state_changed((struct zmk_layer_state_changed){
-    ev->state = state;
+        .layer = layer, .state = state, .timestamp = k_uptime_get()});
-    ev->timestamp = k_uptime_get();
-
-    return ev;
 }

app/include/zmk/events/modifiers_state_changed.h

@@ -10,19 +10,9 @@
 #include <zmk/keys.h>
 #include <zmk/event_manager.h>
 
-struct modifiers_state_changed {
+struct zmk_modifiers_state_changed {
-    struct zmk_event_header header;
     zmk_mod_flags_t modifiers;
     bool state;
 };
 
-ZMK_EVENT_DECLARE(modifiers_state_changed);
+ZMK_EVENT_DECLARE(zmk_modifiers_state_changed);
-
-inline struct modifiers_state_changed *create_modifiers_state_changed(zmk_mod_flags_t modifiers,
-                                                                      bool state) {
-    struct modifiers_state_changed *ev = new_modifiers_state_changed();
-    ev->modifiers = modifiers;
-    ev->state = state;
-
-    return ev;
-}

app/include/zmk/events/position_state_changed.h

@@ -8,12 +8,10 @@
 
 #include <zephyr.h>
 #include <zmk/event_manager.h>
-
+struct zmk_position_state_changed {
-struct position_state_changed {
-    struct zmk_event_header header;
     uint32_t position;
     bool state;
     int64_t timestamp;
 };
 
-ZMK_EVENT_DECLARE(position_state_changed);
+ZMK_EVENT_DECLARE(zmk_position_state_changed);

app/include/zmk/events/sensor_event.h

@@ -9,12 +9,10 @@
 #include <zephyr.h>
 #include <zmk/event_manager.h>
 #include <device.h>
-
+struct zmk_sensor_event {
-struct sensor_event {
-    struct zmk_event_header header;
     uint8_t sensor_number;
     const struct device *sensor;
     int64_t timestamp;
 };
 
-ZMK_EVENT_DECLARE(sensor_event);
+ZMK_EVENT_DECLARE(zmk_sensor_event);

app/include/zmk/events/usb_conn_state_changed.h

@@ -12,9 +12,8 @@
 #include <zmk/event_manager.h>
 #include <zmk/usb.h>
 
-struct usb_conn_state_changed {
+struct zmk_usb_conn_state_changed {
-    struct zmk_event_header header;
     enum zmk_usb_conn_state conn_state;
 };
 
-ZMK_EVENT_DECLARE(usb_conn_state_changed);
+ZMK_EVENT_DECLARE(zmk_usb_conn_state_changed);

app/include/zmk/events/wpm_state_changed.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <zephyr.h>
+#include <zmk/event_manager.h>
+#include <zmk/wpm.h>
+
+struct zmk_wpm_state_changed {
+    int state;
+};
+
+ZMK_EVENT_DECLARE(zmk_wpm_state_changed);

app/include/zmk/hid.h

@@ -166,6 +166,7 @@ struct zmk_hid_consumer_report {
     struct zmk_hid_consumer_report_body body;
 } __packed;
 
+zmk_mod_flags_t zmk_hid_get_explicit_mods();
 int zmk_hid_register_mod(zmk_mod_t modifier);
 int zmk_hid_unregister_mod(zmk_mod_t modifier);
 int zmk_hid_implicit_modifiers_press(zmk_mod_flags_t implicit_modifiers);

app/include/zmk/wpm.h

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+int zmk_wpm_get_state();

app/run-test.sh

@@ -17,7 +17,7 @@ testcases=$(find $path -name native_posix.keymap -exec dirname \{\} \;)
 num_cases=$(echo "$testcases" | wc -l)
 if [ $num_cases -gt 1 ]; then
 	echo "" > ./build/tests/pass-fail.log
-	echo "$testcases" | xargs -l -P 4 ./run-test.sh
+	echo "$testcases" | xargs -L 1 -P 4 ./run-test.sh
 	err=$?
 	sort -k2 ./build/tests/pass-fail.log
 	exit $err

app/src/activity.c

@@ -29,7 +29,10 @@ static uint32_t activity_last_uptime;
 #define MAX_SLEEP_MS CONFIG_ZMK_IDLE_SLEEP_TIMEOUT
 #endif
 
-int raise_event() { return ZMK_EVENT_RAISE(create_activity_state_changed(activity_state)); }
+int raise_event() {
+    return ZMK_EVENT_RAISE(new_zmk_activity_state_changed(
+        (struct zmk_activity_state_changed){.state = activity_state}));
+}
 
 int set_state(enum zmk_activity_state state) {
     if (activity_state == state)
@@ -41,7 +44,7 @@ int set_state(enum zmk_activity_state state) {
 
 enum zmk_activity_state zmk_activity_get_state() { return activity_state; }
 
-int activity_event_listener(const struct zmk_event_header *eh) {
+int activity_event_listener(const zmk_event_t *eh) {
     activity_last_uptime = k_uptime_get();
 
     return set_state(ZMK_ACTIVITY_ACTIVE);
@@ -74,7 +77,7 @@ int activity_init() {
 }
 
 ZMK_LISTENER(activity, activity_event_listener);
-ZMK_SUBSCRIPTION(activity, position_state_changed);
+ZMK_SUBSCRIPTION(activity, zmk_position_state_changed);
-ZMK_SUBSCRIPTION(activity, sensor_event);
+ZMK_SUBSCRIPTION(activity, zmk_sensor_event);
 
 SYS_INIT(activity_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

app/src/battery.c

@@ -45,9 +45,8 @@ static int zmk_battery_update(const struct device *battery) {
         return rc;
     }
 
-    struct battery_state_changed *ev = new_battery_state_changed();
+    return ZMK_EVENT_RAISE(new_zmk_battery_state_changed(
-    ev->state_of_charge = state_of_charge.val1;
+        (struct zmk_battery_state_changed){.state_of_charge = state_of_charge.val1}));
-    return ZMK_EVENT_RAISE(ev);
 }
 
 static void zmk_battery_work(struct k_work *work) {

app/src/behaviors/behavior_hold_tap.c

@@ -69,9 +69,9 @@ struct active_hold_tap {
 struct active_hold_tap *undecided_hold_tap = NULL;
 struct active_hold_tap active_hold_taps[ZMK_BHV_HOLD_TAP_MAX_HELD] = {};
 // We capture most position_state_changed events and some modifiers_state_changed events.
-const struct zmk_event_header *captured_events[ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS] = {};
+const zmk_event_t *captured_events[ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS] = {};
 
-static int capture_event(const struct zmk_event_header *event) {
+static int capture_event(const zmk_event_t *event) {
     for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
         if (captured_events[i] == NULL) {
             captured_events[i] = event;
@@ -81,17 +81,18 @@ static int capture_event(const struct zmk_event_header *event) {
     return -ENOMEM;
 }
 
-static struct position_state_changed *find_captured_keydown_event(uint32_t position) {
+static struct zmk_position_state_changed *find_captured_keydown_event(uint32_t position) {
-    struct position_state_changed *last_match = NULL;
+    struct zmk_position_state_changed *last_match = NULL;
     for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
-        const struct zmk_event_header *eh = captured_events[i];
+        const zmk_event_t *eh = captured_events[i];
         if (eh == NULL) {
             return last_match;
         }
-        if (!is_position_state_changed(eh)) {
+        struct zmk_position_state_changed *position_event = as_zmk_position_state_changed(eh);
+        if (position_event == NULL) {
             continue;
         }
-        struct position_state_changed *position_event = cast_position_state_changed(eh);
+
         if (position_event->position == position && position_event->state) {
             last_match = position_event;
         }
@@ -132,7 +133,7 @@ static void release_captured_events() {
     // [k1_down, k1_up, null, null, null, ...]
     // now mt2 will start releasing it's own captured positions.
     for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_CAPTURED_EVENTS; i++) {
-        const struct zmk_event_header *captured_event = captured_events[i];
+        const zmk_event_t *captured_event = captured_events[i];
         if (captured_event == NULL) {
             return;
         }
@@ -140,14 +141,13 @@ static void release_captured_events() {
         if (undecided_hold_tap != NULL) {
             k_msleep(10);
         }
-        if (is_position_state_changed(captured_event)) {
+
-            struct position_state_changed *position_event =
+        struct zmk_position_state_changed *position_event;
-                cast_position_state_changed(captured_event);
+        struct zmk_keycode_state_changed *modifier_event;
+        if ((position_event = as_zmk_position_state_changed(captured_event)) != NULL) {
             LOG_DBG("Releasing key position event for position %d %s", position_event->position,
                     (position_event->state ? "pressed" : "released"));
-        } else {
+        } else if ((modifier_event = as_zmk_keycode_state_changed(captured_event)) != NULL) {
-            struct keycode_state_changed *modifier_event =
-                cast_keycode_state_changed(captured_event);
             LOG_DBG("Releasing mods changed event 0x%02X %s", modifier_event->keycode,
                     (modifier_event->state ? "pressed" : "released"));
         }
@@ -387,8 +387,8 @@ static const struct behavior_driver_api behavior_hold_tap_driver_api = {
     .binding_released = on_hold_tap_binding_released,
 };
 
-static int position_state_changed_listener(const struct zmk_event_header *eh) {
+static int position_state_changed_listener(const zmk_event_t *eh) {
-    struct position_state_changed *ev = cast_position_state_changed(eh);
+    struct zmk_position_state_changed *ev = as_zmk_position_state_changed(eh);
 
     if (undecided_hold_tap == NULL) {
         LOG_DBG("%d bubble (no undecided hold_tap active)", ev->position);
@@ -428,14 +428,14 @@ static int position_state_changed_listener(const struct zmk_event_header *eh) {
     return ZMK_EV_EVENT_CAPTURED;
 }
 
-static inline bool only_mods(struct keycode_state_changed *ev) {
+static inline bool only_mods(struct zmk_keycode_state_changed *ev) {
     return ev->usage_page == HID_USAGE_KEY && ev->keycode >= HID_USAGE_KEY_KEYBOARD_LEFTCONTROL &&
            ev->keycode <= HID_USAGE_KEY_KEYBOARD_RIGHT_GUI;
 }
 
-static int keycode_state_changed_listener(const struct zmk_event_header *eh) {
+static int keycode_state_changed_listener(const zmk_event_t *eh) {
     // we want to catch layer-up events too... how?
-    struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
+    struct zmk_keycode_state_changed *ev = as_zmk_keycode_state_changed(eh);
 
     if (undecided_hold_tap == NULL) {
         // LOG_DBG("0x%02X bubble (no undecided hold_tap active)", ev->keycode);
@@ -455,19 +455,19 @@ static int keycode_state_changed_listener(const struct zmk_event_header *eh) {
     return ZMK_EV_EVENT_CAPTURED;
 }
 
-int behavior_hold_tap_listener(const struct zmk_event_header *eh) {
+int behavior_hold_tap_listener(const zmk_event_t *eh) {
-    if (is_position_state_changed(eh)) {
+    if (as_zmk_position_state_changed(eh) != NULL) {
         return position_state_changed_listener(eh);
-    } else if (is_keycode_state_changed(eh)) {
+    } else if (as_zmk_keycode_state_changed(eh) != NULL) {
         return keycode_state_changed_listener(eh);
     }
     return ZMK_EV_EVENT_BUBBLE;
 }
 
 ZMK_LISTENER(behavior_hold_tap, behavior_hold_tap_listener);
-ZMK_SUBSCRIPTION(behavior_hold_tap, position_state_changed);
+ZMK_SUBSCRIPTION(behavior_hold_tap, zmk_position_state_changed);
 // this should be modifiers_state_changed, but unfrotunately that's not implemented yet.
-ZMK_SUBSCRIPTION(behavior_hold_tap, keycode_state_changed);
+ZMK_SUBSCRIPTION(behavior_hold_tap, zmk_keycode_state_changed);
 
 void behavior_hold_tap_timer_work_handler(struct k_work *item) {
     struct active_hold_tap *hold_tap = CONTAINER_OF(item, struct active_hold_tap, work);

app/src/behaviors/behavior_key_press.c

@@ -22,14 +22,14 @@ static int on_keymap_binding_pressed(struct zmk_behavior_binding *binding,
                                      struct zmk_behavior_binding_event event) {
     LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1);
     return ZMK_EVENT_RAISE(
-        keycode_state_changed_from_encoded(binding->param1, true, event.timestamp));
+        zmk_keycode_state_changed_from_encoded(binding->param1, true, event.timestamp));
 }
 
 static int on_keymap_binding_released(struct zmk_behavior_binding *binding,
                                       struct zmk_behavior_binding_event event) {
     LOG_DBG("position %d keycode 0x%02X", event.position, binding->param1);
     return ZMK_EVENT_RAISE(
-        keycode_state_changed_from_encoded(binding->param1, false, event.timestamp));
+        zmk_keycode_state_changed_from_encoded(binding->param1, false, event.timestamp));
 }
 
 static const struct behavior_driver_api behavior_key_press_driver_api = {

app/src/behaviors/behavior_mod_morph.c

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#define DT_DRV_COMPAT zmk_behavior_mod_morph
+
+#include <device.h>
+#include <drivers/behavior.h>
+#include <logging/log.h>
+#include <zmk/behavior.h>
+
+#include <zmk/matrix.h>
+#include <zmk/endpoints.h>
+#include <zmk/event_manager.h>
+#include <zmk/events/position_state_changed.h>
+#include <zmk/events/keycode_state_changed.h>
+#include <zmk/events/modifiers_state_changed.h>
+#include <zmk/hid.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
+
+struct behavior_mod_morph_config {
+    struct zmk_behavior_binding normal_binding;
+    struct zmk_behavior_binding morph_binding;
+    zmk_mod_flags_t mods;
+};
+
+struct behavior_mod_morph_data {
+    struct zmk_behavior_binding *pressed_binding;
+};
+
+static int on_mod_morph_binding_pressed(struct zmk_behavior_binding *binding,
+                                        struct zmk_behavior_binding_event event) {
+    const struct device *dev = device_get_binding(binding->behavior_dev);
+    const struct behavior_mod_morph_config *cfg = dev->config;
+    struct behavior_mod_morph_data *data = dev->data;
+
+    if (data->pressed_binding != NULL) {
+        LOG_ERR("Can't press the same mod-morph twice");
+        return -ENOTSUP;
+    }
+
+    if (zmk_hid_get_explicit_mods() & cfg->mods) {
+        data->pressed_binding = (struct zmk_behavior_binding *)&cfg->morph_binding;
+    } else {
+        data->pressed_binding = (struct zmk_behavior_binding *)&cfg->normal_binding;
+    }
+    return behavior_keymap_binding_pressed(data->pressed_binding, event);
+}
+
+static int on_mod_morph_binding_released(struct zmk_behavior_binding *binding,
+                                         struct zmk_behavior_binding_event event) {
+    const struct device *dev = device_get_binding(binding->behavior_dev);
+    struct behavior_mod_morph_data *data = dev->data;
+
+    if (data->pressed_binding == NULL) {
+        LOG_ERR("Mod-morph already released");
+        return -ENOTSUP;
+    }
+
+    struct zmk_behavior_binding *pressed_binding = data->pressed_binding;
+    data->pressed_binding = NULL;
+    return behavior_keymap_binding_released(pressed_binding, event);
+}
+
+static const struct behavior_driver_api behavior_mod_morph_driver_api = {
+    .binding_pressed = on_mod_morph_binding_pressed,
+    .binding_released = on_mod_morph_binding_released,
+};
+
+static int behavior_mod_morph_init(const struct device *dev) { return 0; }
+
+#define _TRANSFORM_ENTRY(idx, node)                                                                \
+    {                                                                                              \
+        .behavior_dev = DT_LABEL(DT_INST_PHANDLE_BY_IDX(node, bindings, idx)),                     \
+        .param1 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param1), (0),       \
+                              (DT_INST_PHA_BY_IDX(node, bindings, idx, param1))),                  \
+        .param2 = COND_CODE_0(DT_INST_PHA_HAS_CELL_AT_IDX(node, bindings, idx, param2), (0),       \
+                              (DT_INST_PHA_BY_IDX(node, bindings, idx, param2))),                  \
+    }
+
+#define KP_INST(n)                                                                                 \
+    static struct behavior_mod_morph_config behavior_mod_morph_config_##n = {                      \
+        .normal_binding = _TRANSFORM_ENTRY(0, n),                                                  \
+        .morph_binding = _TRANSFORM_ENTRY(1, n),                                                   \
+        .mods = DT_INST_PROP(n, mods),                                                             \
+    };                                                                                             \
+    static struct behavior_mod_morph_data behavior_mod_morph_data_##n = {};                        \
+    DEVICE_AND_API_INIT(behavior_mod_morph_##n, DT_INST_LABEL(n), behavior_mod_morph_init,         \
+                        &behavior_mod_morph_data_##n, &behavior_mod_morph_config_##n, APPLICATION, \
+                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &behavior_mod_morph_driver_api);
+
+DT_INST_FOREACH_STATUS_OKAY(KP_INST)
+
+#endif

app/src/behaviors/behavior_sensor_rotate_key_press.c

@@ -45,12 +45,12 @@ static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding,
 
     LOG_DBG("SEND %d", keycode);
 
-    ZMK_EVENT_RAISE(keycode_state_changed_from_encoded(keycode, true, timestamp));
+    ZMK_EVENT_RAISE(zmk_keycode_state_changed_from_encoded(keycode, true, timestamp));
 
     // TODO: Better way to do this?
     k_msleep(5);
 
-    return ZMK_EVENT_RAISE(keycode_state_changed_from_encoded(keycode, false, timestamp));
+    return ZMK_EVENT_RAISE(zmk_keycode_state_changed_from_encoded(keycode, false, timestamp));
 }
 
 static const struct behavior_driver_api behavior_sensor_rotate_key_press_driver_api = {

app/src/behaviors/behavior_sticky_key.c

@@ -175,11 +175,11 @@ static const struct behavior_driver_api behavior_sticky_key_driver_api = {
     .binding_released = on_sticky_key_binding_released,
 };
 
-static int sticky_key_keycode_state_changed_listener(const struct zmk_event_header *eh) {
+static int sticky_key_keycode_state_changed_listener(const zmk_event_t *eh) {
-    if (!is_keycode_state_changed(eh)) {
+    struct zmk_keycode_state_changed *ev = as_zmk_keycode_state_changed(eh);
+    if (ev == NULL) {
         return ZMK_EV_EVENT_BUBBLE;
     }
-    struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
     for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {
         struct active_sticky_key *sticky_key = &active_sticky_keys[i];
         if (sticky_key->position == ZMK_BHV_STICKY_KEY_POSITION_FREE) {
@@ -226,7 +226,7 @@ static int sticky_key_keycode_state_changed_listener(const struct zmk_event_head
 }
 
 ZMK_LISTENER(behavior_sticky_key, sticky_key_keycode_state_changed_listener);
-ZMK_SUBSCRIPTION(behavior_sticky_key, keycode_state_changed);
+ZMK_SUBSCRIPTION(behavior_sticky_key, zmk_keycode_state_changed);
 
 void behavior_sticky_key_timer_handler(struct k_work *item) {
     struct active_sticky_key *sticky_key =

app/src/ble.c

@@ -92,11 +92,8 @@ static bt_addr_le_t peripheral_addr;
 #endif /* IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL) */
 
 static void raise_profile_changed_event() {
-    struct ble_active_profile_changed *ev = new_ble_active_profile_changed();
+    ZMK_EVENT_RAISE(new_zmk_ble_active_profile_changed((struct zmk_ble_active_profile_changed){
-    ev->index = active_profile;
+        .index = active_profile, .profile = &profiles[active_profile]}));
-    ev->profile = &profiles[active_profile];
-
-    ZMK_EVENT_RAISE(ev);
 }
 
 static void raise_profile_changed_event_callback(struct k_work *work) {

app/src/combo.c

@@ -40,7 +40,7 @@ struct active_combo {
     // key_positions_pressed is filled with key_positions when the combo is pressed.
     // The keys are removed from this array when they are released.
     // Once this array is empty, the behavior is released.
-    struct position_state_changed *key_positions_pressed[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO];
+    const zmk_event_t *key_positions_pressed[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO];
 };
 
 struct combo_candidate {
@@ -52,7 +52,7 @@ struct combo_candidate {
 };
 
 // set of keys pressed
-struct position_state_changed *pressed_keys[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO] = {NULL};
+const zmk_event_t *pressed_keys[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO] = {NULL};
 // the set of candidate combos based on the currently pressed_keys
 struct combo_candidate candidates[CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY];
 // the last candidate that was completely pressed
@@ -202,7 +202,7 @@ static int clear_candidates() {
     return CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY;
 }
 
-static int capture_pressed_key(struct position_state_changed *ev) {
+static int capture_pressed_key(const zmk_event_t *ev) {
     for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) {
         if (pressed_keys[i] != NULL) {
             continue;
@@ -228,7 +228,7 @@ static void release_pressed_keys() {
         if (pressed_keys[i] == NULL) {
             return;
         }
-        struct position_state_changed *captured_event = pressed_keys[i];
+        const zmk_event_t *captured_event = pressed_keys[i];
         pressed_keys[i] = NULL;
         ZMK_EVENT_RAISE(captured_event);
     }
@@ -290,7 +290,8 @@ static void activate_combo(struct combo_cfg *combo) {
         return;
     }
     move_pressed_keys_to_active_combo(active_combo);
-    press_combo_behavior(combo, active_combo->key_positions_pressed[0]->timestamp);
+    press_combo_behavior(
+        combo, as_zmk_position_state_changed(active_combo->key_positions_pressed[0])->timestamp);
 }
 
 static void deactivate_combo(int active_combo_index) {
@@ -314,10 +315,11 @@ static bool release_combo_key(int32_t position, int64_t timestamp) {
         for (int i = 0; i < active_combo->combo->key_position_len; i++) {
             if (active_combo->key_positions_pressed[i] == NULL) {
                 all_keys_pressed = false;
-            } else if (active_combo->key_positions_pressed[i]->position != position) {
+            } else if (as_zmk_position_state_changed(active_combo->key_positions_pressed[i])
+                           ->position != position) {
                 all_keys_released = false;
             } else { // not null and position matches
-                k_free(active_combo->key_positions_pressed[i]);
+                ZMK_EVENT_FREE(active_combo->key_positions_pressed[i]);
                 active_combo->key_positions_pressed[i] = NULL;
                 key_released = true;
             }
@@ -362,16 +364,16 @@ static void update_timeout_task() {
     }
 }
 
-static int position_state_down(struct position_state_changed *ev) {
+static int position_state_down(const zmk_event_t *ev, struct zmk_position_state_changed *data) {
     int num_candidates;
     if (candidates[0].combo == NULL) {
-        num_candidates = setup_candidates_for_first_keypress(ev->position, ev->timestamp);
+        num_candidates = setup_candidates_for_first_keypress(data->position, data->timestamp);
         if (num_candidates == 0) {
             return 0;
         }
     } else {
-        filter_timed_out_candidates(ev->timestamp);
+        filter_timed_out_candidates(data->timestamp);
-        num_candidates = filter_candidates(ev->position);
+        num_candidates = filter_candidates(data->position);
     }
     update_timeout_task();
 
@@ -395,7 +397,7 @@ static int position_state_down(struct position_state_changed *ev) {
     }
 }
 
-static int position_state_up(struct position_state_changed *ev) {
+static int position_state_up(struct zmk_position_state_changed *ev) {
     cleanup();
     if (release_combo_key(ev->position, ev->timestamp)) {
         return ZMK_EV_EVENT_HANDLED;
@@ -415,21 +417,21 @@ static void combo_timeout_handler(struct k_work *item) {
     update_timeout_task();
 }
 
-static int position_state_changed_listener(const struct zmk_event_header *eh) {
+static int position_state_changed_listener(const zmk_event_t *ev) {
-    if (!is_position_state_changed(eh)) {
+    struct zmk_position_state_changed *data = as_zmk_position_state_changed(ev);
+    if (data == NULL) {
         return 0;
     }
 
-    struct position_state_changed *ev = cast_position_state_changed(eh);
+    if (data->state) { // keydown
-    if (ev->state) { // keydown
+        return position_state_down(ev, data);
-        return position_state_down(ev);
     } else { // keyup
-        return position_state_up(ev);
+        return position_state_up(data);
     }
 }
 
 ZMK_LISTENER(combo, position_state_changed_listener);
-ZMK_SUBSCRIPTION(combo, position_state_changed);
+ZMK_SUBSCRIPTION(combo, zmk_position_state_changed);
 
 // todo: remove this once #506 is merged and #include <zmk/keymap.h>
 #define KEY_BINDING_TO_STRUCT(idx, drv_inst)                                                       \

app/src/display/main.c

@@ -75,8 +75,12 @@ int zmk_display_init() {
     return 0;
 }
 
-int display_event_handler(const struct zmk_event_header *eh) {
+int display_event_handler(const zmk_event_t *eh) {
-    struct activity_state_changed *ev = cast_activity_state_changed(eh);
+    struct zmk_activity_state_changed *ev = as_zmk_activity_state_changed(eh);
+    if (ev == NULL) {
+        return -ENOTSUP;
+    }
+
     switch (ev->state) {
     case ZMK_ACTIVITY_ACTIVE:
         start_display_updates();
@@ -93,4 +97,4 @@ int display_event_handler(const struct zmk_event_header *eh) {
 }
 
 ZMK_LISTENER(display, display_event_handler);
-ZMK_SUBSCRIPTION(display, activity_state_changed);
+ZMK_SUBSCRIPTION(display, zmk_activity_state_changed);

app/src/display/status_screen.c

@@ -7,6 +7,7 @@
 #include <zmk/display/widgets/output_status.h>
 #include <zmk/display/widgets/battery_status.h>
 #include <zmk/display/widgets/layer_status.h>
+#include <zmk/display/widgets/wpm_status.h>
 #include <zmk/display/status_screen.h>
 
 #include <logging/log.h>
@@ -24,6 +25,10 @@ static struct zmk_widget_output_status output_status_widget;
 static struct zmk_widget_layer_status layer_status_widget;
 #endif
 
+#if IS_ENABLED(CONFIG_ZMK_WIDGET_WPM_STATUS)
+static struct zmk_widget_wpm_status wpm_status_widget;
+#endif
+
 lv_obj_t *zmk_display_status_screen() {
     lv_obj_t *screen;
 
@@ -47,5 +52,10 @@ lv_obj_t *zmk_display_status_screen() {
                  0, 0);
 #endif
 
+#if IS_ENABLED(CONFIG_ZMK_WIDGET_WPM_STATUS)
+    zmk_widget_wpm_status_init(&wpm_status_widget, screen);
+    lv_obj_align(zmk_widget_wpm_status_obj(&wpm_status_widget), NULL, LV_ALIGN_IN_BOTTOM_RIGHT, -12,
+                 0);
+#endif
     return screen;
 }

app/src/display/widgets/CMakeLists.txt

@@ -4,3 +4,4 @@
 target_sources_ifdef(CONFIG_ZMK_WIDGET_BATTERY_STATUS app PRIVATE battery_status.c)
 target_sources_ifdef(CONFIG_ZMK_WIDGET_OUTPUT_STATUS app PRIVATE output_status.c)
 target_sources_ifdef(CONFIG_ZMK_WIDGET_LAYER_STATUS app PRIVATE layer_status.c)
+target_sources_ifdef(CONFIG_ZMK_WIDGET_WPM_STATUS app PRIVATE wpm_status.c)

app/src/display/widgets/Kconfig

@@ -23,4 +23,11 @@ config ZMK_WIDGET_OUTPUT_STATUS
     select LVGL_USE_LABEL
     select LVGL_FONT_MONTSERRAT_16
     
+config ZMK_WIDGET_WPM_STATUS
+    bool "Widget for displaying typed words per minute"
+    depends on !ZMK_SPLIT || ZMK_SPLIT_BLE_ROLE_CENTRAL
+    select LVGL_USE_LABEL
+    select LVGL_FONT_MONTSERRAT_16
+    select ZMK_WPM
+
 endmenu

app/src/display/widgets/battery_status.c

@@ -75,14 +75,14 @@ lv_obj_t *zmk_widget_battery_status_obj(struct zmk_widget_battery_status *widget
     return widget->obj;
 }
 
-int battery_status_listener(const struct zmk_event_header *eh) {
+int battery_status_listener(const zmk_event_t *eh) {
     struct zmk_widget_battery_status *widget;
     SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_battery_symbol(widget->obj); }
     return ZMK_EV_EVENT_BUBBLE;
 }
 
 ZMK_LISTENER(widget_battery_status, battery_status_listener)
-ZMK_SUBSCRIPTION(widget_battery_status, battery_state_changed);
+ZMK_SUBSCRIPTION(widget_battery_status, zmk_battery_state_changed);
 #if IS_ENABLED(CONFIG_USB)
-ZMK_SUBSCRIPTION(widget_battery_status, usb_conn_state_changed);
+ZMK_SUBSCRIPTION(widget_battery_status, zmk_usb_conn_state_changed);
 #endif /* IS_ENABLED(CONFIG_USB) */

app/src/display/widgets/layer_status.c

@@ -69,11 +69,11 @@ lv_obj_t *zmk_widget_layer_status_obj(struct zmk_widget_layer_status *widget) {
     return widget->obj;
 }
 
-int layer_status_listener(const struct zmk_event_header *eh) {
+int layer_status_listener(const zmk_event_t *eh) {
     struct zmk_widget_layer_status *widget;
     SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_layer_symbol(widget->obj); }
     return 0;
 }
 
 ZMK_LISTENER(widget_layer_status, layer_status_listener)
-ZMK_SUBSCRIPTION(widget_layer_status, layer_state_changed);
+ZMK_SUBSCRIPTION(widget_layer_status, zmk_layer_state_changed);

app/src/display/widgets/output_status.c

@@ -79,7 +79,7 @@ lv_obj_t *zmk_widget_output_status_obj(struct zmk_widget_output_status *widget)
     return widget->obj;
 }
 
-int output_status_listener(const struct zmk_event_header *eh) {
+int output_status_listener(const zmk_event_t *eh) {
     struct zmk_widget_output_status *widget;
     SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_status_symbol(widget->obj); }
     return ZMK_EV_EVENT_BUBBLE;
@@ -87,8 +87,8 @@ int output_status_listener(const struct zmk_event_header *eh) {
 
 ZMK_LISTENER(widget_output_status, output_status_listener)
 #if defined(CONFIG_USB)
-ZMK_SUBSCRIPTION(widget_output_status, usb_conn_state_changed);
+ZMK_SUBSCRIPTION(widget_output_status, zmk_usb_conn_state_changed);
 #endif
 #if defined(CONFIG_ZMK_BLE)
-ZMK_SUBSCRIPTION(widget_output_status, ble_active_profile_changed);
+ZMK_SUBSCRIPTION(widget_output_status, zmk_ble_active_profile_changed);
 #endif

app/src/display/widgets/wpm_status.c

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <logging/log.h>
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#include <zmk/display/widgets/wpm_status.h>
+#include <zmk/events/wpm_state_changed.h>
+#include <zmk/event_manager.h>
+#include <zmk/endpoints.h>
+#include <zmk/wpm.h>
+
+static sys_slist_t widgets = SYS_SLIST_STATIC_INIT(&widgets);
+static lv_style_t label_style;
+
+static bool style_initialized = false;
+
+void wpm_status_init() {
+    if (style_initialized) {
+        return;
+    }
+
+    style_initialized = true;
+    lv_style_init(&label_style);
+    lv_style_set_text_color(&label_style, LV_STATE_DEFAULT, LV_COLOR_BLACK);
+    lv_style_set_text_font(&label_style, LV_STATE_DEFAULT, &lv_font_montserrat_12);
+    lv_style_set_text_letter_space(&label_style, LV_STATE_DEFAULT, 1);
+    lv_style_set_text_line_space(&label_style, LV_STATE_DEFAULT, 1);
+}
+
+void set_wpm_symbol(lv_obj_t *label, int wpm) {
+    char text[4] = {};
+
+    LOG_DBG("WPM changed to %i", wpm);
+    sprintf(text, "%i ", wpm);
+
+    lv_label_set_text(label, text);
+}
+
+int zmk_widget_wpm_status_init(struct zmk_widget_wpm_status *widget, lv_obj_t *parent) {
+    wpm_status_init();
+    widget->obj = lv_label_create(parent, NULL);
+    lv_obj_add_style(widget->obj, LV_LABEL_PART_MAIN, &label_style);
+    lv_label_set_align(widget->obj, LV_LABEL_ALIGN_RIGHT);
+
+    lv_obj_set_size(widget->obj, 40, 15);
+    set_wpm_symbol(widget->obj, 0);
+
+    sys_slist_append(&widgets, &widget->node);
+
+    return 0;
+}
+
+lv_obj_t *zmk_widget_wpm_status_obj(struct zmk_widget_wpm_status *widget) { return widget->obj; }
+
+int wpm_status_listener(const zmk_event_t *eh) {
+    struct zmk_wpm_state_changed *ev = as_zmk_wpm_state_changed(eh);
+    struct zmk_widget_wpm_status *widget;
+    SYS_SLIST_FOR_EACH_CONTAINER(&widgets, widget, node) { set_wpm_symbol(widget->obj, ev->state); }
+    return 0;
+}
+
+ZMK_LISTENER(widget_wpm_status, wpm_status_listener)
+ZMK_SUBSCRIPTION(widget_wpm_status, zmk_wpm_state_changed);

app/src/endpoints.c

@@ -245,17 +245,17 @@ static void update_current_endpoint() {
     }
 }
 
-static int endpoint_listener(const struct zmk_event_header *eh) {
+static int endpoint_listener(const zmk_event_t *eh) {
     update_current_endpoint();
     return 0;
 }
 
 ZMK_LISTENER(endpoint_listener, endpoint_listener);
 #if IS_ENABLED(CONFIG_ZMK_USB)
-ZMK_SUBSCRIPTION(endpoint_listener, usb_conn_state_changed);
+ZMK_SUBSCRIPTION(endpoint_listener, zmk_usb_conn_state_changed);
 #endif
 #if IS_ENABLED(CONFIG_ZMK_BLE)
-ZMK_SUBSCRIPTION(endpoint_listener, ble_active_profile_changed);
+ZMK_SUBSCRIPTION(endpoint_listener, zmk_ble_active_profile_changed);
 #endif
 
 SYS_INIT(zmk_endpoints_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

app/src/event_manager.c

@@ -17,7 +17,7 @@ extern struct zmk_event_type *__event_type_end[];
 extern struct zmk_event_subscription __event_subscriptions_start[];
 extern struct zmk_event_subscription __event_subscriptions_end[];
 
-int zmk_event_manager_handle_from(struct zmk_event_header *event, uint8_t start_index) {
+int zmk_event_manager_handle_from(zmk_event_t *event, uint8_t start_index) {
     int ret = 0;
     uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
     for (int i = start_index; i < len; i++) {
@@ -48,12 +48,9 @@ release:
     return ret;
 }
 
-int zmk_event_manager_raise(struct zmk_event_header *event) {
+int zmk_event_manager_raise(zmk_event_t *event) { return zmk_event_manager_handle_from(event, 0); }
-    return zmk_event_manager_handle_from(event, 0);
-}
 
-int zmk_event_manager_raise_after(struct zmk_event_header *event,
+int zmk_event_manager_raise_after(zmk_event_t *event, const struct zmk_listener *listener) {
-                                  const struct zmk_listener *listener) {
     uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
     for (int i = 0; i < len; i++) {
         struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
@@ -68,8 +65,7 @@ int zmk_event_manager_raise_after(struct zmk_event_header *event,
     return -EINVAL;
 }
 
-int zmk_event_manager_raise_at(struct zmk_event_header *event,
+int zmk_event_manager_raise_at(zmk_event_t *event, const struct zmk_listener *listener) {
-                               const struct zmk_listener *listener) {
     uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
     for (int i = 0; i < len; i++) {
         struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
@@ -84,6 +80,6 @@ int zmk_event_manager_raise_at(struct zmk_event_header *event,
     return -EINVAL;
 }
 
-int zmk_event_manager_release(struct zmk_event_header *event) {
+int zmk_event_manager_release(zmk_event_t *event) {
     return zmk_event_manager_handle_from(event, event->last_listener_index + 1);
 }

app/src/events/activity_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/activity_state_changed.h>
 
-ZMK_EVENT_IMPL(activity_state_changed);
+ZMK_EVENT_IMPL(zmk_activity_state_changed);

app/src/events/battery_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/battery_state_changed.h>
 
-ZMK_EVENT_IMPL(battery_state_changed);
+ZMK_EVENT_IMPL(zmk_battery_state_changed);

app/src/events/ble_active_profile_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/ble_active_profile_changed.h>
 
-ZMK_EVENT_IMPL(ble_active_profile_changed);
+ZMK_EVENT_IMPL(zmk_ble_active_profile_changed);

app/src/events/keycode_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/keycode_state_changed.h>
 
-ZMK_EVENT_IMPL(keycode_state_changed);
+ZMK_EVENT_IMPL(zmk_keycode_state_changed);

app/src/events/layer_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/layer_state_changed.h>
 
-ZMK_EVENT_IMPL(layer_state_changed);
+ZMK_EVENT_IMPL(zmk_layer_state_changed);

app/src/events/modifiers_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/modifiers_state_changed.h>
 
-ZMK_EVENT_IMPL(modifiers_state_changed);
+ZMK_EVENT_IMPL(zmk_modifiers_state_changed);

app/src/events/position_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/position_state_changed.h>
 
-ZMK_EVENT_IMPL(position_state_changed);
+ZMK_EVENT_IMPL(zmk_position_state_changed);

app/src/events/sensor_event.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/sensor_event.h>
 
-ZMK_EVENT_IMPL(sensor_event);
+ZMK_EVENT_IMPL(zmk_sensor_event);

app/src/events/usb_conn_state_changed.c

@@ -7,4 +7,4 @@
 #include <kernel.h>
 #include <zmk/events/usb_conn_state_changed.h>
 
-ZMK_EVENT_IMPL(usb_conn_state_changed);
+ZMK_EVENT_IMPL(zmk_usb_conn_state_changed);

app/src/events/wpm_state_changed.c

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <kernel.h>
+#include <zmk/events/wpm_state_changed.h>
+
+ZMK_EVENT_IMPL(zmk_wpm_state_changed);

app/src/hid.c

@@ -26,6 +26,8 @@ static zmk_mod_flags_t explicit_modifiers = 0;
         LOG_DBG("Modifiers set to 0x%02X", 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]);

app/src/hid_listener.c

@@ -70,9 +70,9 @@ static int hid_listener_keycode_released(uint16_t usage_page, uint32_t keycode,
     return zmk_endpoints_send_report(usage_page);
 }
 
-int hid_listener(const struct zmk_event_header *eh) {
+int hid_listener(const zmk_event_t *eh) {
-    if (is_keycode_state_changed(eh)) {
+    const struct zmk_keycode_state_changed *ev = as_zmk_keycode_state_changed(eh);
-        const struct keycode_state_changed *ev = cast_keycode_state_changed(eh);
+    if (ev) {
         if (ev->state) {
             hid_listener_keycode_pressed(ev->usage_page, ev->keycode, ev->implicit_modifiers);
         } else {
@@ -83,4 +83,4 @@ int hid_listener(const struct zmk_event_header *eh) {
 }
 
 ZMK_LISTENER(hid_listener, hid_listener);
-ZMK_SUBSCRIPTION(hid_listener, keycode_state_changed);
+ZMK_SUBSCRIPTION(hid_listener, zmk_keycode_state_changed);

app/src/keymap.c

@@ -246,23 +246,27 @@ int zmk_keymap_sensor_triggered(uint8_t sensor_number, const struct device *sens
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
 
-int keymap_listener(const struct zmk_event_header *eh) {
+int keymap_listener(const zmk_event_t *eh) {
-    if (is_position_state_changed(eh)) {
+    const struct zmk_position_state_changed *pos_ev;
-        const struct position_state_changed *ev = cast_position_state_changed(eh);
+    if ((pos_ev = as_zmk_position_state_changed(eh)) != NULL) {
-        return zmk_keymap_position_state_changed(ev->position, ev->state, ev->timestamp);
+        return zmk_keymap_position_state_changed(pos_ev->position, pos_ev->state,
-#if ZMK_KEYMAP_HAS_SENSORS
+                                                 pos_ev->timestamp);
-    } else if (is_sensor_event(eh)) {
-        const struct sensor_event *ev = cast_sensor_event(eh);
-        return zmk_keymap_sensor_triggered(ev->sensor_number, ev->sensor, ev->timestamp);
-#endif /* ZMK_KEYMAP_HAS_SENSORS */
     }
 
+#if ZMK_KEYMAP_HAS_SENSORS
+    const struct zmk_sensor_event *sensor_ev;
+    if ((sensor_ev = as_zmk_sensor_event(eh)) != NULL) {
+        return zmk_keymap_sensor_triggered(sensor_ev->sensor_number, sensor_ev->sensor,
+                                           sensor_ev->timestamp);
+    }
+#endif /* ZMK_KEYMAP_HAS_SENSORS */
+
     return -ENOTSUP;
 }
 
 ZMK_LISTENER(keymap, keymap_listener);
-ZMK_SUBSCRIPTION(keymap, position_state_changed);
+ZMK_SUBSCRIPTION(keymap, zmk_position_state_changed);
 
 #if ZMK_KEYMAP_HAS_SENSORS
-ZMK_SUBSCRIPTION(keymap, sensor_event);
+ZMK_SUBSCRIPTION(keymap, zmk_sensor_event);
 #endif /* ZMK_KEYMAP_HAS_SENSORS */

app/src/kscan.c

@@ -47,14 +47,10 @@ void zmk_kscan_process_msgq(struct k_work *item) {
     while (k_msgq_get(&zmk_kscan_msgq, &ev, K_NO_WAIT) == 0) {
         bool pressed = (ev.state == ZMK_KSCAN_EVENT_STATE_PRESSED);
         uint32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column);
-        struct position_state_changed *pos_ev;
         LOG_DBG("Row: %d, col: %d, position: %d, pressed: %s\n", ev.row, ev.column, position,
                 (pressed ? "true" : "false"));
-        pos_ev = new_position_state_changed();
+        ZMK_EVENT_RAISE(new_zmk_position_state_changed((struct zmk_position_state_changed){
-        pos_ev->state = pressed;
+            .state = pressed, .position = position, .timestamp = k_uptime_get()}));
-        pos_ev->position = position;
-        pos_ev->timestamp = k_uptime_get();
-        ZMK_EVENT_RAISE(pos_ev);
     }
 }
 

app/src/sensors.c

@@ -35,7 +35,6 @@ static struct sensors_data_item sensors[] = {UTIL_LISTIFY(ZMK_KEYMAP_SENSORS_LEN
 static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_trigger *trigger) {
     int err;
     struct sensors_data_item *item = CONTAINER_OF(trigger, struct sensors_data_item, trigger);
-    struct sensor_event *event;
 
     LOG_DBG("sensor %d", item->sensor_number);
 
@@ -45,12 +44,8 @@ static void zmk_sensors_trigger_handler(const struct device *dev, struct sensor_
         return;
     }
 
-    event = new_sensor_event();
+    ZMK_EVENT_RAISE(new_zmk_sensor_event((struct zmk_sensor_event){
-    event->sensor_number = item->sensor_number;
+        .sensor_number = item->sensor_number, .sensor = dev, .timestamp = k_uptime_get()}));
-    event->sensor = dev;
-    event->timestamp = k_uptime_get();
-
-    ZMK_EVENT_RAISE(event);
 }
 
 static void zmk_sensors_init_item(const char *node, uint8_t i, uint8_t abs_i) {

app/src/split/bluetooth/central.c

@@ -33,25 +33,14 @@ static struct bt_uuid_128 uuid = BT_UUID_INIT_128(ZMK_SPLIT_BT_SERVICE_UUID);
 static struct bt_gatt_discover_params discover_params;
 static struct bt_gatt_subscribe_params subscribe_params;
 
-struct zmk_split_peripheral_event {
+K_MSGQ_DEFINE(peripheral_event_msgq, sizeof(struct zmk_position_state_changed),
-    uint32_t position;
-    uint32_t state;
-    int32_t timestamp;
-};
-
-K_MSGQ_DEFINE(peripheral_event_msgq, sizeof(struct zmk_split_peripheral_event),
               CONFIG_ZMK_SPLIT_BLE_CENTRAL_POSITION_QUEUE_SIZE, 4);
 
 void peripheral_event_work_callback(struct k_work *work) {
-    struct zmk_split_peripheral_event ev;
+    struct zmk_position_state_changed ev;
     while (k_msgq_get(&peripheral_event_msgq, &ev, K_NO_WAIT) == 0) {
-        struct position_state_changed *pos_ev = new_position_state_changed();
-        pos_ev->position = ev.position;
-        pos_ev->state = ev.state;
-        pos_ev->timestamp = ev.timestamp;
-
         LOG_DBG("Trigger key position state change for %d", ev.position);
-        ZMK_EVENT_RAISE(pos_ev);
+        ZMK_EVENT_RAISE(new_zmk_position_state_changed(ev));
     }
 }
 
@@ -82,7 +71,7 @@ static uint8_t split_central_notify_func(struct bt_conn *conn,
             if (changed_positions[i] & BIT(j)) {
                 uint32_t position = (i * 8) + j;
                 bool pressed = position_state[i] & BIT(j);
-                struct zmk_split_peripheral_event ev = {
+                struct zmk_position_state_changed ev = {
                     .position = position, .state = pressed, .timestamp = k_uptime_get()};
 
                 k_msgq_put(&peripheral_event_msgq, &ev, K_NO_WAIT);

app/src/split_listener.c

@@ -19,10 +19,10 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <zmk/hid.h>
 #include <zmk/endpoints.h>
 
-int split_listener(const struct zmk_event_header *eh) {
+int split_listener(const zmk_event_t *eh) {
     LOG_DBG("");
-    if (is_position_state_changed(eh)) {
+    const struct zmk_position_state_changed *ev = as_zmk_position_state_changed(eh);
-        const struct position_state_changed *ev = cast_position_state_changed(eh);
+    if (ev != NULL) {
         if (ev->state) {
             return zmk_split_bt_position_pressed(ev->position);
         } else {
@@ -33,4 +33,4 @@ int split_listener(const struct zmk_event_header *eh) {
 }
 
 ZMK_LISTENER(split_listener, split_listener);
-ZMK_SUBSCRIPTION(split_listener, position_state_changed);
+ZMK_SUBSCRIPTION(split_listener, zmk_position_state_changed);

app/src/usb.c

@@ -55,10 +55,8 @@ int zmk_usb_hid_send_report(const uint8_t *report, size_t len) {
 #endif /* CONFIG_ZMK_USB */
 
 static void raise_usb_status_changed_event() {
-    struct usb_conn_state_changed *ev = new_usb_conn_state_changed();
+    ZMK_EVENT_RAISE(new_zmk_usb_conn_state_changed(
-    ev->conn_state = zmk_usb_get_conn_state();
+        (struct zmk_usb_conn_state_changed){.conn_state = zmk_usb_get_conn_state()}));
-
-    ZMK_EVENT_RAISE(ev);
 }
 
 enum usb_dc_status_code zmk_usb_get_status() { return usb_status; }

app/src/wpm.c

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2020 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <device.h>
+#include <init.h>
+#include <kernel.h>
+
+#include <logging/log.h>
+
+LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
+
+#include <zmk/event_manager.h>
+#include <zmk/events/wpm_state_changed.h>
+#include <zmk/events/keycode_state_changed.h>
+
+#include <zmk/wpm.h>
+
+#define WPM_UPDATE_INTERVAL_SECONDS 1
+#define WPM_RESET_INTERVAL_SECONDS 5
+
+// See https://en.wikipedia.org/wiki/Words_per_minute
+// "Since the length or duration of words is clearly variable, for the purpose of measurement of
+// text entry, the definition of each "word" is often standardized to be five characters or
+// keystrokes long in English"
+#define CHARS_PER_WORD 5.0
+
+static uint8_t wpm_state = -1;
+static uint8_t last_wpm_state;
+static uint8_t wpm_update_counter;
+static uint32_t key_pressed_count;
+
+int zmk_wpm_get_state() { return wpm_state; }
+
+int wpm_event_listener(const zmk_event_t *eh) {
+    const struct zmk_keycode_state_changed *ev = as_zmk_keycode_state_changed(eh);
+    if (ev) {
+        // count only key up events
+        if (!ev->state) {
+            key_pressed_count++;
+            LOG_DBG("key_pressed_count %d keycode %d", key_pressed_count, ev->keycode);
+        }
+    }
+    return 0;
+}
+
+void wpm_work_handler(struct k_work *work) {
+    wpm_update_counter++;
+    wpm_state = (key_pressed_count / CHARS_PER_WORD) /
+                (wpm_update_counter * WPM_UPDATE_INTERVAL_SECONDS / 60.0);
+
+    if (last_wpm_state != wpm_state) {
+        LOG_DBG("Raised WPM state changed %d wpm_update_counter %d", wpm_state, wpm_update_counter);
+
+        ZMK_EVENT_RAISE(
+            new_zmk_wpm_state_changed((struct zmk_wpm_state_changed){.state = wpm_state}));
+
+        last_wpm_state = wpm_state;
+    }
+
+    if (wpm_update_counter >= WPM_RESET_INTERVAL_SECONDS) {
+        wpm_update_counter = 0;
+        key_pressed_count = 0;
+    }
+}
+
+K_WORK_DEFINE(wpm_work, wpm_work_handler);
+
+void wpm_expiry_function() { k_work_submit(&wpm_work); }
+
+K_TIMER_DEFINE(wpm_timer, wpm_expiry_function, NULL);
+
+int wpm_init() {
+    wpm_state = 0;
+    wpm_update_counter = 0;
+    k_timer_start(&wpm_timer, K_SECONDS(WPM_UPDATE_INTERVAL_SECONDS),
+                  K_SECONDS(WPM_UPDATE_INTERVAL_SECONDS));
+    return 0;
+}
+
+ZMK_LISTENER(wpm, wpm_event_listener);
+ZMK_SUBSCRIPTION(wpm, zmk_keycode_state_changed);
+
+SYS_INIT(wpm_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

app/tests/gresc/gresc-press-release/events.patterns

@@ -0,0 +1 @@
+s/.*hid_listener_keycode_//p

app/tests/gresc/gresc-press-release/keycode_events.snapshot

@@ -0,0 +1,18 @@
+pressed: usage_page 0x07 keycode 0x29 mods 0x00
+released: usage_page 0x07 keycode 0x29 mods 0x00
+pressed: usage_page 0x07 keycode 0xe1 mods 0x00
+pressed: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0xe1 mods 0x00
+pressed: usage_page 0x07 keycode 0xe3 mods 0x00
+pressed: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0xe3 mods 0x00
+pressed: usage_page 0x07 keycode 0xe1 mods 0x00
+pressed: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0xe1 mods 0x00
+released: usage_page 0x07 keycode 0x35 mods 0x00
+pressed: usage_page 0x07 keycode 0xe3 mods 0x00
+pressed: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0xe3 mods 0x00
+released: usage_page 0x07 keycode 0x35 mods 0x00

app/tests/gresc/gresc-press-release/native_posix.keymap

@@ -0,0 +1,49 @@
+#include <dt-bindings/zmk/keys.h>
+#include <behaviors.dtsi>
+#include <dt-bindings/zmk/kscan-mock.h>
+
+/ {
+	keymap {
+		compatible = "zmk,keymap";
+		label ="Default keymap";
+
+		default_layer {
+			bindings = <
+				&gresc         &none
+				&kp LEFT_SHIFT &kp LEFT_GUI
+			>;
+		};
+	};
+};
+
+&kscan {
+	events = <
+		/* esc */
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+
+		/* ~ */
+		ZMK_MOCK_PRESS(1,0,10) 
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+		ZMK_MOCK_RELEASE(1,0,10)
+
+		/* LGUI+` */
+		ZMK_MOCK_PRESS(1,1,10) 
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+		ZMK_MOCK_RELEASE(1,1,10)
+
+		/* ~ */
+		ZMK_MOCK_PRESS(1,0,10) 
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(1,0,10)
+		ZMK_MOCK_RELEASE(0,0,10)
+
+		/* LGUI+` */
+		ZMK_MOCK_PRESS(1,1,10) 
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(1,1,10)
+		ZMK_MOCK_RELEASE(0,0,10)
+	>;
+};

app/tests/gresc/gresc-two-instances/events.patterns

@@ -0,0 +1,2 @@
+s/.*hid_listener_keycode_//p
+s/.*on_mod_morph_binding_/morph_binding_/p

app/tests/gresc/gresc-two-instances/keycode_events.snapshot

@@ -0,0 +1,6 @@
+pressed: usage_page 0x07 keycode 0x29 mods 0x00
+released: usage_page 0x07 keycode 0x29 mods 0x00
+pressed: usage_page 0x07 keycode 0xe1 mods 0x00
+pressed: usage_page 0x07 keycode 0x35 mods 0x00
+released: usage_page 0x07 keycode 0xe1 mods 0x00
+released: usage_page 0x07 keycode 0x35 mods 0x00

app/tests/gresc/gresc-two-instances/native_posix.keymap

@@ -0,0 +1,43 @@
+#include <dt-bindings/zmk/keys.h>
+#include <behaviors.dtsi>
+#include <dt-bindings/zmk/kscan-mock.h>
+
+/*
+This test checks nothing breaks if two grave-escapes are pressed at the same time.
+If someone ever really needs two, they can make a second behavior definition.
+
+The second gresc that is pressed is ignored.
+The first gresc that is released releases the key.
+*/
+
+/ {
+	keymap {
+		compatible = "zmk,keymap";
+		label ="Default keymap";
+
+		default_layer {
+			bindings = <
+				&gresc         &gresc
+				&kp LEFT_SHIFT &kp LEFT_GUI
+			>;
+		};
+	};
+};
+
+&kscan {
+	events = <
+		/* esc */
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_PRESS(0,1,10) /* the second gresc is ignored */
+		ZMK_MOCK_RELEASE(0,0,10)
+		ZMK_MOCK_RELEASE(0,1,10) /* the second gresc is ignored */
+
+		/* ~ */
+		ZMK_MOCK_PRESS(1,0,10) 
+		ZMK_MOCK_PRESS(0,1,10)
+		ZMK_MOCK_PRESS(0,0,10)  /* the second gresc is ignored */ 
+		ZMK_MOCK_RELEASE(1,0,10)
+		ZMK_MOCK_RELEASE(0,1,10)
+		ZMK_MOCK_RELEASE(0,0,10)  /* the second gresc is ignored */
+	>;
+};

app/tests/wpm/1-single_keypress/events.patterns

@@ -0,0 +1,2 @@
+s/.*wpm_work_handler: //p
+s/.*wpm_event_listener: //p

app/tests/wpm/1-single_keypress/keycode_events.snapshot

@@ -0,0 +1,7 @@
+key_pressed_count 1 keycode 5
+Raised WPM state changed 12 wpm_update_counter 1
+Raised WPM state changed 6 wpm_update_counter 2
+Raised WPM state changed 4 wpm_update_counter 3
+Raised WPM state changed 3 wpm_update_counter 4
+Raised WPM state changed 2 wpm_update_counter 5
+Raised WPM state changed 0 wpm_update_counter 1

app/tests/wpm/1-single_keypress/native_posix.conf

@@ -0,0 +1,9 @@
+CONFIG_KSCAN=n
+CONFIG_ZMK_KSCAN_MOCK_DRIVER=y
+CONFIG_ZMK_KSCAN_GPIO_DRIVER=n
+CONFIG_GPIO=n
+CONFIG_ZMK_BLE=n
+CONFIG_LOG=y
+CONFIG_LOG_BACKEND_SHOW_COLOR=n
+CONFIG_ZMK_LOG_LEVEL_DBG=y
+CONFIG_ZMK_WPM=y

app/tests/wpm/1-single_keypress/native_posix.keymap

@@ -0,0 +1,10 @@
+#include "../behavior_keymap.dtsi"
+
+&kscan {
+	events = <
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+		/* Wait for the worker to trigger and reset after 5 seconds, followed by a 0 at 6 seconds */
+		ZMK_MOCK_PRESS(0,0,6000) 
+	>;
+};

app/tests/wpm/2-multiple_keypress/events.patterns

@@ -0,0 +1,2 @@
+s/.*wpm_work_handler: //p
+s/.*wpm_event_listener: //p

app/tests/wpm/2-multiple_keypress/keycode_events.snapshot

@@ -0,0 +1,4 @@
+key_pressed_count 1 keycode 5
+Raised WPM state changed 12 wpm_update_counter 1
+key_pressed_count 2 keycode 5
+Raised WPM state changed 8 wpm_update_counter 3

app/tests/wpm/2-multiple_keypress/native_posix.conf

@@ -0,0 +1,9 @@
+CONFIG_KSCAN=n
+CONFIG_ZMK_KSCAN_MOCK_DRIVER=y
+CONFIG_ZMK_KSCAN_GPIO_DRIVER=n
+CONFIG_GPIO=n
+CONFIG_ZMK_BLE=n
+CONFIG_LOG=y
+CONFIG_LOG_BACKEND_SHOW_COLOR=n
+CONFIG_ZMK_LOG_LEVEL_DBG=y
+CONFIG_ZMK_WPM=y

app/tests/wpm/2-multiple_keypress/native_posix.keymap

@@ -0,0 +1,15 @@
+#include "../behavior_keymap.dtsi"
+
+&kscan {
+	events = <
+		ZMK_MOCK_PRESS(0,0,10) 
+		ZMK_MOCK_RELEASE(0,0,10)
+		//1st WPM worker call - 12wpm - 1 key press in 1 second
+		ZMK_MOCK_PRESS(0,0,1000) 
+		ZMK_MOCK_RELEASE(0,0,10)
+		// 2nd WPM worker call - 12wpm - 2 key press in 2 second
+		// note there is no event for this as WPM hasn't changed
+		// 3rd WPM worker call - 8wpm - 2 key press in 3 seconds
+		ZMK_MOCK_PRESS(0,0,2000) 
+	>;
+};

app/tests/wpm/behavior_keymap.dtsi

@@ -0,0 +1,17 @@
+#include <dt-bindings/zmk/keys.h>
+#include <behaviors.dtsi>
+#include <dt-bindings/zmk/kscan_mock.h>
+
+/ {
+	keymap {
+		compatible = "zmk,keymap";
+		label ="Default keymap";
+
+		default_layer {
+			bindings = <
+				&kp B &none
+				&none &none
+			>;
+		};
+	};
+};

docs/docs/behaviors/hold-tap.md

@@ -23,9 +23,9 @@ We call this the 'hold-preferred' flavor of hold-taps. While this flavor may wor
 
 #### Flavors
 
-- The 'hold-preferred' flavor triggers the hold behavior when the tapping_term_ms has expired or another key is pressed.
+- The 'hold-preferred' flavor triggers the hold behavior when the `tapping_term_ms` has expired or another key is pressed.
-- The 'balanced' flavor will trigger the hold behavior when the tapping_term_ms has expired or another key is pressed and released.
+- The 'balanced' flavor will trigger the hold behavior when the `tapping_term_ms` has expired or another key is pressed and released.
-- The 'tap-preferred' flavor triggers the hold behavior when the tapping_term_ms has expired. It triggers the tap behavior when another key is pressed.
+- The 'tap-preferred' flavor triggers the hold behavior when the `tapping_term_ms` has expired. It triggers the tap behavior when another key is pressed.
 
 When the hold-tap key is released and the hold behavior has not been triggered, the tap behavior will trigger.
 
@@ -68,7 +68,7 @@ This example configures a hold-tap that works well for homerow mods:
 
 ```
 
-If this config does not work for you, try the flavor "balanced" with a medium tapping_term_ms such as 200ms.
+If this config does not work for you, try the flavor "balanced" with a medium `tapping_term_ms` such as 200ms.
 
 #### Comparison to QMK
 

docs/docs/features/combos.md

@@ -1,6 +1,5 @@
 ---
-title: Combo Behavior
+title: Combos
-sidebar_label: Combos
 ---
 
 ## Summary
@@ -9,7 +8,7 @@ Combo keys are a way to combine multiple keypresses to output a different key. F
 
 ### Configuration
 
-Combos are specified like this:
+Combos configured in your `.keymap` file, but are separate from the `keymap` node found there, since they are processed before the normal keymap. They are specified like this:
 
 ```
 / {

docs/docs/intro.md

@@ -26,7 +26,7 @@ ZMK is currently missing some features found in other popular firmware. This tab
 | [Display Support](features/displays)[^2]                                                                                  | 🚧  |    🚧     | ✅  |
 | [RGB Underglow](features/underglow)                                                                                       | ✅  |    ✅     | ✅  |
 | One Shot Keys                                                                                                             | ✅  |    ✅     | ✅  |
-| [Combo Keys](behaviors/combos)                                                                                            | ✅  |           | ✅  |
+| [Combo Keys](features/combos)                                                                                             | ✅  |           | ✅  |
 | Macros                                                                                                                    | 🚧  |    ✅     | ✅  |
 | Mouse Keys                                                                                                                | 💡  |    ✅     | ✅  |
 | Low Active Power Usage                                                                                                    | ✅  |           |     |

docs/sidebars.js

@@ -10,6 +10,7 @@ module.exports = {
     ],
     Features: [
       "features/keymaps",
+      "features/combos",
       "features/displays",
       "features/encoders",
       "features/underglow",
@@ -20,7 +21,6 @@ module.exports = {
       "behaviors/misc",
       "behaviors/hold-tap",
       "behaviors/mod-tap",
-      "behaviors/combos",
       "behaviors/reset",
       "behaviors/bluetooth",
       "behaviors/outputs",