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

Merge pull request #40 from petejohanson/boards/clueboard-california-macropad

Browse source 
Initial working Clueboard California Macropad w/ proton-c fixes
This commit is contained in:
Pete Johanson 2020-06-24 10:46:02 -04:00 committed by GitHub
commit b1cab32c66
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
19 changed files with 414 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
.gitignore vendored
View file

@ -1,6 +1,6 @@
.west/ /.west
bootloader/ /bootloader
modules/ /modules
tools/ /tools
zephyr/ /zephyr
build/ /build

2
app/boards/arm/planck/planck_rev6.dts
View file

@ -55,7 +55,7 @@
}; };
kscan { kscan {
compatible = "gpio-kscan"; compatible = "zmk,kscan-gpio-matrix";
label = "Keyscan Matrix"; label = "Keyscan Matrix";
row-gpios = <&gpioa 10 GPIO_ACTIVE_HIGH>, row-gpios = <&gpioa 10 GPIO_ACTIVE_HIGH>,
<&gpioa 9 GPIO_ACTIVE_HIGH>, <&gpioa 9 GPIO_ACTIVE_HIGH>,

5
app/boards/arm/proton_c/board.cmake
View file

@ -1,6 +1,7 @@
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
board_runner_args(jlink "--device=STM32F303VC" "--speed=4000") board_runner_args(dfu-util "--pid=0483:df11" "--alt=0" "--dfuse")
board_runner_args(jlink "--device=STM32F303CC" "--speed=4000")
include(${ZEPHYR_BASE}/boards/common/openocd.board.cmake) include(${ZEPHYR_BASE}/boards/common/dfu-util.board.cmake)
include(${ZEPHYR_BASE}/boards/common/jlink.board.cmake) include(${ZEPHYR_BASE}/boards/common/jlink.board.cmake)

14
app/boards/shields/clueboard_california/Kconfig.defconfig Normal file
View file

@ -0,0 +1,14 @@
if SHIELD_CLUEBOARD_CALIFORNIA
config ZMK_KEYBOARD_NAME
default "Clueboard California Macropad"
# Unable to use interrupts as the same pin number is used
# across A & B controllers, and STM32F303CCT6 can't enable
# interrutps for multiple controllers for the same "line"
# for the external interrupts.
config ZMK_KSCAN_GPIO_POLLING
default y
endif

5
app/boards/shields/clueboard_california/Kconfig.shield Normal file
View file

@ -0,0 +1,5 @@
# Copyright (c) 2020 Pete Johanson
# SPDX-License-Identifier: MIT
config SHIELD_CLUEBOARD_CALIFORNIA
def_bool $(shields_list_contains,clueboard_california)

0
app/boards/shields/clueboard_california/clueboard_california.conf Normal file
View file

34
app/boards/shields/clueboard_california/clueboard_california.overlay Normal file
View file

@ -0,0 +1,34 @@
/*
* Copyright (c) 2020 Pete Johanson
*
* SPDX-License-Identifier: MIT
*/
/ {
chosen {
zmk,kscan = &kscan0;
};
kscan0: kscan_0 {
compatible = "zmk,kscan-gpio-direct";
label = "KSCAN";
input-gpios
= <&gpioa 10 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpioa 9 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpioa 0 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpiob 8 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpiob 11 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpiob 9 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpioa 8 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpioa 7 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpiob 1 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
, <&gpiob 2 (GPIO_ACTIVE_LOW | GPIO_PULL_UP)>
;
};
// TODO: Per-key LED node(s)
};

24
app/boards/shields/clueboard_california/keymap/keymap.overlay Normal file
View file

@ -0,0 +1,24 @@
#include <dt-bindings/zmk/keys.h>
#include <dt-bindings/zmk/matrix-transform.h>
#include <keymap.h>
/ {
chosen {
zmk,keymap = &keymap0;
};
keymap0: keymap {
compatible = "zmk,keymap";
label ="Default Kyria Keymap";
layers = <&default>;
};
layers {
compatible = "zmk,layers";
default: layer_0 {
label = "DEFAULT";
keys = <KC_9 KC_8 KC_7 KC_6 KC_5 KC_4 KC_3 KC_2 KC_1 KC_0>;
};
};
};

24
app/boards/shields/clueboard_california/readme.md Normal file
View file

@ -0,0 +1,24 @@
# [Clueboard California Macropad](https://clueboard.co/parts/clueboard-california-macropad-kit)
A small 10-key macropad in the shape of the US state of California.
## Features
- Per key LED.
- Proton-C only, including space for the piezo speaker.
- Direct GPIO wiring, no GPIO matrix at all.
## Hardware Notes
| Switch | Switch Pin | LED Pin |
| ------------ | ---------- | ------- |
| shasta1 | a10 | a2 |
| modoc1 | a9 | b5 |
| mendocino1 | a0 | a1 |
| lassen1 | b8 | b4 |
| eldorado1 | b11 | b12 |
| big_sur1 | b9 | b10 |
| sierra1 | a8 | a15 |
| los_padres1 | a7 | a6 |
| mojave1 | b1 | b0 |
| joshua_tree1 | b2 | b3 |

4
app/boards/shields/kyria/kyria.overlay
View file

@ -29,7 +29,7 @@
}; };
kscan_left: kscan_left { kscan_left: kscan_left {
compatible = "gpio-kscan"; compatible = "zmk,kscan-gpio-matrix";
label = "KSCAN_LEFT"; label = "KSCAN_LEFT";
diode-direction = "row2col"; diode-direction = "row2col";
@ -49,7 +49,7 @@
}; };
kscan_right: kscan_right { kscan_right: kscan_right {
compatible = "gpio-kscan"; compatible = "zmk,kscan-gpio-matrix";
label = "KSCAN_RIGHT"; label = "KSCAN_RIGHT";
diode-direction = "row2col"; diode-direction = "row2col";

4
app/boards/shields/petejohanson_handwire/petejohanson_handwire.overlay
View file

@ -21,7 +21,7 @@
}; };
left_hand: kscan_1 { left_hand: kscan_1 {
compatible = "gpio-kscan"; compatible = "zmk,kscan-gpio-matrix";
label = "KSCAN_LEFT"; label = "KSCAN_LEFT";
diode-direction = "row2col"; diode-direction = "row2col";
@ -32,7 +32,7 @@
}; };
right_hand: kscan_2 { right_hand: kscan_2 {
compatible = "gpio-kscan"; compatible = "zmk,kscan-gpio-matrix";
label = "KSCAN_RIGHT"; label = "KSCAN_RIGHT";
diode-direction = "row2col"; diode-direction = "row2col";

2
app/boards/shields/petejohanson_proton_handwire/petejohanson_proton_handwire.overlay
View file

@ -5,7 +5,7 @@
}; };
kscan0: kscan { kscan0: kscan {
compatible = "gpio-kscan"; compatible = "zmk,kscan-gpio-matrix";
label = "KSCAN"; label = "KSCAN";
diode-direction = "row2col"; diode-direction = "row2col";

4
app/drivers/zephyr/CMakeLists.txt
View file

@ -1,9 +1,9 @@
if(CONFIG_ZMK_KSCAN_GPIO_DRIVER) if(CONFIG_ZMK_KSCAN_GPIO_DRIVER)
# Add hello_world_driver.h to the set of global include paths.
zephyr_include_directories(.) zephyr_include_directories(.)
zephyr_library() zephyr_library()
zephyr_library_sources( zephyr_library_sources(
kscan_gpio.c kscan_gpio_matrix.c
kscan_gpio_direct.c
) )
endif() endif()

8
app/drivers/zephyr/Kconfig
View file

@ -3,6 +3,14 @@ config ZMK_KSCAN_GPIO_DRIVER
default y default y
select GPIO select GPIO
if ZMK_KSCAN_GPIO_DRIVER
config ZMK_KSCAN_GPIO_POLLING
bool "Poll for key event triggers instead of using interrupts"
default n
endif
config ZMK_KSCAN_INIT_PRIORITY config ZMK_KSCAN_INIT_PRIORITY
int "Keyboard scan driver init priority" int "Keyboard scan driver init priority"
default 40 default 40

16
app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-direct.yaml Normal file
View file

@ -0,0 +1,16 @@
# Copyright (c) 2020, Pete Johanson
# SPDX-License-Identifier: MIT
description: Direct GPIO keyboard KSCAN controller
compatible: "zmk,kscan-gpio-direct"
include: kscan.yaml
properties:
input-gpios:
type: phandle-array
required: true
debounce-period:
type: int
default: 5

2
app/drivers/zephyr/dts/bindings/gpio-kscan.yaml → app/drivers/zephyr/dts/bindings/zmk,kscan-gpio-matrix.yaml
View file

@ -3,7 +3,7 @@
description: GPIO keyboard matrix controller description: GPIO keyboard matrix controller
compatible: "gpio-kscan" compatible: "zmk,kscan-gpio-matrix"
include: kscan.yaml include: kscan.yaml

263
app/drivers/zephyr/kscan_gpio_direct.c Normal file
View file

@ -0,0 +1,263 @@
/*
* Copyright (c) 2020 Peter Johanson <peter@peterjohanson.com>
*
* SPDX-License-Identifier: MIT
*/
#define DT_DRV_COMPAT zmk_kscan_gpio_direct
#include <device.h>
#include <drivers/kscan.h>
#include <drivers/gpio.h>
#include <logging/log.h>
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
struct kscan_gpio_item_config
{
char *label;
gpio_pin_t pin;
gpio_flags_t flags;
};
union work_reference {
struct k_delayed_work delayed;
struct k_work direct;
};
struct kscan_gpio_config
{
u8_t num_of_inputs;
u8_t debounce_period;
struct kscan_gpio_item_config inputs[];
};
struct kscan_gpio_data
{
#if defined(CONFIG_ZMK_KSCAN_GPIO_POLLING)
struct k_timer poll_timer;
#endif /* defined(CONFIG_ZMK_KSCAN_GPIO_POLLING) */
kscan_callback_t callback;
union work_reference work;
struct device *dev;
u32_t pin_state;
struct device *inputs[];
};
static struct device **kscan_gpio_input_devices(struct device *dev)
{
struct kscan_gpio_data *data = dev->driver_data;
return data->inputs;
}
static const struct kscan_gpio_item_config *kscan_gpio_input_configs(struct device *dev)
{
const struct kscan_gpio_config *cfg = dev->config_info;
return cfg->inputs;
}
#if !defined(CONFIG_ZMK_KSCAN_GPIO_POLLING)
struct kscan_gpio_irq_callback
{
union work_reference *work;
u8_t debounce_period;
struct gpio_callback callback;
};
static int kscan_gpio_config_interrupts(struct device *dev, gpio_flags_t flags)
{
const struct kscan_gpio_config *cfg = dev->config_info;
struct device **devices = kscan_gpio_input_devices(dev);
const struct kscan_gpio_item_config *configs = kscan_gpio_input_configs(dev);
for (int i = 0; i < cfg->num_of_inputs; i++)
{
struct device *dev = devices[i];
const struct kscan_gpio_item_config *cfg = &configs[i];
int err = gpio_pin_interrupt_configure(dev, cfg->pin, flags);
if (err)
{
LOG_ERR("Unable to enable matrix GPIO interrupt");
return err;
}
}
return 0;
}
static int kscan_gpio_direct_enable(struct device *dev)
{
return kscan_gpio_config_interrupts(dev,
GPIO_INT_DEBOUNCE | GPIO_INT_EDGE_BOTH);
}
static int kscan_gpio_direct_disable(struct device *dev)
{
return kscan_gpio_config_interrupts(dev,
GPIO_INT_DISABLE);
}
static void kscan_gpio_irq_callback_handler(struct device *dev,
struct gpio_callback *cb, gpio_port_pins_t pin)
{
struct kscan_gpio_irq_callback *data =
CONTAINER_OF(cb, struct kscan_gpio_irq_callback, callback);
if (data->debounce_period > 0) {
k_delayed_work_cancel(&data->work->delayed);
k_delayed_work_submit(&data->work->delayed, K_MSEC(data->debounce_period));
} else {
k_work_submit(&data->work->direct);
}
}
#else /* !defined(CONFIG_ZMK_KSCAN_GPIO_POLLING) */
static void kscan_gpio_timer_handler(struct k_timer *timer)
{
struct kscan_gpio_data *data =
CONTAINER_OF(timer, struct kscan_gpio_data, poll_timer);
k_work_submit(&data->work.direct);
}
static int kscan_gpio_direct_enable(struct device *dev)
{
struct kscan_gpio_data *data = dev->driver_data;
k_timer_start(&data->poll_timer, K_MSEC(10), K_MSEC(10));
return 0;
}
static int kscan_gpio_direct_disable(struct device *dev)
{
struct kscan_gpio_data *data = dev->driver_data;
k_timer_stop(&data->poll_timer);
return 0;
}
#endif /* defined(CONFIG_ZMK_KSCAN_GPIO_POLLING) */
static int kscan_gpio_direct_configure(struct device *dev, kscan_callback_t callback)
{
struct kscan_gpio_data *data = dev->driver_data;
if (!callback)
{
return -EINVAL;
}
data->callback = callback;
return 0;
}
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;
LOG_DBG("Scanning the pins for updated state");
for (int i = 0; i < cfg->num_of_inputs; i++)
{
struct device *in_dev = kscan_gpio_input_devices(dev)[i];
const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i];
WRITE_BIT(read_state, i, gpio_pin_get(in_dev, in_cfg->pin) > 0);
}
for (int i = 0; i < cfg->num_of_inputs; i++)
{
bool pressed = BIT(i) & read_state;
if (pressed != (BIT(i) & data->pin_state))
{
LOG_DBG("Sending event at %d,%d state %s",
0, i, (pressed ? "on" : "off"));
WRITE_BIT(data->pin_state, i, pressed);
data->callback(dev, 0, i, pressed);
}
}
return 0;
}
static void kscan_gpio_work_handler(struct k_work *work)
{
struct kscan_gpio_data *data =
CONTAINER_OF(work, struct kscan_gpio_data, work);
kscan_gpio_read(data->dev);
}
static const struct kscan_driver_api gpio_driver_api = {
.config = kscan_gpio_direct_configure,
.enable_callback = kscan_gpio_direct_enable,
.disable_callback = kscan_gpio_direct_disable,
};
#define KSCAN_DIRECT_INPUT_ITEM(i,n) \
{ \
.label = DT_INST_GPIO_LABEL_BY_IDX(n, input_gpios, i), \
.pin = DT_INST_GPIO_PIN_BY_IDX(n, input_gpios, i), \
.flags = DT_INST_GPIO_FLAGS_BY_IDX(n, input_gpios, i), \
},
#define INST_INPUT_LEN(n) DT_INST_PROP_LEN(n, input_gpios)
#define GPIO_INST_INIT(n) \
COND_CODE_0(CONFIG_ZMK_KSCAN_GPIO_POLLING, (static struct kscan_gpio_irq_callback \
irq_callbacks_##n[INST_INPUT_LEN(n)];), ()) \
static struct kscan_gpio_data kscan_gpio_data_##n = { \
.inputs = { [INST_INPUT_LEN(n)-1] = NULL } \
}; \
static int kscan_gpio_init_##n(struct device *dev) \
{ \
struct kscan_gpio_data *data = dev->driver_data; \
const struct kscan_gpio_config *cfg = dev->config_info; \
int err; \
struct device **input_devices = kscan_gpio_input_devices(dev); \
for (int i = 0; i < cfg->num_of_inputs; i++) \
{ \
const struct kscan_gpio_item_config *in_cfg = &kscan_gpio_input_configs(dev)[i]; \
input_devices[i] = device_get_binding(in_cfg->label); \
if (!input_devices[i]) \
{ \
LOG_ERR("Unable to find input GPIO device"); \
return -EINVAL; \
} \
err = gpio_pin_configure(input_devices[i], in_cfg->pin, GPIO_INPUT | in_cfg->flags); \
if (err) \
{ \
LOG_ERR("Unable to configure pin %d on %s for input", in_cfg->pin, in_cfg->label); \
return err; \
} \
COND_CODE_0(CONFIG_ZMK_KSCAN_GPIO_POLLING, \
( \
irq_callbacks_##n[i].work = &data->work; \
irq_callbacks_##n[i].debounce_period = cfg->debounce_period; \
gpio_init_callback(&irq_callbacks_##n[i].callback, kscan_gpio_irq_callback_handler, BIT(in_cfg->pin)); \
err = gpio_add_callback(input_devices[i], &irq_callbacks_##n[i].callback); \
if (err) \
{ \
LOG_ERR("Error adding the callback to the column device"); \
return err; \
} \
), ()) \
} \
data->dev = dev; \
COND_CODE_1(CONFIG_ZMK_KSCAN_GPIO_POLLING, (k_timer_init(&data->poll_timer, kscan_gpio_timer_handler, NULL);), ( )) \
if (cfg->debounce_period > 0) { \
k_delayed_work_init(&data->work.delayed, kscan_gpio_work_handler); \
} else { \
k_work_init(&data->work.direct, kscan_gpio_work_handler); \
} \
return 0; \
} \
static const struct kscan_gpio_config kscan_gpio_config_##n = { \
.inputs = { UTIL_LISTIFY(INST_INPUT_LEN(n), KSCAN_DIRECT_INPUT_ITEM, n) }, \
.num_of_inputs = INST_INPUT_LEN(n), \
.debounce_period = DT_INST_PROP(n, debounce_period) \
}; \
DEVICE_AND_API_INIT(kscan_gpio_##n, DT_INST_LABEL(n), kscan_gpio_init_##n, \
&kscan_gpio_data_##n, &kscan_gpio_config_##n, \
POST_KERNEL, CONFIG_ZMK_KSCAN_INIT_PRIORITY, \
&gpio_driver_api);
DT_INST_FOREACH_STATUS_OKAY(GPIO_INST_INIT)
#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */

6
app/drivers/zephyr/kscan_gpio.c → app/drivers/zephyr/kscan_gpio_matrix.c
View file

@ -4,7 +4,7 @@
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
*/ */
#define DT_DRV_COMPAT gpio_kscan #define DT_DRV_COMPAT zmk_kscan_gpio_matrix
#include <device.h> #include <device.h>
#include <drivers/kscan.h> #include <drivers/kscan.h>
@ -13,6 +13,8 @@
LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL); LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
struct kscan_gpio_item_config struct kscan_gpio_item_config
{ {
char *label; char *label;
@ -254,3 +256,5 @@ static int kscan_gpio_config_interrupts(struct device **devices,
&gpio_driver_api_##n); &gpio_driver_api_##n);
DT_INST_FOREACH_STATUS_OKAY(GPIO_INST_INIT) DT_INST_FOREACH_STATUS_OKAY(GPIO_INST_INIT)
#endif /* DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) */

3
app/include/zmk/matrix.h
View file

@ -5,6 +5,9 @@
#if DT_NODE_HAS_PROP(ZMK_MATRIX_NODE_ID,row_gpios) #if DT_NODE_HAS_PROP(ZMK_MATRIX_NODE_ID,row_gpios)
#define ZMK_MATRIX_ROWS DT_PROP_LEN(ZMK_MATRIX_NODE_ID,row_gpios) #define ZMK_MATRIX_ROWS DT_PROP_LEN(ZMK_MATRIX_NODE_ID,row_gpios)
#define ZMK_MATRIX_COLS DT_PROP_LEN(ZMK_MATRIX_NODE_ID,col_gpios) #define ZMK_MATRIX_COLS DT_PROP_LEN(ZMK_MATRIX_NODE_ID,col_gpios)
#elif DT_NODE_HAS_PROP(ZMK_MATRIX_NODE_ID,input_gpios)
#define ZMK_MATRIX_ROWS 1
#define ZMK_MATRIX_COLS DT_PROP_LEN(ZMK_MATRIX_NODE_ID,input_gpios)
#else #else
#define ZMK_MATRIX_ROWS DT_PROP(ZMK_MATRIX_NODE_ID,rows) #define ZMK_MATRIX_ROWS DT_PROP(ZMK_MATRIX_NODE_ID,rows)
#define ZMK_MATRIX_COLS DT_PROP(ZMK_MATRIX_NODE_ID,columns) #define ZMK_MATRIX_COLS DT_PROP(ZMK_MATRIX_NODE_ID,columns)