diff --git a/app/module/drivers/kscan/CMakeLists.txt b/app/module/drivers/kscan/CMakeLists.txt index d8c78a5c..5b05af76 100644 --- a/app/module/drivers/kscan/CMakeLists.txt +++ b/app/module/drivers/kscan/CMakeLists.txt @@ -5,7 +5,7 @@ zephyr_library_amend() zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_DRIVER kscan_gpio.c) zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_MATRIX kscan_gpio_matrix.c) -zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_CHARLIPLEX kscan_gpio_charliplex.c) +zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_CHARLIEPLEX kscan_gpio_charlieplex.c) zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_DIRECT kscan_gpio_direct.c) zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_GPIO_DEMUX kscan_gpio_demux.c) zephyr_library_sources_ifdef(CONFIG_ZMK_KSCAN_MOCK_DRIVER kscan_mock.c) diff --git a/app/module/drivers/kscan/Kconfig b/app/module/drivers/kscan/Kconfig index fa2bde42..6b701936 100644 --- a/app/module/drivers/kscan/Kconfig +++ b/app/module/drivers/kscan/Kconfig @@ -5,7 +5,7 @@ DT_COMPAT_ZMK_KSCAN_COMPOSITE := zmk,kscan-composite DT_COMPAT_ZMK_KSCAN_GPIO_DEMUX := zmk,kscan-gpio-demux DT_COMPAT_ZMK_KSCAN_GPIO_DIRECT := zmk,kscan-gpio-direct DT_COMPAT_ZMK_KSCAN_GPIO_MATRIX := zmk,kscan-gpio-matrix -DT_COMPAT_ZMK_KSCAN_GPIO_CHARLIPLEX := zmk,kscan-gpio-charliplex +DT_COMPAT_ZMK_KSCAN_GPIO_CHARLIEPLEX := zmk,kscan-gpio-charlieplex DT_COMPAT_ZMK_KSCAN_MOCK := zmk,kscan-mock if KSCAN @@ -34,9 +34,9 @@ config ZMK_KSCAN_GPIO_MATRIX default $(dt_compat_enabled,$(DT_COMPAT_ZMK_KSCAN_GPIO_MATRIX)) select ZMK_KSCAN_GPIO_DRIVER -config ZMK_KSCAN_GPIO_CHARLIPLEX +config ZMK_KSCAN_GPIO_CHARLIEPLEX bool - default $(dt_compat_enabled,$(DT_COMPAT_ZMK_KSCAN_GPIO_CHARLIPLEX)) + default $(dt_compat_enabled,$(DT_COMPAT_ZMK_KSCAN_GPIO_CHARLIEPLEX)) select ZMK_KSCAN_GPIO_DRIVER if ZMK_KSCAN_GPIO_MATRIX @@ -64,9 +64,9 @@ config ZMK_KSCAN_MATRIX_WAIT_BETWEEN_OUTPUTS endif # ZMK_KSCAN_GPIO_MATRIX -if ZMK_KSCAN_GPIO_CHARLIPLEX +if ZMK_KSCAN_GPIO_CHARLIEPLEX -config ZMK_KSCAN_CHARLIPLEX_WAIT_BEFORE_INPUTS +config ZMK_KSCAN_CHARLIEPLEX_WAIT_BEFORE_INPUTS int "Ticks to wait before reading inputs after an output set active" default 0 help @@ -76,8 +76,8 @@ config ZMK_KSCAN_CHARLIPLEX_WAIT_BEFORE_INPUTS the number of ticks to wait after setting an output active before reading the inputs for their active state. -config ZMK_KSCAN_CHARLIPLEX_WAIT_BETWEEN_OUTPUTS - int "Ticks to wait between each output when scanning charliplex matrix" +config ZMK_KSCAN_CHARLIEPLEX_WAIT_BETWEEN_OUTPUTS + int "Ticks to wait between each output when scanning charlieplex matrix" default 0 help When iterating over each output to drive it active, read inputs, then set @@ -86,7 +86,7 @@ config ZMK_KSCAN_CHARLIPLEX_WAIT_BETWEEN_OUTPUTS scenario, set this value to a positive value to configure the number of usecs to wait after reading each column of keys. -endif # ZMK_KSCAN_GPIO_CHARLIPLEX +endif # ZMK_KSCAN_GPIO_CHARLIEPLEX config ZMK_KSCAN_MOCK_DRIVER bool diff --git a/app/module/drivers/kscan/kscan_gpio_charliplex.c b/app/module/drivers/kscan/kscan_gpio_charlieplex.c similarity index 65% rename from app/module/drivers/kscan/kscan_gpio_charliplex.c rename to app/module/drivers/kscan/kscan_gpio_charlieplex.c index 63f847fb..02c029cd 100644 --- a/app/module/drivers/kscan/kscan_gpio_charliplex.c +++ b/app/module/drivers/kscan/kscan_gpio_charlieplex.c @@ -17,10 +17,10 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); -#define DT_DRV_COMPAT zmk_kscan_gpio_charliplex +#define DT_DRV_COMPAT zmk_kscan_gpio_charlieplex #define INST_LEN(n) DT_INST_PROP_LEN(n, gpios) -#define INST_CHARLIPLEX_LEN(n) (INST_LEN(n) * INST_LEN(n)) +#define INST_CHARLIEPLEX_LEN(n) (INST_LEN(n) * INST_LEN(n)) #if CONFIG_ZMK_KSCAN_DEBOUNCE_PRESS_MS >= 0 #define INST_DEBOUNCE_PRESS_MS(n) CONFIG_ZMK_KSCAN_DEBOUNCE_PRESS_MS @@ -59,7 +59,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); #define KSCAN_INTR_CFG_INIT(inst_idx) GPIO_DT_SPEC_GET(DT_DRV_INST(inst_idx), interrupt_gpios) -struct kscan_charliplex_data { +struct kscan_charlieplex_data { const struct device *dev; kscan_callback_t callback; struct k_work_delayable work; @@ -69,7 +69,7 @@ struct kscan_charliplex_data { * Current state of the matrix as a flattened 2D array of length * (config->cells.length ^2) */ - struct zmk_debounce_state *charliplex_state; + struct zmk_debounce_state *charlieplex_state; }; struct kscan_gpio_list { @@ -81,7 +81,7 @@ struct kscan_gpio_list { #define KSCAN_GPIO_LIST(gpio_array) \ ((struct kscan_gpio_list){.gpios = gpio_array, .len = ARRAY_SIZE(gpio_array)}) -struct kscan_charliplex_config { +struct kscan_charlieplex_config { struct kscan_gpio_list cells; struct zmk_debounce_config debounce_config; int32_t debounce_scan_period_ms; @@ -95,7 +95,8 @@ struct kscan_charliplex_config { * There are effectively (n) cols and (n-1) rows, but we use the full col x row space * as a safety measure against someone accidentally defining a transform RC at (p,p) */ -static int state_index(const struct kscan_charliplex_config *config, const int row, const int col) { +static int state_index(const struct kscan_charlieplex_config *config, const int row, + const int col) { __ASSERT(row < config->cells.len, "Invalid row %i", row); __ASSERT(col < config->cells.len, "Invalid column %i", col); __ASSERT(col != row, "Invalid column row pair %i, %i", col, row); @@ -103,7 +104,7 @@ static int state_index(const struct kscan_charliplex_config *config, const int r return (col * config->cells.len) + row; } -static int kscan_charliplex_set_as_input(const struct gpio_dt_spec *gpio) { +static int kscan_charlieplex_set_as_input(const struct gpio_dt_spec *gpio) { if (!device_is_ready(gpio->port)) { LOG_ERR("GPIO is not ready: %s", gpio->port->name); return -ENODEV; @@ -117,7 +118,7 @@ static int kscan_charliplex_set_as_input(const struct gpio_dt_spec *gpio) { return 0; } -static int kscan_charliplex_set_as_output(const struct gpio_dt_spec *gpio) { +static int kscan_charlieplex_set_as_output(const struct gpio_dt_spec *gpio) { if (!device_is_ready(gpio->port)) { LOG_ERR("GPIO is not ready: %s", gpio->port->name); return -ENODEV; @@ -136,11 +137,11 @@ static int kscan_charliplex_set_as_output(const struct gpio_dt_spec *gpio) { return err; } -static int kscan_charliplex_set_all_as_input(const struct device *dev) { - const struct kscan_charliplex_config *config = dev->config; +static int kscan_charlieplex_set_all_as_input(const struct device *dev) { + const struct kscan_charlieplex_config *config = dev->config; int err = 0; for (int i = 0; i < config->cells.len; i++) { - err = kscan_charliplex_set_as_input(&config->cells.gpios[i]); + err = kscan_charlieplex_set_as_input(&config->cells.gpios[i]); if (err) { return err; } @@ -149,8 +150,8 @@ static int kscan_charliplex_set_all_as_input(const struct device *dev) { return 0; } -static int kscan_charliplex_set_all_outputs(const struct device *dev, const int value) { - const struct kscan_charliplex_config *config = dev->config; +static int kscan_charlieplex_set_all_outputs(const struct device *dev, const int value) { + const struct kscan_charlieplex_config *config = dev->config; for (int i = 0; i < config->cells.len; i++) { const struct gpio_dt_spec *gpio = &config->cells.gpios[i]; @@ -170,9 +171,9 @@ static int kscan_charliplex_set_all_outputs(const struct device *dev, const int return 0; } -static int kscan_charliplex_interrupt_configure(const struct device *dev, - const gpio_flags_t flags) { - const struct kscan_charliplex_config *config = dev->config; +static int kscan_charlieplex_interrupt_configure(const struct device *dev, + const gpio_flags_t flags) { + const struct kscan_charlieplex_config *config = dev->config; const struct gpio_dt_spec *gpio = &config->interrupt; int err = gpio_pin_interrupt_configure_dt(gpio, flags); @@ -184,43 +185,43 @@ static int kscan_charliplex_interrupt_configure(const struct device *dev, return 0; } -static int kscan_charliplex_interrupt_enable(const struct device *dev) { - int err = kscan_charliplex_interrupt_configure(dev, GPIO_INT_LEVEL_ACTIVE); +static int kscan_charlieplex_interrupt_enable(const struct device *dev) { + int err = kscan_charlieplex_interrupt_configure(dev, GPIO_INT_LEVEL_ACTIVE); if (err) { return err; } // While interrupts are enabled, set all outputs active so an pressed key will trigger - return kscan_charliplex_set_all_outputs(dev, 1); + return kscan_charlieplex_set_all_outputs(dev, 1); } -static void kscan_charliplex_irq_callback(const struct device *port, struct gpio_callback *cb, - const gpio_port_pins_t _pin) { - struct kscan_charliplex_data *data = - CONTAINER_OF(cb, struct kscan_charliplex_data, irq_callback); +static void kscan_charlieplex_irq_callback(const struct device *port, struct gpio_callback *cb, + const gpio_port_pins_t _pin) { + struct kscan_charlieplex_data *data = + CONTAINER_OF(cb, struct kscan_charlieplex_data, irq_callback); // Disable our interrupt to avoid re-entry while we scan. - kscan_charliplex_interrupt_configure(data->dev, GPIO_INT_DISABLE); + kscan_charlieplex_interrupt_configure(data->dev, GPIO_INT_DISABLE); data->scan_time = k_uptime_get(); k_work_reschedule(&data->work, K_NO_WAIT); } -static void kscan_charliplex_read_continue(const struct device *dev) { - const struct kscan_charliplex_config *config = dev->config; - struct kscan_charliplex_data *data = dev->data; +static void kscan_charlieplex_read_continue(const struct device *dev) { + const struct kscan_charlieplex_config *config = dev->config; + struct kscan_charlieplex_data *data = dev->data; data->scan_time += config->debounce_scan_period_ms; k_work_reschedule(&data->work, K_TIMEOUT_ABS_MS(data->scan_time)); } -static void kscan_charliplex_read_end(const struct device *dev) { - struct kscan_charliplex_data *data = dev->data; - const struct kscan_charliplex_config *config = dev->config; +static void kscan_charlieplex_read_end(const struct device *dev) { + struct kscan_charlieplex_data *data = dev->data; + const struct kscan_charlieplex_config *config = dev->config; if (config->use_interrupt) { // Return to waiting for an interrupt. - kscan_charliplex_interrupt_enable(dev); + kscan_charlieplex_interrupt_enable(dev); } else { data->scan_time += config->poll_period_ms; @@ -229,14 +230,14 @@ static void kscan_charliplex_read_end(const struct device *dev) { } } -static int kscan_charliplex_read(const struct device *dev) { - struct kscan_charliplex_data *data = dev->data; - const struct kscan_charliplex_config *config = dev->config; +static int kscan_charlieplex_read(const struct device *dev) { + struct kscan_charlieplex_data *data = dev->data; + const struct kscan_charlieplex_config *config = dev->config; bool continue_scan = false; // NOTE: RR vs MATRIX: set all pins as input, in case there was a failure on a // previous scan, and one of the pins is still set as output - int err = kscan_charliplex_set_all_as_input(dev); + int err = kscan_charlieplex_set_all_as_input(dev); if (err) { return err; } @@ -244,13 +245,13 @@ static int kscan_charliplex_read(const struct device *dev) { // Scan the matrix. for (int row = 0; row < config->cells.len; row++) { const struct gpio_dt_spec *out_gpio = &config->cells.gpios[row]; - err = kscan_charliplex_set_as_output(out_gpio); + err = kscan_charlieplex_set_as_output(out_gpio); if (err) { return err; } -#if CONFIG_ZMK_KSCAN_CHARLIPLEX_WAIT_BEFORE_INPUTS > 0 - k_busy_wait(CONFIG_ZMK_KSCAN_CHARLIPLEX_WAIT_BEFORE_INPUTS); +#if CONFIG_ZMK_KSCAN_CHARLIEPLEX_WAIT_BEFORE_INPUTS > 0 + k_busy_wait(CONFIG_ZMK_KSCAN_CHARLIEPLEX_WAIT_BEFORE_INPUTS); #endif for (int col = 0; col < config->cells.len; col++) { @@ -260,7 +261,7 @@ static int kscan_charliplex_read(const struct device *dev) { const struct gpio_dt_spec *in_gpio = &config->cells.gpios[col]; const int index = state_index(config, row, col); - struct zmk_debounce_state *state = &data->charliplex_state[index]; + struct zmk_debounce_state *state = &data->charlieplex_state[index]; zmk_debounce_update(state, gpio_pin_get_dt(in_gpio), config->debounce_scan_period_ms, &config->debounce_config); @@ -275,67 +276,67 @@ static int kscan_charliplex_read(const struct device *dev) { continue_scan = continue_scan || zmk_debounce_is_active(state); } - err = kscan_charliplex_set_as_input(out_gpio); + err = kscan_charlieplex_set_as_input(out_gpio); if (err) { return err; } -#if CONFIG_ZMK_KSCAN_CHARLIPLEX_WAIT_BETWEEN_OUTPUTS > 0 - k_busy_wait(CONFIG_ZMK_KSCAN_CHARLIPLEX_WAIT_BETWEEN_OUTPUTS); +#if CONFIG_ZMK_KSCAN_CHARLIEPLEX_WAIT_BETWEEN_OUTPUTS > 0 + k_busy_wait(CONFIG_ZMK_KSCAN_CHARLIEPLEX_WAIT_BETWEEN_OUTPUTS); #endif } if (continue_scan) { // At least one key is pressed or the debouncer has not yet decided if // it is pressed. Poll quickly until everything is released. - kscan_charliplex_read_continue(dev); + kscan_charlieplex_read_continue(dev); } else { // All keys are released. Return to normal. - kscan_charliplex_read_end(dev); + kscan_charlieplex_read_end(dev); } return 0; } -static void kscan_charliplex_work_handler(struct k_work *work) { +static void kscan_charlieplex_work_handler(struct k_work *work) { struct k_work_delayable *dwork = CONTAINER_OF(work, struct k_work_delayable, work); - struct kscan_charliplex_data *data = CONTAINER_OF(dwork, struct kscan_charliplex_data, work); - kscan_charliplex_read(data->dev); + struct kscan_charlieplex_data *data = CONTAINER_OF(dwork, struct kscan_charlieplex_data, work); + kscan_charlieplex_read(data->dev); } -static int kscan_charliplex_configure(const struct device *dev, const kscan_callback_t callback) { +static int kscan_charlieplex_configure(const struct device *dev, const kscan_callback_t callback) { if (!callback) { return -EINVAL; } - struct kscan_charliplex_data *data = dev->data; + struct kscan_charlieplex_data *data = dev->data; data->callback = callback; return 0; } -static int kscan_charliplex_enable(const struct device *dev) { - struct kscan_charliplex_data *data = dev->data; +static int kscan_charlieplex_enable(const struct device *dev) { + struct kscan_charlieplex_data *data = dev->data; data->scan_time = k_uptime_get(); // Read will automatically start interrupts/polling once done. - return kscan_charliplex_read(dev); + return kscan_charlieplex_read(dev); } -static int kscan_charliplex_disable(const struct device *dev) { - struct kscan_charliplex_data *data = dev->data; +static int kscan_charlieplex_disable(const struct device *dev) { + struct kscan_charlieplex_data *data = dev->data; k_work_cancel_delayable(&data->work); - const struct kscan_charliplex_config *config = dev->config; + const struct kscan_charlieplex_config *config = dev->config; if (config->use_interrupt) { - return kscan_charliplex_interrupt_configure(dev, GPIO_INT_DISABLE); + return kscan_charlieplex_interrupt_configure(dev, GPIO_INT_DISABLE); } return 0; } -static int kscan_charliplex_init_inputs(const struct device *dev) { - const struct kscan_charliplex_config *config = dev->config; +static int kscan_charlieplex_init_inputs(const struct device *dev) { + const struct kscan_charlieplex_config *config = dev->config; for (int i = 0; i < config->cells.len; i++) { - int err = kscan_charliplex_set_as_input(&config->cells.gpios[i]); + int err = kscan_charlieplex_set_as_input(&config->cells.gpios[i]); if (err) { return err; } @@ -344,17 +345,17 @@ static int kscan_charliplex_init_inputs(const struct device *dev) { return 0; } -static int kscan_charliplex_init_interrupt(const struct device *dev) { - struct kscan_charliplex_data *data = dev->data; +static int kscan_charlieplex_init_interrupt(const struct device *dev) { + struct kscan_charlieplex_data *data = dev->data; - const struct kscan_charliplex_config *config = dev->config; + const struct kscan_charlieplex_config *config = dev->config; const struct gpio_dt_spec *gpio = &config->interrupt; - int err = kscan_charliplex_set_as_input(gpio); + int err = kscan_charlieplex_set_as_input(gpio); if (err) { return err; } - gpio_init_callback(&data->irq_callback, kscan_charliplex_irq_callback, BIT(gpio->pin)); + gpio_init_callback(&data->irq_callback, kscan_charlieplex_irq_callback, BIT(gpio->pin)); err = gpio_add_callback(gpio->port, &data->irq_callback); if (err) { LOG_ERR("Error adding the callback to the input device: %i", err); @@ -362,43 +363,43 @@ static int kscan_charliplex_init_interrupt(const struct device *dev) { return err; } -static int kscan_charliplex_init(const struct device *dev) { - struct kscan_charliplex_data *data = dev->data; +static int kscan_charlieplex_init(const struct device *dev) { + struct kscan_charlieplex_data *data = dev->data; data->dev = dev; - kscan_charliplex_init_inputs(dev); - kscan_charliplex_set_all_outputs(dev, 0); + kscan_charlieplex_init_inputs(dev); + kscan_charlieplex_set_all_outputs(dev, 0); - const struct kscan_charliplex_config *config = dev->config; + const struct kscan_charlieplex_config *config = dev->config; if (config->use_interrupt) { - kscan_charliplex_init_interrupt(dev); + kscan_charlieplex_init_interrupt(dev); } - k_work_init_delayable(&data->work, kscan_charliplex_work_handler); + k_work_init_delayable(&data->work, kscan_charlieplex_work_handler); return 0; } -static const struct kscan_driver_api kscan_charliplex_api = { - .config = kscan_charliplex_configure, - .enable_callback = kscan_charliplex_enable, - .disable_callback = kscan_charliplex_disable, +static const struct kscan_driver_api kscan_charlieplex_api = { + .config = kscan_charlieplex_configure, + .enable_callback = kscan_charlieplex_enable, + .disable_callback = kscan_charlieplex_disable, }; -#define KSCAN_CHARLIPLEX_INIT(n) \ +#define KSCAN_CHARLIEPLEX_INIT(n) \ BUILD_ASSERT(INST_DEBOUNCE_PRESS_MS(n) <= DEBOUNCE_COUNTER_MAX, \ "ZMK_KSCAN_DEBOUNCE_PRESS_MS or debounce-press-ms is too large"); \ BUILD_ASSERT(INST_DEBOUNCE_RELEASE_MS(n) <= DEBOUNCE_COUNTER_MAX, \ "ZMK_KSCAN_DEBOUNCE_RELEASE_MS or debounce-release-ms is too large"); \ \ - static struct zmk_debounce_state kscan_charliplex_state_##n[INST_CHARLIPLEX_LEN(n)]; \ - static const struct gpio_dt_spec kscan_charliplex_cells_##n[] = { \ + static struct zmk_debounce_state kscan_charlieplex_state_##n[INST_CHARLIEPLEX_LEN(n)]; \ + static const struct gpio_dt_spec kscan_charlieplex_cells_##n[] = { \ UTIL_LISTIFY(INST_LEN(n), KSCAN_GPIO_CFG_INIT, n)}; \ - static struct kscan_charliplex_data kscan_charliplex_data_##n = { \ - .charliplex_state = kscan_charliplex_state_##n, \ + static struct kscan_charlieplex_data kscan_charlieplex_data_##n = { \ + .charlieplex_state = kscan_charlieplex_state_##n, \ }; \ \ - static struct kscan_charliplex_config kscan_charliplex_config_##n = { \ - .cells = KSCAN_GPIO_LIST(kscan_charliplex_cells_##n), \ + static struct kscan_charlieplex_config kscan_charlieplex_config_##n = { \ + .cells = KSCAN_GPIO_LIST(kscan_charlieplex_cells_##n), \ .debounce_config = \ { \ .debounce_press_ms = INST_DEBOUNCE_PRESS_MS(n), \ @@ -409,8 +410,8 @@ static const struct kscan_driver_api kscan_charliplex_api = { COND_POLL_AND_INTR((.use_interrupt = INST_INTR_DEFINED(n), )) \ COND_THIS_INTERRUPT(n, (.interrupt = KSCAN_INTR_CFG_INIT(n), ))}; \ \ - DEVICE_DT_INST_DEFINE(n, &kscan_charliplex_init, NULL, &kscan_charliplex_data_##n, \ - &kscan_charliplex_config_##n, APPLICATION, \ - CONFIG_APPLICATION_INIT_PRIORITY, &kscan_charliplex_api); + DEVICE_DT_INST_DEFINE(n, &kscan_charlieplex_init, NULL, &kscan_charlieplex_data_##n, \ + &kscan_charlieplex_config_##n, APPLICATION, \ + CONFIG_APPLICATION_INIT_PRIORITY, &kscan_charlieplex_api); -DT_INST_FOREACH_STATUS_OKAY(KSCAN_CHARLIPLEX_INIT); +DT_INST_FOREACH_STATUS_OKAY(KSCAN_CHARLIEPLEX_INIT); diff --git a/app/module/dts/bindings/kscan/zmk,kscan-gpio-charliplex.yaml b/app/module/dts/bindings/kscan/zmk,kscan-gpio-charlieplex.yaml similarity index 87% rename from app/module/dts/bindings/kscan/zmk,kscan-gpio-charliplex.yaml rename to app/module/dts/bindings/kscan/zmk,kscan-gpio-charlieplex.yaml index 033c852f..f8da1d27 100644 --- a/app/module/dts/bindings/kscan/zmk,kscan-gpio-charliplex.yaml +++ b/app/module/dts/bindings/kscan/zmk,kscan-gpio-charlieplex.yaml @@ -1,9 +1,9 @@ # Copyright (c) 2023 The ZMK Contributors # SPDX-License-Identifier: MIT -description: GPIO keyboard charliplex matrix controller +description: GPIO keyboard charlieplex matrix controller -compatible: "zmk,kscan-gpio-charliplex" +compatible: "zmk,kscan-gpio-charlieplex" include: kscan.yaml diff --git a/docs/docs/config/kscan.md b/docs/docs/config/kscan.md index 67482d35..18be58af 100644 --- a/docs/docs/config/kscan.md +++ b/docs/docs/config/kscan.md @@ -149,7 +149,7 @@ The output pins (e.g. columns for `col2row`) should have the flag `GPIO_ACTIVE_H }; ``` -## Charliplex Driver +## Charlieplex Driver Keyboard scan driver where keys are arranged on a matrix with each GPIO used as both input and output. @@ -158,16 +158,16 @@ Keyboard scan driver where keys are arranged on a matrix with each GPIO used as Definition file: [zmk/app/drivers/kscan/Kconfig](https://github.com/zmkfirmware/zmk/blob/main/app/drivers/kscan/Kconfig) -| Config | Type | Description | Default | -| -------------------------------------------------- | ----------- | ------------------------------------------------------------------------- | ------- | -| `CONFIG_ZMK_KSCAN_CHARLIPLEX_WAIT_BEFORE_INPUTS` | int (ticks) | How long to wait before reading input pins after setting output active | 0 | -| `CONFIG_ZMK_KSCAN_CHARLIPLEX_WAIT_BETWEEN_OUTPUTS` | int (ticks) | How long to wait between each output to allow previous output to "settle" | 0 | +| Config | Type | Description | Default | +| --------------------------------------------------- | ----------- | ------------------------------------------------------------------------- | ------- | +| `CONFIG_ZMK_KSCAN_CHARLIEPLEX_WAIT_BEFORE_INPUTS` | int (ticks) | How long to wait before reading input pins after setting output active | 0 | +| `CONFIG_ZMK_KSCAN_CHARLIEPLEX_WAIT_BETWEEN_OUTPUTS` | int (ticks) | How long to wait between each output to allow previous output to "settle" | 0 | ### Devicetree -Applies to: `compatible = "zmk,kscan-gpio-charliplex"` +Applies to: `compatible = "zmk,kscan-gpio-charlieplex"` -Definition file: [zmk/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-charliplex.yaml](https://github.com/zmkfirmware/zmk/blob/main/app/drivers/zephyr/dts/bindings/kscan/zmk%2Ckscan-gpio-charliplex.yaml) +Definition file: [zmk/app/drivers/zephyr/dts/bindings/kscan/zmk,kscan-gpio-charlieplex.yaml](https://github.com/zmkfirmware/zmk/blob/main/app/drivers/zephyr/dts/bindings/kscan/zmk%2Ckscan-gpio-charlieplex.yaml) | Property | Type | Description | Default | | ------------------------- | ---------- | ------------------------------------------------------------------------------------------- | ------- | @@ -438,9 +438,9 @@ Consider a keyboard with a [duplex matrix](https://wiki.ai03.com/books/pcb-desig }; ``` -### Example: Charliplex +### Example: Charlieplex -Since a charliplex driver will never align with a keyboard directly due to the un-addressable positions, a matrix transform should be used to map the pairs to the layout of the keys. +Since a charlieplex driver will never align with a keyboard directly due to the un-addressable positions, a matrix transform should be used to map the pairs to the layout of the keys. Note that the entire addressable space does not need to be mapped. ```devicetree @@ -451,7 +451,7 @@ Note that the entire addressable space does not need to be mapped. }; kscan0: kscan { - compatible = "zmk,kscan-gpio-charliplex"; + compatible = "zmk,kscan-gpio-charlieplex"; label = "KSCAN"; interrupt-gpios = <&pro_micro 21 (GPIO_ACTIVE_HIGH | GPIO_PULL_DOWN) >;