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

refactor(app): replace Zephyr integer types with C99 integer types

Browse source 
u8_t → uint8_t
u16_t → uint16_t
u32_t → uint32_t
u64_t → uint64_t
s8_t → int8_t
s16_t → int16_t
s32_t → int32_t
s64_t → int64_t

Prerequisite for #223
See: https://github.com/zephyrproject-rtos/zephyr/releases/tag/zephyr-v2.4.0
PR: #467
This commit is contained in:
innovaker 2020-12-02 16:41:57 +00:00 committed by Pete Johanson
parent a4652fa25d
commit bac1f17cf6
45 changed files with 208 additions and 205 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
app/drivers/kscan/kscan_composite.c
View file

@ -17,8 +17,8 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct kscan_composite_child_config {
char *label;
u8_t row_offset;
u8_t column_offset;
uint8_t row_offset;
uint8_t column_offset;
};
#define CHILD_CONFIG(inst) \
@ -55,7 +55,7 @@ static int kscan_composite_disable_callback(struct device *dev) {
return 0;
}
static void kscan_composite_child_callback(struct device *child_dev, u32_t row, u32_t column,
static void kscan_composite_child_callback(struct device *child_dev, uint32_t row, uint32_t column,
bool pressed) {
// TODO: Ideally we can get this passed into our callback!
struct device *dev = device_get_binding(DT_INST_LABEL(0));

4
app/drivers/kscan/kscan_gpio_demux.c
View file

@ -105,8 +105,8 @@ struct kscan_gpio_item_config {
static bool read_state[INST_MATRIX_INPUTS(n)][INST_MATRIX_OUTPUTS(n)]; \
for (int o = 0; o < INST_MATRIX_OUTPUTS(n); o++) { \
/* Iterate over bits and set GPIOs accordingly */ \
for (u8_t bit = 0; bit < INST_DEMUX_GPIOS(n); bit++) { \
u8_t state = (o & (0b1 << bit)) >> bit; \
for (uint8_t bit = 0; bit < INST_DEMUX_GPIOS(n); bit++) { \
uint8_t state = (o & (0b1 << bit)) >> bit; \
struct device *out_dev = kscan_gpio_output_devices_##n(dev)[bit]; \
const struct kscan_gpio_item_config *out_cfg = \
&kscan_gpio_output_configs_##n(dev)[bit]; \

12
app/drivers/kscan/kscan_gpio_direct.c
View file

@ -27,8 +27,8 @@ union work_reference {
};
struct kscan_gpio_config {
u8_t num_of_inputs;
u8_t debounce_period;
uint8_t num_of_inputs;
uint8_t debounce_period;
struct kscan_gpio_item_config inputs[];
};
@ -39,7 +39,7 @@ struct kscan_gpio_data {
kscan_callback_t callback;
union work_reference work;
struct device *dev;
u32_t pin_state;
uint32_t pin_state;
struct device *inputs[];
};
@ -53,7 +53,7 @@ static const struct kscan_gpio_item_config *kscan_gpio_input_configs(struct devi
return cfg->inputs;
}
static void kscan_gpio_direct_queue_read(union work_reference *work, u8_t debounce_period) {
static void kscan_gpio_direct_queue_read(union work_reference *work, uint8_t debounce_period) {
if (debounce_period > 0) {
k_delayed_work_cancel(&work->delayed);
k_delayed_work_submit(&work->delayed, K_MSEC(debounce_period));
@ -67,7 +67,7 @@ static void kscan_gpio_direct_queue_read(union work_reference *work, u8_t deboun
struct kscan_gpio_irq_callback {
struct device *dev;
union work_reference *work;
u8_t debounce_period;
uint8_t debounce_period;
struct gpio_callback callback;
};
@ -140,7 +140,7 @@ static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t call
static int kscan_gpio_read(struct device *dev) {
struct kscan_gpio_data *data = dev->driver_data;
const struct kscan_gpio_config *cfg = dev->config_info;
u32_t read_state = data->pin_state;
uint32_t read_state = data->pin_state;
bool submit_follow_up_read = false;
for (int i = 0; i < cfg->num_of_inputs; i++) {
struct device *in_dev = kscan_gpio_input_devices(dev)[i];

4
app/drivers/kscan/kscan_gpio_matrix.c
View file

@ -123,8 +123,8 @@ static int kscan_gpio_config_interrupts(struct device **devices,
} \
} \
static void kscan_gpio_set_matrix_state_##n( \
bool state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)], u32_t input_index, \
u32_t output_index, bool value) { \
bool state[INST_MATRIX_ROWS(n)][INST_MATRIX_COLS(n)], uint32_t input_index, \
uint32_t output_index, bool value) { \
state[COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (output_index), \
(input_index))] \
[COND_CODE_0(DT_ENUM_IDX(DT_DRV_INST(n), diode_direction), (input_index), \

8
app/drivers/kscan/kscan_mock.c
View file

@ -18,7 +18,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct kscan_mock_data {
kscan_callback_t callback;
u32_t event_index;
uint32_t event_index;
struct k_delayed_work work;
struct device *dev;
};
@ -45,14 +45,14 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
#define MOCK_INST_INIT(n) \
struct kscan_mock_config_##n { \
u32_t events[DT_INST_PROP_LEN(n, events)]; \
uint32_t events[DT_INST_PROP_LEN(n, events)]; \
bool exit_after; \
}; \
static void kscan_mock_schedule_next_event_##n(struct device *dev) { \
struct kscan_mock_data *data = dev->driver_data; \
const struct kscan_mock_config_##n *cfg = dev->config_info; \
if (data->event_index < DT_INST_PROP_LEN(n, events)) { \
u32_t ev = cfg->events[data->event_index]; \
uint32_t ev = cfg->events[data->event_index]; \
LOG_DBG("delaying next keypress: %d", ZMK_MOCK_MSEC(ev)); \
k_delayed_work_submit(&data->work, K_MSEC(ZMK_MOCK_MSEC(ev))); \
} else if (cfg->exit_after) { \
@ -63,7 +63,7 @@ static int kscan_mock_configure(struct device *dev, kscan_callback_t callback) {
static void kscan_mock_work_handler_##n(struct k_work *work) { \
struct kscan_mock_data *data = CONTAINER_OF(work, struct kscan_mock_data, work); \
const struct kscan_mock_config_##n *cfg = data->dev->config_info; \
u32_t ev = cfg->events[data->event_index]; \
uint32_t ev = cfg->events[data->event_index]; \
LOG_DBG("ev %u row %d column %d state %d\n", ev, ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev), \
ZMK_MOCK_IS_PRESS(ev)); \
data->callback(data->dev, ZMK_MOCK_ROW(ev), ZMK_MOCK_COL(ev), ZMK_MOCK_IS_PRESS(ev)); \

4
app/drivers/sensor/ec11/ec11.c
View file

@ -29,8 +29,8 @@ static int ec11_get_ab_state(struct device *dev) {
static int ec11_sample_fetch(struct device *dev, enum sensor_channel chan) {
struct ec11_data *drv_data = dev->driver_data;
const struct ec11_config *drv_cfg = dev->config_info;
u8_t val;
s8_t delta;
uint8_t val;
int8_t delta;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_ROTATION);

18
app/drivers/sensor/ec11/ec11.h
View file

@ -12,23 +12,23 @@
struct ec11_config {
const char *a_label;
const u8_t a_pin;
const u8_t a_flags;
const uint8_t a_pin;
const uint8_t a_flags;
const char *b_label;
const u8_t b_pin;
const u8_t b_flags;
const uint8_t b_pin;
const uint8_t b_flags;
const u8_t resolution;
const uint8_t resolution;
};
struct ec11_data {
struct device *a;
struct device *b;
u8_t ab_state;
s8_t pulses;
s8_t ticks;
s8_t delta;
uint8_t ab_state;
int8_t pulses;
int8_t ticks;
int8_t delta;
#ifdef CONFIG_EC11_TRIGGER
struct gpio_callback a_gpio_cb;

4
app/drivers/sensor/ec11/ec11_trigger.c
View file

@ -36,7 +36,7 @@ static inline void setup_int(struct device *dev, bool enable) {
}
}
static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) {
static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) {
struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, a_gpio_cb);
LOG_DBG("");
@ -50,7 +50,7 @@ static void ec11_a_gpio_callback(struct device *dev, struct gpio_callback *cb, u
#endif
}
static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) {
static void ec11_b_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) {
struct ec11_data *drv_data = CONTAINER_OF(cb, struct ec11_data, b_gpio_cb);
LOG_DBG("");

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

@ -23,7 +23,7 @@
typedef int (*behavior_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
struct zmk_behavior_binding_event event);
typedef int (*behavior_sensor_keymap_binding_callback_t)(struct zmk_behavior_binding *binding,
struct device *sensor, s64_t timestamp);
struct device *sensor, int64_t timestamp);
__subsystem struct behavior_driver_api {
behavior_keymap_binding_callback_t binding_pressed;
@ -92,11 +92,11 @@ static inline int z_impl_behavior_keymap_binding_released(struct zmk_behavior_bi
* @retval Negative errno code if failure.
*/
__syscall int behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
struct device *sensor, s64_t timestamp);
struct device *sensor, int64_t timestamp);
static inline int
z_impl_behavior_sensor_keymap_binding_triggered(struct zmk_behavior_binding *binding,
struct device *sensor, s64_t timestamp) {
struct device *sensor, int64_t timestamp) {
struct device *dev = device_get_binding(binding->behavior_dev);
const struct behavior_driver_api *api = (const struct behavior_driver_api *)dev->driver_api;

8
app/include/zmk/behavior.h
View file

@ -8,12 +8,12 @@
struct zmk_behavior_binding {
char *behavior_dev;
u32_t param1;
u32_t param2;
uint32_t param1;
uint32_t param2;
};
struct zmk_behavior_binding_event {
int layer;
u32_t position;
s64_t timestamp;
uint32_t position;
int64_t timestamp;
};

2
app/include/zmk/ble.h
View file

@ -12,7 +12,7 @@
int zmk_ble_clear_bonds();
int zmk_ble_prof_next();
int zmk_ble_prof_prev();
int zmk_ble_prof_select(u8_t index);
int zmk_ble_prof_select(uint8_t index);
int zmk_ble_active_profile_index();
bt_addr_le_t *zmk_ble_active_profile_addr();

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

@ -18,4 +18,4 @@ int zmk_endpoints_select(enum zmk_endpoint endpoint);
int zmk_endpoints_toggle();
enum zmk_endpoint zmk_endpoints_selected();
int zmk_endpoints_send_report(u8_t usage_report);
int zmk_endpoints_send_report(uint8_t usage_report);

2
app/include/zmk/event-manager.h
View file

@ -16,7 +16,7 @@ struct zmk_event_type {
struct zmk_event_header {
const struct zmk_event_type *event;
u8_t last_listener_index;
uint8_t last_listener_index;
};
#define ZMK_EV_EVENT_HANDLED 1

2
app/include/zmk/events/battery-state-changed.h
View file

@ -12,7 +12,7 @@
struct battery_state_changed {
struct zmk_event_header header;
// TODO: Other battery channels
u8_t state_of_charge;
uint8_t state_of_charge;
};
ZMK_EVENT_DECLARE(battery_state_changed);

2
app/include/zmk/events/ble-active-profile-changed.h
View file

@ -14,7 +14,7 @@
struct ble_active_profile_changed {
struct zmk_event_header header;
u8_t index;
uint8_t index;
struct zmk_ble_profile *profile;
};

14
app/include/zmk/events/keycode-state-changed.h
View file

@ -14,19 +14,19 @@
struct keycode_state_changed {
struct zmk_event_header header;
u8_t usage_page;
u32_t keycode;
u8_t implicit_modifiers;
uint8_t usage_page;
uint32_t keycode;
uint8_t implicit_modifiers;
bool state;
s64_t timestamp;
int64_t timestamp;
};
ZMK_EVENT_DECLARE(keycode_state_changed);
static inline struct keycode_state_changed *
keycode_state_changed_from_encoded(u32_t encoded, bool pressed, s64_t timestamp) {
u16_t page = HID_USAGE_PAGE(encoded) & 0xFF;
u16_t id = HID_USAGE_ID(encoded);
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 implicit_mods = SELECT_MODS(encoded);
if (!page) {

6
app/include/zmk/events/layer-state-changed.h
View file

@ -11,14 +11,14 @@
struct layer_state_changed {
struct zmk_event_header header;
u8_t layer;
uint8_t layer;
bool state;
s64_t timestamp;
int64_t timestamp;
};
ZMK_EVENT_DECLARE(layer_state_changed);
static inline struct layer_state_changed *create_layer_state_changed(u8_t layer, bool state) {
static inline struct layer_state_changed *create_layer_state_changed(uint8_t layer, bool state) {
struct layer_state_changed *ev = new_layer_state_changed();
ev->layer = layer;
ev->state = state;

4
app/include/zmk/events/position-state-changed.h
View file

@ -11,9 +11,9 @@
struct position_state_changed {
struct zmk_event_header header;
u32_t position;
uint32_t position;
bool state;
s64_t timestamp;
int64_t timestamp;
};
ZMK_EVENT_DECLARE(position_state_changed);

4
app/include/zmk/events/sensor-event.h
View file

@ -12,9 +12,9 @@
struct sensor_event {
struct zmk_event_header header;
u8_t sensor_number;
uint8_t sensor_number;
struct device *sensor;
s64_t timestamp;
int64_t timestamp;
};
ZMK_EVENT_DECLARE(sensor_event);

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

@ -19,7 +19,7 @@
#define ZMK_HID_CONSUMER_NKRO_SIZE 6
static const u8_t zmk_hid_report_desc[] = {
static const uint8_t zmk_hid_report_desc[] = {
/* USAGE_PAGE (Generic Desktop) */
HID_GI_USAGE_PAGE,
HID_USAGE_GD,
@ -141,28 +141,28 @@ static const u8_t zmk_hid_report_desc[] = {
// struct zmk_hid_boot_report
// {
// u8_t modifiers;
// u8_t _unused;
// u8_t keys[6];
// uint8_t modifiers;
// uint8_t _unused;
// uint8_t keys[6];
// } __packed;
struct zmk_hid_keyboard_report_body {
zmk_mod_flags modifiers;
u8_t _reserved;
u8_t keys[ZMK_HID_KEYBOARD_NKRO_SIZE];
uint8_t _reserved;
uint8_t keys[ZMK_HID_KEYBOARD_NKRO_SIZE];
} __packed;
struct zmk_hid_keyboard_report {
u8_t report_id;
uint8_t report_id;
struct zmk_hid_keyboard_report_body body;
} __packed;
struct zmk_hid_consumer_report_body {
u16_t keys[ZMK_HID_CONSUMER_NKRO_SIZE];
uint16_t keys[ZMK_HID_CONSUMER_NKRO_SIZE];
} __packed;
struct zmk_hid_consumer_report {
u8_t report_id;
uint8_t report_id;
struct zmk_hid_consumer_report_body body;
} __packed;

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

@ -6,14 +6,14 @@
#pragma once
typedef u32_t zmk_keymap_layers_state;
typedef uint32_t zmk_keymap_layers_state;
u8_t zmk_keymap_layer_default();
uint8_t zmk_keymap_layer_default();
zmk_keymap_layers_state zmk_keymap_layer_state();
bool zmk_keymap_layer_active(u8_t layer);
u8_t zmk_keymap_highest_layer_active();
int zmk_keymap_layer_activate(u8_t layer);
int zmk_keymap_layer_deactivate(u8_t layer);
int zmk_keymap_layer_toggle(u8_t layer);
bool zmk_keymap_layer_active(uint8_t layer);
uint8_t zmk_keymap_highest_layer_active();
int zmk_keymap_layer_activate(uint8_t layer);
int zmk_keymap_layer_deactivate(uint8_t layer);
int zmk_keymap_layer_toggle(uint8_t layer);
int zmk_keymap_position_state_changed(u32_t position, bool pressed, s64_t timestamp);
int zmk_keymap_position_state_changed(uint32_t position, bool pressed, int64_t timestamp);

12
app/include/zmk/keys.h
View file

@ -9,14 +9,14 @@
#include <zephyr.h>
#include <dt-bindings/zmk/keys.h>
typedef u32_t zmk_key;
typedef u8_t zmk_action;
typedef u8_t zmk_mod;
typedef u8_t zmk_mod_flags;
typedef uint32_t zmk_key;
typedef uint8_t zmk_action;
typedef uint8_t zmk_mod;
typedef uint8_t zmk_mod_flags;
struct zmk_key_event {
u32_t column;
u32_t row;
uint32_t column;
uint32_t row;
zmk_key key;
bool pressed;
};

2
app/include/zmk/matrix_transform.h
View file

@ -6,4 +6,4 @@
#pragma once
u32_t zmk_matrix_transform_row_column_to_position(u32_t row, u32_t column);
uint32_t zmk_matrix_transform_row_column_to_position(uint32_t row, uint32_t column);

4
app/include/zmk/split/bluetooth/service.h
View file

@ -6,5 +6,5 @@
#pragma once
int zmk_split_bt_position_pressed(u8_t position);
int zmk_split_bt_position_released(u8_t position);
int zmk_split_bt_position_pressed(uint8_t position);
int zmk_split_bt_position_released(uint8_t position);

2
app/include/zmk/usb.h
View file

@ -25,5 +25,5 @@ static inline bool zmk_usb_is_powered() { return zmk_usb_get_conn_state() != ZMK
static inline bool zmk_usb_is_hid_ready() { return zmk_usb_get_conn_state() == ZMK_USB_CONN_HID; }
#ifdef CONFIG_ZMK_USB
int zmk_usb_hid_send_report(const u8_t *report, size_t len);
int zmk_usb_hid_send_report(const uint8_t *report, size_t len);
#endif /* CONFIG_ZMK_USB */

18
app/src/behaviors/behavior_hold_tap.c
View file

@ -49,11 +49,11 @@ struct behavior_hold_tap_config {
// this data is specific for each hold-tap
struct active_hold_tap {
s32_t position;
int32_t position;
// todo: move these params into the config->behaviors->tap and
u32_t param_hold;
u32_t param_tap;
s64_t timestamp;
uint32_t param_hold;
uint32_t param_tap;
int64_t timestamp;
bool is_decided;
bool is_hold;
const struct behavior_hold_tap_config *config;
@ -81,7 +81,7 @@ static int capture_event(const struct zmk_event_header *event) {
return -ENOMEM;
}
static struct position_state_changed *find_captured_keydown_event(u32_t position) {
static struct position_state_changed *find_captured_keydown_event(uint32_t position) {
struct 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];
@ -155,7 +155,7 @@ static void release_captured_events() {
}
}
static struct active_hold_tap *find_hold_tap(u32_t position) {
static struct active_hold_tap *find_hold_tap(uint32_t position) {
for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_HELD; i++) {
if (active_hold_taps[i].position == position) {
return &active_hold_taps[i];
@ -164,8 +164,8 @@ static struct active_hold_tap *find_hold_tap(u32_t position) {
return NULL;
}
static struct active_hold_tap *store_hold_tap(u32_t position, u32_t param_hold, u32_t param_tap,
s64_t timestamp,
static struct active_hold_tap *store_hold_tap(uint32_t position, uint32_t param_hold,
uint32_t param_tap, int64_t timestamp,
const struct behavior_hold_tap_config *config) {
for (int i = 0; i < ZMK_BHV_HOLD_TAP_MAX_HELD; i++) {
if (active_hold_taps[i].position != ZMK_BHV_HOLD_TAP_POSITION_NOT_USED) {
@ -326,7 +326,7 @@ static int on_hold_tap_binding_pressed(struct zmk_behavior_binding *binding,
// if this behavior was queued we have to adjust the timer to only
// wait for the remaining time.
s32_t tapping_term_ms_left = (hold_tap->timestamp + cfg->tapping_term_ms) - k_uptime_get();
int32_t tapping_term_ms_left = (hold_tap->timestamp + cfg->tapping_term_ms) - k_uptime_get();
if (tapping_term_ms_left > 0) {
k_delayed_work_submit(&hold_tap->work, K_MSEC(tapping_term_ms_left));
}

4
app/src/behaviors/behavior_sensor_rotate_key_press.c
View file

@ -19,10 +19,10 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
static int behavior_sensor_rotate_key_press_init(struct device *dev) { return 0; };
static int on_sensor_binding_triggered(struct zmk_behavior_binding *binding, struct device *sensor,
s64_t timestamp) {
int64_t timestamp) {
struct sensor_value value;
int err;
u32_t keycode;
uint32_t keycode;
LOG_DBG("inc keycode 0x%02X dec keycode 0x%02X", binding->param1, binding->param2);
err = sensor_channel_get(sensor, SENSOR_CHAN_ROTATION, &value);

26
app/src/behaviors/behavior_sticky_key.c
View file

@ -29,28 +29,29 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#define ZMK_BHV_STICKY_KEY_POSITION_NOT_USED ULONG_MAX
struct behavior_sticky_key_config {
u32_t release_after_ms;
uint32_t release_after_ms;
struct zmk_behavior_binding behavior;
};
struct active_sticky_key {
u32_t position;
u32_t param1;
u32_t param2;
uint32_t position;
uint32_t param1;
uint32_t param2;
const struct behavior_sticky_key_config *config;
// timer data.
bool timer_started;
s64_t release_at;
int64_t release_at;
struct k_delayed_work release_timer;
bool timer_is_cancelled;
// usage page and keycode for the key that is being modified by this sticky key
u8_t modified_key_usage_page;
u32_t modified_key_keycode;
uint8_t modified_key_usage_page;
uint32_t modified_key_keycode;
};
struct active_sticky_key active_sticky_keys[ZMK_BHV_STICKY_KEY_MAX_HELD] = {};
static struct active_sticky_key *store_sticky_key(u32_t position, u32_t param1, u32_t param2,
static struct active_sticky_key *store_sticky_key(uint32_t position, uint32_t param1,
uint32_t param2,
const struct behavior_sticky_key_config *config) {
for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {
if (active_sticky_keys[i].position != ZMK_BHV_STICKY_KEY_POSITION_NOT_USED ||
@ -75,7 +76,7 @@ static void clear_sticky_key(struct active_sticky_key *sticky_key) {
sticky_key->position = ZMK_BHV_STICKY_KEY_POSITION_NOT_USED;
}
static struct active_sticky_key *find_sticky_key(u32_t position) {
static struct active_sticky_key *find_sticky_key(uint32_t position) {
for (int i = 0; i < ZMK_BHV_STICKY_KEY_MAX_HELD; i++) {
if (active_sticky_keys[i].position == position &&
!active_sticky_keys[i].timer_is_cancelled) {
@ -85,7 +86,8 @@ static struct active_sticky_key *find_sticky_key(u32_t position) {
return NULL;
}
static inline int press_sticky_key_behavior(struct active_sticky_key *sticky_key, s64_t timestamp) {
static inline int press_sticky_key_behavior(struct active_sticky_key *sticky_key,
int64_t timestamp) {
struct zmk_behavior_binding binding = {
.behavior_dev = sticky_key->config->behavior.behavior_dev,
.param1 = sticky_key->param1,
@ -99,7 +101,7 @@ static inline int press_sticky_key_behavior(struct active_sticky_key *sticky_key
}
static inline int release_sticky_key_behavior(struct active_sticky_key *sticky_key,
s64_t timestamp) {
int64_t timestamp) {
struct zmk_behavior_binding binding = {
.behavior_dev = sticky_key->config->behavior.behavior_dev,
.param1 = sticky_key->param1,
@ -162,7 +164,7 @@ static int on_sticky_key_binding_released(struct zmk_behavior_binding *binding,
sticky_key->timer_started = true;
sticky_key->release_at = event.timestamp + sticky_key->config->release_after_ms;
// adjust timer in case this behavior was queued by a hold-tap
s32_t ms_left = sticky_key->release_at - k_uptime_get();
int32_t ms_left = sticky_key->release_at - k_uptime_get();
if (ms_left > 0) {
k_delayed_work_submit(&sticky_key->release_timer, K_MSEC(ms_left));
}

20
app/src/ble.c
View file

@ -36,8 +36,8 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/events/ble-active-profile-changed.h>
static struct bt_conn *auth_passkey_entry_conn;
static u8_t passkey_entries[6] = {0, 0, 0, 0, 0, 0};
static u8_t passkey_digit = 0;
static uint8_t passkey_entries[6] = {0, 0, 0, 0, 0, 0};
static uint8_t passkey_digit = 0;
#if IS_ENABLED(CONFIG_ZMK_SPLIT_BLE_ROLE_CENTRAL)
#define PROFILE_COUNT (CONFIG_BT_MAX_PAIRED - 1)
@ -58,7 +58,7 @@ enum advertising_type {
BT_GAP_ADV_FAST_INT_MAX_2, NULL)
static struct zmk_ble_profile profiles[PROFILE_COUNT];
static u8_t active_profile;
static uint8_t active_profile;
#define DEVICE_NAME CONFIG_BT_DEVICE_NAME
#define DEVICE_NAME_LEN (sizeof(DEVICE_NAME) - 1)
@ -104,7 +104,7 @@ bool zmk_ble_active_profile_is_open() {
return !bt_addr_le_cmp(&profiles[active_profile].peer, BT_ADDR_LE_ANY);
}
void set_profile_address(u8_t index, const bt_addr_le_t *addr) {
void set_profile_address(uint8_t index, const bt_addr_le_t *addr) {
char setting_name[15];
char addr_str[BT_ADDR_LE_STR_LEN];
@ -228,7 +228,7 @@ int zmk_ble_clear_bonds() {
int zmk_ble_active_profile_index() { return active_profile; }
int zmk_ble_prof_select(u8_t index) {
int zmk_ble_prof_select(uint8_t index) {
LOG_DBG("profile %d", index);
if (active_profile == index) {
return 0;
@ -277,7 +277,7 @@ static int ble_profiles_handle_set(const char *name, size_t len, settings_read_c
if (settings_name_steq(name, "profiles", &next) && next) {
char *endptr;
u8_t idx = strtoul(next, &endptr, 10);
uint8_t idx = strtoul(next, &endptr, 10);
if (*endptr != '\0') {
LOG_WRN("Invalid profile index: %s", log_strdup(next));
return -EINVAL;
@ -339,7 +339,7 @@ static bool is_conn_active_profile(const struct bt_conn *conn) {
return bt_addr_le_cmp(bt_conn_get_dst(conn), &profiles[active_profile].peer) == 0;
}
static void connected(struct bt_conn *conn, u8_t err) {
static void connected(struct bt_conn *conn, uint8_t err) {
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
LOG_DBG("Connected thread: %p", k_current_get());
@ -372,7 +372,7 @@ static void connected(struct bt_conn *conn, u8_t err) {
}
}
static void disconnected(struct bt_conn *conn, u8_t reason) {
static void disconnected(struct bt_conn *conn, uint8_t reason) {
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
@ -581,12 +581,12 @@ bool zmk_ble_handle_key_user(struct zmk_key_event *key_event) {
return true;
}
u32_t val = (key == NUMBER_0) ? 0 : (key - NUMBER_1 + 1);
uint32_t val = (key == NUMBER_0) ? 0 : (key - NUMBER_1 + 1);
passkey_entries[passkey_digit++] = val;
if (passkey_digit == 6) {
u32_t passkey = 0;
uint32_t passkey = 0;
for (int i = 5; i >= 0; i--) {
passkey = (passkey * 10) + val;
}

2
app/src/display/widgets/battery_status.c
View file

@ -32,7 +32,7 @@ void battery_status_init() {
void set_battery_symbol(lv_obj_t *label) {
char text[2] = " ";
u8_t level = bt_gatt_bas_get_battery_level();
uint8_t level = bt_gatt_bas_get_battery_level();
#if IS_ENABLED(CONFIG_USB)
if (zmk_usb_is_powered()) {

2
app/src/display/widgets/output_status.c
View file

@ -36,7 +36,7 @@ void set_status_symbol(lv_obj_t *label) {
enum zmk_endpoint selected_endpoint = zmk_endpoints_selected();
bool active_profile_connected = zmk_ble_active_profile_is_connected();
bool active_profie_bonded = !zmk_ble_active_profile_is_open();
u8_t active_profile_index = zmk_ble_active_profile_index();
uint8_t active_profile_index = zmk_ble_active_profile_index();
char text[6] = {};
switch (selected_endpoint) {

6
app/src/endpoints.c
View file

@ -61,7 +61,7 @@ static int send_keyboard_report() {
switch (current_endpoint) {
#if IS_ENABLED(CONFIG_ZMK_USB)
case ZMK_ENDPOINT_USB: {
int err = zmk_usb_hid_send_report((u8_t *)keyboard_report, sizeof(*keyboard_report));
int err = zmk_usb_hid_send_report((uint8_t *)keyboard_report, sizeof(*keyboard_report));
if (err) {
LOG_ERR("FAILED TO SEND OVER USB: %d", err);
}
@ -91,7 +91,7 @@ static int send_consumer_report() {
switch (current_endpoint) {
#if IS_ENABLED(CONFIG_ZMK_USB)
case ZMK_ENDPOINT_USB: {
int err = zmk_usb_hid_send_report((u8_t *)consumer_report, sizeof(*consumer_report));
int err = zmk_usb_hid_send_report((uint8_t *)consumer_report, sizeof(*consumer_report));
if (err) {
LOG_ERR("FAILED TO SEND OVER USB: %d", err);
}
@ -115,7 +115,7 @@ static int send_consumer_report() {
}
}
int zmk_endpoints_send_report(u8_t usage_page) {
int zmk_endpoints_send_report(uint8_t usage_page) {
LOG_DBG("usage page 0x%02X", usage_page);
switch (usage_page) {

8
app/src/event_manager.c
View file

@ -17,9 +17,9 @@ 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, u8_t start_index) {
int zmk_event_manager_handle_from(struct zmk_event_header *event, uint8_t start_index) {
int ret = 0;
u8_t len = __event_subscriptions_end - __event_subscriptions_start;
uint8_t len = __event_subscriptions_end - __event_subscriptions_start;
for (int i = start_index; i < len; i++) {
struct zmk_event_subscription *ev_sub = __event_subscriptions_start + i;
if (ev_sub->event_type == event->event) {
@ -54,7 +54,7 @@ int zmk_event_manager_raise(struct zmk_event_header *event) {
int zmk_event_manager_raise_after(struct zmk_event_header *event,
const struct zmk_listener *listener) {
u8_t len = __event_subscriptions_end - __event_subscriptions_start;
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;
@ -70,7 +70,7 @@ int zmk_event_manager_raise_after(struct zmk_event_header *event,
int zmk_event_manager_raise_at(struct zmk_event_header *event,
const struct zmk_listener *listener) {
u8_t len = __event_subscriptions_end - __event_subscriptions_start;
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;

4
app/src/ext_power_generic.c
View file

@ -21,8 +21,8 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
struct ext_power_generic_config {
const char *label;
const u8_t pin;
const u8_t flags;
const uint8_t pin;
const uint8_t flags;
};
struct ext_power_generic_data {

4
app/src/hid_listener.c
View file

@ -16,7 +16,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <dt-bindings/zmk/hid_usage_pages.h>
#include <zmk/endpoints.h>
static int hid_listener_keycode_pressed(u8_t usage_page, u32_t keycode,
static int hid_listener_keycode_pressed(uint8_t usage_page, uint32_t keycode,
zmk_mod_flags implicit_modifiers) {
int err;
LOG_DBG("usage_page 0x%02X keycode 0x%02X mods 0x%02X", usage_page, keycode,
@ -41,7 +41,7 @@ static int hid_listener_keycode_pressed(u8_t usage_page, u32_t keycode,
return zmk_endpoints_send_report(usage_page);
}
static int hid_listener_keycode_released(u8_t usage_page, u32_t keycode,
static int hid_listener_keycode_released(uint8_t usage_page, uint32_t keycode,
zmk_mod_flags implicit_modifiers) {
int err;
LOG_DBG("usage_page 0x%02X keycode 0x%02X mods 0x%02X", usage_page, keycode,

34
app/src/hog.c
View file

@ -23,14 +23,14 @@ enum {
};
struct hids_info {
u16_t version; /* version number of base USB HID Specification */
u8_t code; /* country HID Device hardware is localized for. */
u8_t flags;
uint16_t version; /* version number of base USB HID Specification */
uint8_t code; /* country HID Device hardware is localized for. */
uint8_t flags;
} __packed;
struct hids_report {
u8_t id; /* report id */
u8_t type; /* report type */
uint8_t id; /* report id */
uint8_t type; /* report type */
} __packed;
static struct hids_info info = {
@ -56,29 +56,29 @@ static struct hids_report consumer_input = {
};
static bool host_requests_notification = false;
static u8_t ctrl_point;
// static u8_t proto_mode;
static uint8_t ctrl_point;
// static uint8_t proto_mode;
static ssize_t read_hids_info(struct bt_conn *conn, const struct bt_gatt_attr *attr, void *buf,
u16_t len, u16_t offset) {
uint16_t len, uint16_t offset) {
return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data,
sizeof(struct hids_info));
}
static ssize_t read_hids_report_ref(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, u16_t len, u16_t offset) {
void *buf, uint16_t len, uint16_t offset) {
return bt_gatt_attr_read(conn, attr, buf, len, offset, attr->user_data,
sizeof(struct hids_report));
}
static ssize_t read_hids_report_map(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, u16_t len, u16_t offset) {
void *buf, uint16_t len, uint16_t offset) {
return bt_gatt_attr_read(conn, attr, buf, len, offset, zmk_hid_report_desc,
sizeof(zmk_hid_report_desc));
}
static ssize_t read_hids_input_report(struct bt_conn *conn, const struct bt_gatt_attr *attr,
void *buf, u16_t len, u16_t offset) {
void *buf, uint16_t len, uint16_t offset) {
struct zmk_hid_keyboard_report_body *report_body = &zmk_hid_get_keyboard_report()->body;
return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body,
sizeof(struct zmk_hid_keyboard_report_body));
@ -86,7 +86,7 @@ static ssize_t read_hids_input_report(struct bt_conn *conn, const struct bt_gatt
static ssize_t read_hids_consumer_input_report(struct bt_conn *conn,
const struct bt_gatt_attr *attr, void *buf,
u16_t len, u16_t offset) {
uint16_t len, uint16_t offset) {
struct zmk_hid_consumer_report_body *report_body = &zmk_hid_get_consumer_report()->body;
return bt_gatt_attr_read(conn, attr, buf, len, offset, report_body,
sizeof(struct zmk_hid_consumer_report_body));
@ -94,20 +94,20 @@ static ssize_t read_hids_consumer_input_report(struct bt_conn *conn,
// static ssize_t write_proto_mode(struct bt_conn *conn,
// const struct bt_gatt_attr *attr,
// const void *buf, u16_t len, u16_t offset,
// u8_t flags)
// const void *buf, uint16_t len, uint16_t offset,
// uint8_t flags)
// {
// printk("PROTO CHANGED\n");
// return 0;
// }
static void input_ccc_changed(const struct bt_gatt_attr *attr, u16_t value) {
static void input_ccc_changed(const struct bt_gatt_attr *attr, uint16_t value) {
host_requests_notification = (value == BT_GATT_CCC_NOTIFY) ? 1 : 0;
}
static ssize_t write_ctrl_point(struct bt_conn *conn, const struct bt_gatt_attr *attr,
const void *buf, u16_t len, u16_t offset, u8_t flags) {
u8_t *value = attr->user_data;
const void *buf, uint16_t len, uint16_t offset, uint8_t flags) {
uint8_t *value = attr->user_data;
if (offset + len > sizeof(ctrl_point)) {
return BT_GATT_ERR(BT_ATT_ERR_INVALID_OFFSET);

28
app/src/keymap.c
View file

@ -20,7 +20,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/events/sensor-event.h>
static zmk_keymap_layers_state _zmk_keymap_layer_state = 0;
static u8_t _zmk_keymap_layer_default = 0;
static uint8_t _zmk_keymap_layer_default = 0;
#define DT_DRV_COMPAT zmk_keymap
@ -64,7 +64,7 @@ static u8_t _zmk_keymap_layer_default = 0;
// When a behavior handles a key position "down" event, we record the layer state
// here so that even if that layer is deactivated before the "up", event, we
// still send the release event to the behavior in that layer also.
static u32_t zmk_keymap_active_behavior_layer[ZMK_KEYMAP_LEN];
static uint32_t zmk_keymap_active_behavior_layer[ZMK_KEYMAP_LEN];
static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_LEN] = {
DT_INST_FOREACH_CHILD(0, TRANSFORMED_LAYER)};
@ -77,7 +77,7 @@ static struct zmk_behavior_binding zmk_sensor_keymap[ZMK_KEYMAP_LAYERS_LEN]
#endif /* ZMK_KEYMAP_HAS_SENSORS */
static inline int set_layer_state(u8_t layer, bool state) {
static inline int set_layer_state(uint8_t layer, bool state) {
if (layer >= 32) {
return -EINVAL;
}
@ -86,16 +86,16 @@ static inline int set_layer_state(u8_t layer, bool state) {
return 0;
}
u8_t zmk_keymap_layer_default() { return _zmk_keymap_layer_default; }
uint8_t zmk_keymap_layer_default() { return _zmk_keymap_layer_default; }
zmk_keymap_layers_state zmk_keymap_layer_state() { return _zmk_keymap_layer_state; }
bool zmk_keymap_layer_active(u8_t layer) {
bool zmk_keymap_layer_active(uint8_t layer) {
return (_zmk_keymap_layer_state & (BIT(layer))) == (BIT(layer));
};
u8_t zmk_keymap_highest_layer_active() {
for (u8_t layer = 31; layer > 0; layer--) {
uint8_t zmk_keymap_highest_layer_active() {
for (uint8_t layer = 31; layer > 0; layer--) {
if (zmk_keymap_layer_active(layer)) {
return layer;
}
@ -103,11 +103,11 @@ u8_t zmk_keymap_highest_layer_active() {
return zmk_keymap_layer_default();
}
int zmk_keymap_layer_activate(u8_t layer) { return set_layer_state(layer, true); };
int zmk_keymap_layer_activate(uint8_t layer) { return set_layer_state(layer, true); };
int zmk_keymap_layer_deactivate(u8_t layer) { return set_layer_state(layer, false); };
int zmk_keymap_layer_deactivate(uint8_t layer) { return set_layer_state(layer, false); };
int zmk_keymap_layer_toggle(u8_t layer) {
int zmk_keymap_layer_toggle(uint8_t layer) {
if (zmk_keymap_layer_active(layer)) {
return zmk_keymap_layer_deactivate(layer);
}
@ -115,11 +115,11 @@ int zmk_keymap_layer_toggle(u8_t layer) {
return zmk_keymap_layer_activate(layer);
};
bool is_active_layer(u8_t layer, zmk_keymap_layers_state layer_state) {
bool is_active_layer(uint8_t layer, zmk_keymap_layers_state layer_state) {
return (layer_state & BIT(layer)) == BIT(layer) || layer == _zmk_keymap_layer_default;
}
int zmk_keymap_apply_position_state(int layer, u32_t position, bool pressed, s64_t timestamp) {
int zmk_keymap_apply_position_state(int layer, uint32_t position, bool pressed, int64_t timestamp) {
struct zmk_behavior_binding *binding = &zmk_keymap[layer][position];
struct device *behavior;
struct zmk_behavior_binding_event event = {
@ -145,7 +145,7 @@ int zmk_keymap_apply_position_state(int layer, u32_t position, bool pressed, s64
}
}
int zmk_keymap_position_state_changed(u32_t position, bool pressed, s64_t timestamp) {
int zmk_keymap_position_state_changed(uint32_t position, bool pressed, int64_t timestamp) {
if (pressed) {
zmk_keymap_active_behavior_layer[position] = _zmk_keymap_layer_state;
}
@ -168,7 +168,7 @@ int zmk_keymap_position_state_changed(u32_t position, bool pressed, s64_t timest
}
#if ZMK_KEYMAP_HAS_SENSORS
int zmk_keymap_sensor_triggered(u8_t sensor_number, struct device *sensor, s64_t timestamp) {
int zmk_keymap_sensor_triggered(uint8_t sensor_number, struct device *sensor, int64_t timestamp) {
for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= _zmk_keymap_layer_default; layer--) {
if (((_zmk_keymap_layer_state & BIT(layer)) == BIT(layer) ||
layer == _zmk_keymap_layer_default) &&

10
app/src/kscan.c
View file

@ -19,9 +19,9 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#define ZMK_KSCAN_EVENT_STATE_RELEASED 1
struct zmk_kscan_event {
u32_t row;
u32_t column;
u32_t state;
uint32_t row;
uint32_t column;
uint32_t state;
};
struct zmk_kscan_msg_processor {
@ -30,7 +30,7 @@ struct zmk_kscan_msg_processor {
K_MSGQ_DEFINE(zmk_kscan_msgq, sizeof(struct zmk_kscan_event), CONFIG_ZMK_KSCAN_EVENT_QUEUE_SIZE, 4);
static void zmk_kscan_callback(struct device *dev, u32_t row, u32_t column, bool pressed) {
static void zmk_kscan_callback(struct device *dev, uint32_t row, uint32_t column, bool pressed) {
struct zmk_kscan_event ev = {
.row = row,
.column = column,
@ -45,7 +45,7 @@ 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);
u32_t position = zmk_matrix_transform_row_column_to_position(ev.row, ev.column);
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"));

6
app/src/matrix_transform.c
View file

@ -15,12 +15,12 @@
[(KT_ROW(DT_PROP_BY_IDX(ZMK_KEYMAP_TRANSFORM_NODE, map, i)) * ZMK_MATRIX_COLS) + \
KT_COL(DT_PROP_BY_IDX(ZMK_KEYMAP_TRANSFORM_NODE, map, i))] = i,
static u32_t transform[] = {UTIL_LISTIFY(ZMK_KEYMAP_LEN, _TRANSFORM_ENTRY, 0)};
static uint32_t transform[] = {UTIL_LISTIFY(ZMK_KEYMAP_LEN, _TRANSFORM_ENTRY, 0)};
#endif
u32_t zmk_matrix_transform_row_column_to_position(u32_t row, u32_t column) {
u32_t matrix_index;
uint32_t zmk_matrix_transform_row_column_to_position(uint32_t row, uint32_t column) {
uint32_t matrix_index;
#if DT_NODE_HAS_PROP(ZMK_KEYMAP_TRANSFORM_NODE, col_offset)
column += DT_PROP(ZMK_KEYMAP_TRANSFORM_NODE, col_offset);

6
app/src/power.c
View file

@ -17,7 +17,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/events/position-state-changed.h>
#include <zmk/events/sensor-event.h>
static u32_t power_last_uptime;
static uint32_t power_last_uptime;
#define MAX_IDLE_MS CONFIG_ZMK_IDLE_SLEEP_TIMEOUT
@ -29,10 +29,10 @@ bool is_usb_power_present() {
#endif /* CONFIG_USB */
}
enum power_states sys_pm_policy_next_state(s32_t ticks) {
enum power_states sys_pm_policy_next_state(int32_t ticks) {
#ifdef CONFIG_SYS_POWER_DEEP_SLEEP_STATES
#ifdef CONFIG_HAS_SYS_POWER_STATE_DEEP_SLEEP_1
s32_t current = k_uptime_get();
int32_t current = k_uptime_get();
if (power_last_uptime > 0 && !is_usb_power_present() &&
current - power_last_uptime > MAX_IDLE_MS) {
return SYS_POWER_STATE_DEEP_SLEEP_1;

20
app/src/rgb_underglow.c
View file

@ -31,18 +31,18 @@ enum rgb_underglow_effect {
};
struct led_hsb {
u16_t h;
u8_t s;
u8_t b;
uint16_t h;
uint8_t s;
uint8_t b;
};
struct rgb_underglow_state {
u16_t hue;
u8_t saturation;
u8_t brightness;
u8_t animation_speed;
u8_t current_effect;
u16_t animation_step;
uint16_t hue;
uint8_t saturation;
uint8_t brightness;
uint8_t animation_speed;
uint8_t current_effect;
uint16_t animation_step;
bool on;
};
@ -59,7 +59,7 @@ static struct device *ext_power;
static struct led_rgb hsb_to_rgb(struct led_hsb hsb) {
double r, g, b;
u8_t i = hsb.h / 60;
uint8_t i = hsb.h / 60;
double v = hsb.b / 100.0;
double s = hsb.s / 100.0;
double f = hsb.h / 360.0 * 6 - i;

4
app/src/sensors.c
View file

@ -19,7 +19,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#if ZMK_KEYMAP_HAS_SENSORS
struct sensors_data_item {
u8_t sensor_number;
uint8_t sensor_number;
struct device *dev;
struct sensor_trigger trigger;
};
@ -53,7 +53,7 @@ static void zmk_sensors_trigger_handler(struct device *dev, struct sensor_trigge
ZMK_EVENT_RAISE(event);
}
static void zmk_sensors_init_item(const char *node, u8_t i, u8_t abs_i) {
static void zmk_sensors_init_item(const char *node, uint8_t i, uint8_t abs_i) {
LOG_DBG("Init %s at index %d with sensor_number %d", node, i, abs_i);
sensors[i].dev = device_get_binding(node);

25
app/src/split/bluetooth/central.c
View file

@ -33,11 +33,12 @@ 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;
static u8_t split_central_notify_func(struct bt_conn *conn, struct bt_gatt_subscribe_params *params,
const void *data, u16_t length) {
static u8_t position_state[POSITION_STATE_DATA_LEN];
static uint8_t split_central_notify_func(struct bt_conn *conn,
struct bt_gatt_subscribe_params *params, const void *data,
uint16_t length) {
static uint8_t position_state[POSITION_STATE_DATA_LEN];
u8_t changed_positions[POSITION_STATE_DATA_LEN];
uint8_t changed_positions[POSITION_STATE_DATA_LEN];
if (!data) {
LOG_DBG("[UNSUBSCRIBED]");
@ -48,14 +49,14 @@ static u8_t split_central_notify_func(struct bt_conn *conn, struct bt_gatt_subsc
LOG_DBG("[NOTIFICATION] data %p length %u", data, length);
for (int i = 0; i < POSITION_STATE_DATA_LEN; i++) {
changed_positions[i] = ((u8_t *)data)[i] ^ position_state[i];
position_state[i] = ((u8_t *)data)[i];
changed_positions[i] = ((uint8_t *)data)[i] ^ position_state[i];
position_state[i] = ((uint8_t *)data)[i];
}
for (int i = 0; i < POSITION_STATE_DATA_LEN; i++) {
for (int j = 0; j < 8; j++) {
if (changed_positions[i] & BIT(j)) {
u32_t position = (i * 8) + j;
uint32_t position = (i * 8) + j;
bool pressed = position_state[i] & BIT(j);
struct position_state_changed *pos_ev = new_position_state_changed();
pos_ev->position = position;
@ -91,8 +92,8 @@ static int split_central_subscribe(struct bt_conn *conn) {
return 0;
}
static u8_t split_central_discovery_func(struct bt_conn *conn, const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params) {
static uint8_t split_central_discovery_func(struct bt_conn *conn, const struct bt_gatt_attr *attr,
struct bt_gatt_discover_params *params) {
int err;
if (!attr) {
@ -245,7 +246,7 @@ static bool split_central_eir_found(struct bt_data *data, void *user_data) {
return true;
}
static void split_central_device_found(const bt_addr_le_t *addr, s8_t rssi, u8_t type,
static void split_central_device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
struct net_buf_simple *ad) {
char dev[BT_ADDR_LE_STR_LEN];
@ -272,7 +273,7 @@ static int start_scan(void) {
return 0;
}
static void split_central_connected(struct bt_conn *conn, u8_t conn_err) {
static void split_central_connected(struct bt_conn *conn, uint8_t conn_err) {
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
@ -292,7 +293,7 @@ static void split_central_connected(struct bt_conn *conn, u8_t conn_err) {
split_central_process_connection(conn);
}
static void split_central_disconnected(struct bt_conn *conn, u8_t reason) {
static void split_central_disconnected(struct bt_conn *conn, uint8_t reason) {
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));

16
app/src/split/bluetooth/service.c
View file

@ -18,21 +18,21 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#include <zmk/split/bluetooth/uuid.h>
#include <zmk/split/bluetooth/service.h>
static u8_t num_of_positions = ZMK_KEYMAP_LEN;
static u8_t position_state[16];
static uint8_t num_of_positions = ZMK_KEYMAP_LEN;
static uint8_t position_state[16];
static ssize_t split_svc_pos_state(struct bt_conn *conn, const struct bt_gatt_attr *attrs,
void *buf, u16_t len, u16_t offset) {
void *buf, uint16_t len, uint16_t offset) {
return bt_gatt_attr_read(conn, attrs, buf, len, offset, &position_state,
sizeof(position_state));
}
static ssize_t split_svc_num_of_positions(struct bt_conn *conn, const struct bt_gatt_attr *attrs,
void *buf, u16_t len, u16_t offset) {
return bt_gatt_attr_read(conn, attrs, buf, len, offset, attrs->user_data, sizeof(u8_t));
void *buf, uint16_t len, uint16_t offset) {
return bt_gatt_attr_read(conn, attrs, buf, len, offset, attrs->user_data, sizeof(uint8_t));
}
static void split_svc_pos_state_ccc(const struct bt_gatt_attr *attr, u16_t value) {
static void split_svc_pos_state_ccc(const struct bt_gatt_attr *attr, uint16_t value) {
LOG_DBG("value %d", value);
}
@ -45,12 +45,12 @@ BT_GATT_SERVICE_DEFINE(
BT_GATT_DESCRIPTOR(BT_UUID_NUM_OF_DIGITALS, BT_GATT_PERM_READ, split_svc_num_of_positions, NULL,
&num_of_positions), );
int zmk_split_bt_position_pressed(u8_t position) {
int zmk_split_bt_position_pressed(uint8_t position) {
WRITE_BIT(position_state[position / 8], position % 8, true);
return bt_gatt_notify(NULL, &split_svc.attrs[1], &position_state, sizeof(position_state));
}
int zmk_split_bt_position_released(u8_t position) {
int zmk_split_bt_position_released(uint8_t position) {
WRITE_BIT(position_state[position / 8], position % 8, false);
return bt_gatt_notify(NULL, &split_svc.attrs[1], &position_state, sizeof(position_state));
}

4
app/src/usb.c
View file

@ -31,7 +31,7 @@ static const struct hid_ops ops = {
.int_in_ready = in_ready_cb,
};
int zmk_usb_hid_send_report(const u8_t *report, size_t len) {
int zmk_usb_hid_send_report(const uint8_t *report, size_t len) {
switch (usb_status) {
case USB_DC_SUSPEND:
return usb_wakeup_request();
@ -78,7 +78,7 @@ enum zmk_usb_conn_state zmk_usb_get_conn_state() {
}
}
void usb_status_cb(enum usb_dc_status_code status, const u8_t *params) {
void usb_status_cb(enum usb_dc_status_code status, const uint8_t *params) {
usb_status = status;
raise_usb_status_changed_event();
};