From 267dffda154d119ed5f155665e90fc5e03d138a5 Mon Sep 17 00:00:00 2001 From: Purdea Andrei Date: Tue, 28 May 2024 14:49:55 +0300 Subject: EEPROM: Don't erase if we don't have to. Adding eeprom_driver_format abstraction. (#18332) --- quantum/eeconfig.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'quantum') diff --git a/quantum/eeconfig.c b/quantum/eeconfig.c index 40690d6a97..ffbbf43a95 100644 --- a/quantum/eeconfig.c +++ b/quantum/eeconfig.c @@ -46,7 +46,7 @@ __attribute__((weak)) void eeconfig_init_kb(void) { */ void eeconfig_init_quantum(void) { #if defined(EEPROM_DRIVER) - eeprom_driver_erase(); + eeprom_driver_format(false); #endif eeprom_update_word(EECONFIG_MAGIC, EECONFIG_MAGIC_NUMBER); @@ -108,7 +108,7 @@ void eeconfig_enable(void) { */ void eeconfig_disable(void) { #if defined(EEPROM_DRIVER) - eeprom_driver_erase(); + eeprom_driver_format(false); #endif eeprom_update_word(EECONFIG_MAGIC, EECONFIG_MAGIC_NUMBER_OFF); } -- cgit v1.2.3 From a82b0628b399c35bcdf70f14cabfa0bb27f86af8 Mon Sep 17 00:00:00 2001 From: Fernando Birra Date: Tue, 4 Jun 2024 23:41:26 +0100 Subject: GC9xxx LCD family drivers (GC9107 and GC9A01) (#23091) Co-authored-by: Nick Brassel Co-authored-by: jack <0x6A73@pm.me> Co-authored-by: Joel Challis Co-authored-by: フィルターペーパー <76888457+filterpaper@users.noreply.github.com> Co-authored-by: rookiebwoy <81021475+rookiebwoy@users.noreply.github.com> Fixup boardsource/equals (#23106) Fix make clean test:os_detection (#23112) Fix make clean test:os_detection (#23112)" Fixup boardsource/equals (#23106)" --- drivers/painter/gc9a01/qp_gc9a01.c | 157 ----------------------------- drivers/painter/gc9a01/qp_gc9a01.h | 36 ------- drivers/painter/gc9a01/qp_gc9a01_opcodes.h | 77 -------------- drivers/painter/gc9xxx/qp_gc9107.c | 114 +++++++++++++++++++++ drivers/painter/gc9xxx/qp_gc9107.h | 37 +++++++ drivers/painter/gc9xxx/qp_gc9107_opcodes.h | 135 +++++++++++++++++++++++++ drivers/painter/gc9xxx/qp_gc9a01.c | 127 +++++++++++++++++++++++ drivers/painter/gc9xxx/qp_gc9a01.h | 36 +++++++ drivers/painter/gc9xxx/qp_gc9a01_opcodes.h | 104 +++++++++++++++++++ drivers/painter/gc9xxx/qp_gc9xxx_opcodes.h | 55 ++++++++++ quantum/painter/qp.h | 6 ++ quantum/painter/qp_internal.c | 1 + quantum/painter/rules.mk | 16 ++- 13 files changed, 629 insertions(+), 272 deletions(-) delete mode 100644 drivers/painter/gc9a01/qp_gc9a01.c delete mode 100644 drivers/painter/gc9a01/qp_gc9a01.h delete mode 100644 drivers/painter/gc9a01/qp_gc9a01_opcodes.h create mode 100644 drivers/painter/gc9xxx/qp_gc9107.c create mode 100644 drivers/painter/gc9xxx/qp_gc9107.h create mode 100644 drivers/painter/gc9xxx/qp_gc9107_opcodes.h create mode 100644 drivers/painter/gc9xxx/qp_gc9a01.c create mode 100644 drivers/painter/gc9xxx/qp_gc9a01.h create mode 100644 drivers/painter/gc9xxx/qp_gc9a01_opcodes.h create mode 100644 drivers/painter/gc9xxx/qp_gc9xxx_opcodes.h (limited to 'quantum') diff --git a/drivers/painter/gc9a01/qp_gc9a01.c b/drivers/painter/gc9a01/qp_gc9a01.c deleted file mode 100644 index fe6fa7a9d0..0000000000 --- a/drivers/painter/gc9a01/qp_gc9a01.c +++ /dev/null @@ -1,157 +0,0 @@ -// Copyright 2021 Paul Cotter (@gr1mr3aver) -// Copyright 2023 Nick Brassel (@tzarc) -// SPDX-License-Identifier: GPL-2.0-or-later - -#include "qp_internal.h" -#include "qp_comms.h" -#include "qp_gc9a01.h" -#include "qp_gc9a01_opcodes.h" -#include "qp_tft_panel.h" - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Driver storage -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -tft_panel_dc_reset_painter_device_t gc9a01_drivers[GC9A01_NUM_DEVICES] = {0}; - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Initialization -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -__attribute__((weak)) bool qp_gc9a01_init(painter_device_t device, painter_rotation_t rotation) { - // A lot of these "unknown" opcodes are sourced from other OSS projects and are seemingly required for this display to function. - // clang-format off - const uint8_t gc9a01_init_sequence[] = { - // Command, Delay, N, Data[N] - GC9A01_SET_INTER_REG_ENABLE2, 0, 0, - 0xEB, 0, 1, 0x14, - GC9A01_SET_INTER_REG_ENABLE1, 0, 0, - GC9A01_SET_INTER_REG_ENABLE2, 0, 0, - 0xEB, 0, 1, 0x14, - 0x84, 0, 1, 0x40, - 0x85, 0, 1, 0xFF, - 0x86, 0, 1, 0xFF, - 0x87, 0, 1, 0xFF, - 0x88, 0, 1, 0x0A, - 0x89, 0, 1, 0x21, - 0x8a, 0, 1, 0x00, - 0x8b, 0, 1, 0x80, - 0x8c, 0, 1, 0x01, - 0x8d, 0, 1, 0x01, - 0x8e, 0, 1, 0xFF, - 0x8f, 0, 1, 0xFF, - GC9A01_SET_FUNCTION_CTL, 0, 2, 0x00, 0x20, - GC9A01_SET_PIX_FMT, 0, 1, 0x55, - 0x90, 0, 4, 0x08, 0x08, 0x08, 0x08, - 0xBD, 0, 1, 0x06, - 0xBC, 0, 1, 0x00, - 0xFF, 0, 3, 0x60, 0x01, 0x04, - GC9A01_SET_POWER_CTL_2, 0, 1, 0x13, - GC9A01_SET_POWER_CTL_3, 0, 1, 0x13, - GC9A01_SET_POWER_CTL_4, 0, 1, 0x22, - 0xBE, 0, 1, 0x11, - 0xE1, 0, 2, 0x10, 0x0E, - 0xDF, 0, 3, 0x21, 0x0C, 0x02, - GC9A01_SET_GAMMA1, 0, 6, 0x45, 0x09, 0x08, 0x08, 0x26, 0x2A, - GC9A01_SET_GAMMA2, 0, 6, 0x43, 0x70, 0x72, 0x36, 0x37, 0x6F, - GC9A01_SET_GAMMA3, 0, 6, 0x45, 0x09, 0x08, 0x08, 0x26, 0x2A, - GC9A01_SET_GAMMA4, 0, 6, 0x43, 0x70, 0x72, 0x36, 0x37, 0x6F, - 0xED, 0, 2, 0x1B, 0x0B, - 0xAE, 0, 1, 0x77, - 0xCD, 0, 1, 0x63, - 0x70, 0, 9, 0x07, 0x07, 0x04, 0x0E, 0x0F, 0x09, 0x07, 0x08, 0x03, - GC9A01_SET_FRAME_RATE, 0, 1, 0x34, - 0x62, 0, 12, 0x18, 0x0D, 0x71, 0xED, 0x70, 0x70, 0x18, 0x0F, 0x71, 0xEF, 0x70, 0x70, - 0x63, 0, 12, 0x18, 0x11, 0x71, 0xF1, 0x70, 0x70, 0x18, 0x13, 0x71, 0xF3, 0x70, 0x70, - 0x64, 0, 7, 0x28, 0x29, 0xF1, 0x01, 0xF1, 0x00, 0x07, - 0x66, 0, 10, 0x3C, 0x00, 0xCD, 0x67, 0x45, 0x45, 0x10, 0x00, 0x00, 0x00, - 0x67, 0, 10, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, 0x54, 0x10, 0x32, 0x98, - 0x74, 0, 7, 0x10, 0x85, 0x80, 0x00, 0x00, 0x4E, 0x00, - 0x98, 0, 2, 0x3E, 0x07, - GC9A01_CMD_TEARING_OFF, 0, 0, - GC9A01_CMD_INVERT_OFF, 0, 0, - GC9A01_CMD_SLEEP_OFF, 120, 0, - GC9A01_CMD_DISPLAY_ON, 20, 0 - }; - // clang-format on - - // clang-format on - qp_comms_bulk_command_sequence(device, gc9a01_init_sequence, sizeof(gc9a01_init_sequence)); - - // Configure the rotation (i.e. the ordering and direction of memory writes in GRAM) - const uint8_t madctl[] = { - [QP_ROTATION_0] = GC9A01_MADCTL_BGR, - [QP_ROTATION_90] = GC9A01_MADCTL_BGR | GC9A01_MADCTL_MX | GC9A01_MADCTL_MV, - [QP_ROTATION_180] = GC9A01_MADCTL_BGR | GC9A01_MADCTL_MX | GC9A01_MADCTL_MY, - [QP_ROTATION_270] = GC9A01_MADCTL_BGR | GC9A01_MADCTL_MV | GC9A01_MADCTL_MY, - }; - qp_comms_command_databyte(device, GC9A01_SET_MEM_ACS_CTL, madctl[rotation]); - - return true; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Driver vtable -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -const tft_panel_dc_reset_painter_driver_vtable_t gc9a01_driver_vtable = { - .base = - { - .init = qp_gc9a01_init, - .power = qp_tft_panel_power, - .clear = qp_tft_panel_clear, - .flush = qp_tft_panel_flush, - .pixdata = qp_tft_panel_pixdata, - .viewport = qp_tft_panel_viewport, - .palette_convert = qp_tft_panel_palette_convert_rgb565_swapped, - .append_pixels = qp_tft_panel_append_pixels_rgb565, - .append_pixdata = qp_tft_panel_append_pixdata, - }, - .num_window_bytes = 2, - .swap_window_coords = false, - .opcodes = - { - .display_on = GC9A01_CMD_DISPLAY_ON, - .display_off = GC9A01_CMD_DISPLAY_OFF, - .set_column_address = GC9A01_SET_COL_ADDR, - .set_row_address = GC9A01_SET_PAGE_ADDR, - .enable_writes = GC9A01_SET_MEM, - }, -}; - -#ifdef QUANTUM_PAINTER_GC9A01_SPI_ENABLE -// Factory function for creating a handle to the ILI9341 device -painter_device_t qp_gc9a01_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode) { - for (uint32_t i = 0; i < GC9A01_NUM_DEVICES; ++i) { - tft_panel_dc_reset_painter_device_t *driver = &gc9a01_drivers[i]; - if (!driver->base.driver_vtable) { - driver->base.driver_vtable = (const painter_driver_vtable_t *)&gc9a01_driver_vtable; - driver->base.comms_vtable = (const painter_comms_vtable_t *)&spi_comms_with_dc_vtable; - driver->base.native_bits_per_pixel = 16; // RGB565 - driver->base.panel_width = panel_width; - driver->base.panel_height = panel_height; - driver->base.rotation = QP_ROTATION_0; - driver->base.offset_x = 0; - driver->base.offset_y = 0; - - // SPI and other pin configuration - driver->base.comms_config = &driver->spi_dc_reset_config; - driver->spi_dc_reset_config.spi_config.chip_select_pin = chip_select_pin; - driver->spi_dc_reset_config.spi_config.divisor = spi_divisor; - driver->spi_dc_reset_config.spi_config.lsb_first = false; - driver->spi_dc_reset_config.spi_config.mode = spi_mode; - driver->spi_dc_reset_config.dc_pin = dc_pin; - driver->spi_dc_reset_config.reset_pin = reset_pin; - driver->spi_dc_reset_config.command_params_uses_command_pin = false; - - if (!qp_internal_register_device((painter_device_t)driver)) { - memset(driver, 0, sizeof(tft_panel_dc_reset_painter_device_t)); - return NULL; - } - - return (painter_device_t)driver; - } - } - return NULL; -} - -#endif // QUANTUM_PAINTER_GC9A01_SPI_ENABLE diff --git a/drivers/painter/gc9a01/qp_gc9a01.h b/drivers/painter/gc9a01/qp_gc9a01.h deleted file mode 100644 index 31a3804b50..0000000000 --- a/drivers/painter/gc9a01/qp_gc9a01.h +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright 2021 Paul Cotter (@gr1mr3aver) -// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once - -#include "gpio.h" -#include "qp_internal.h" - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Quantum Painter GC9A01 configurables (add to your keyboard's config.h) - -#ifndef GC9A01_NUM_DEVICES -/** - * @def This controls the maximum number of GC9A01 devices that Quantum Painter can communicate with at any one time. - * Increasing this number allows for multiple displays to be used. - */ -# define GC9A01_NUM_DEVICES 1 -#endif - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Quantum Painter GC9A01 device factories - -#ifdef QUANTUM_PAINTER_GC9A01_SPI_ENABLE -/** - * Factory method for an GC9A01 SPI LCD device. - * - * @param panel_width[in] the width of the display panel - * @param panel_height[in] the height of the display panel - * @param chip_select_pin[in] the GPIO pin used for SPI chip select - * @param dc_pin[in] the GPIO pin used for D/C control - * @param reset_pin[in] the GPIO pin used for RST - * @param spi_divisor[in] the SPI divisor to use when communicating with the display - * @param spi_mode[in] the SPI mode to use when communicating with the display - * @return the device handle used with all drawing routines in Quantum Painter - */ -painter_device_t qp_gc9a01_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode); -#endif // QUANTUM_PAINTER_GC9A01_SPI_ENABLE diff --git a/drivers/painter/gc9a01/qp_gc9a01_opcodes.h b/drivers/painter/gc9a01/qp_gc9a01_opcodes.h deleted file mode 100644 index 828e42752b..0000000000 --- a/drivers/painter/gc9a01/qp_gc9a01_opcodes.h +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright 2021 Paul Cotter (@gr1mr3aver) -// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Quantum Painter GC9A01 command opcodes -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Level 1 command opcodes - -#define GC9A01_GET_ID_INFO 0x04 // Get ID information -#define GC9A01_GET_STATUS 0x09 // Get status -#define GC9A01_CMD_SLEEP_ON 0x10 // Enter sleep mode -#define GC9A01_CMD_SLEEP_OFF 0x11 // Exit sleep mode -#define GC9A01_CMD_PARTIAL_ON 0x12 // Enter partial mode -#define GC9A01_CMD_PARTIAL_OFF 0x13 // Exit partial mode -#define GC9A01_CMD_INVERT_ON 0x20 // Enter inverted mode -#define GC9A01_CMD_INVERT_OFF 0x21 // Exit inverted mode -#define GC9A01_CMD_DISPLAY_OFF 0x28 // Disable display -#define GC9A01_CMD_DISPLAY_ON 0x29 // Enable display -#define GC9A01_SET_COL_ADDR 0x2A // Set column address -#define GC9A01_SET_PAGE_ADDR 0x2B // Set page address -#define GC9A01_SET_MEM 0x2C // Set memory -#define GC9A01_SET_PARTIAL_AREA 0x30 // Set partial area -#define GC9A01_SET_VSCROLL 0x33 // Set vertical scroll def -#define GC9A01_CMD_TEARING_ON 0x34 // Tearing line enabled -#define GC9A01_CMD_TEARING_OFF 0x35 // Tearing line disabled -#define GC9A01_SET_MEM_ACS_CTL 0x36 // Set mem access ctl -#define GC9A01_SET_VSCROLL_ADDR 0x37 // Set vscroll start addr -#define GC9A01_CMD_IDLE_OFF 0x38 // Exit idle mode -#define GC9A01_CMD_IDLE_ON 0x39 // Enter idle mode -#define GC9A01_SET_PIX_FMT 0x3A // Set pixel format -#define GC9A01_SET_MEM_CONT 0x3C // Set memory continue -#define GC9A01_SET_TEAR_SCANLINE 0x44 // Set tearing scanline -#define GC9A01_GET_TEAR_SCANLINE 0x45 // Get tearing scanline -#define GC9A01_SET_BRIGHTNESS 0x51 // Set brightness -#define GC9A01_SET_DISPLAY_CTL 0x53 // Set display ctl -#define GC9A01_GET_ID1 0xDA // Get ID1 -#define GC9A01_GET_ID2 0xDB // Get ID2 -#define GC9A01_GET_ID3 0xDC // Get ID3 - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Level 2 command opcodes - -#define GC9A01_SET_RGB_IF_SIG_CTL 0xB0 // RGB IF signal ctl -#define GC9A01_SET_BLANKING_PORCH_CTL 0xB5 // Set blanking porch ctl -#define GC9A01_SET_FUNCTION_CTL 0xB6 // Set function ctl -#define GC9A01_SET_TEARING_EFFECT 0xBA // Set backlight ctl 3 -#define GC9A01_SET_IF_CTL 0xF6 // Set interface control - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Level 3 command opcodes - -#define GC9A01_SET_FRAME_RATE 0xE8 // Set frame rate -#define GC9A01_SET_SPI_2DATA 0xE9 // Set frame rate -#define GC9A01_SET_POWER_CTL_1 0xC1 // Set power ctl 1 -#define GC9A01_SET_POWER_CTL_2 0xC3 // Set power ctl 2 -#define GC9A01_SET_POWER_CTL_3 0xC4 // Set power ctl 3 -#define GC9A01_SET_POWER_CTL_4 0xC9 // Set power ctl 4 -#define GC9A01_SET_POWER_CTL_7 0xA7 // Set power ctl 7 -#define GC9A01_SET_INTER_REG_ENABLE1 0xFE // Enable Inter Register 1 -#define GC9A01_SET_INTER_REG_ENABLE2 0xEF // Enable Inter Register 2 -#define GC9A01_SET_GAMMA1 0xF0 // -#define GC9A01_SET_GAMMA2 0xF1 -#define GC9A01_SET_GAMMA3 0xF2 -#define GC9A01_SET_GAMMA4 0xF3 - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// MADCTL Flags -#define GC9A01_MADCTL_MY 0b10000000 -#define GC9A01_MADCTL_MX 0b01000000 -#define GC9A01_MADCTL_MV 0b00100000 -#define GC9A01_MADCTL_ML 0b00010000 -#define GC9A01_MADCTL_RGB 0b00000000 -#define GC9A01_MADCTL_BGR 0b00001000 -#define GC9A01_MADCTL_MH 0b00000100 diff --git a/drivers/painter/gc9xxx/qp_gc9107.c b/drivers/painter/gc9xxx/qp_gc9107.c new file mode 100644 index 0000000000..108344da4f --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9107.c @@ -0,0 +1,114 @@ +// Copyright 2024 Fernando Birra +// SPDX-License-Identifier: GPL-2.0-or-later +#include "qp_internal.h" +#include "qp_comms.h" +#include "qp_gc9107.h" +#include "qp_gc9xxx_opcodes.h" +#include "qp_gc9107_opcodes.h" +#include "qp_tft_panel.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Driver storage +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +tft_panel_dc_reset_painter_device_t gc9107_drivers[GC9107_NUM_DEVICES] = {0}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Initialization +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +__attribute__((weak)) bool qp_gc9107_init(painter_device_t device, painter_rotation_t rotation) { + // A lot of these "unknown" opcodes are sourced from other OSS projects and are seemingly required for this display to function. + // clang-format off + const uint8_t gc9107_init_sequence[] = { + GC9XXX_SET_INTER_REG_ENABLE1, 5, 0, + GC9XXX_SET_INTER_REG_ENABLE2, 5, 0, + GC9107_SET_FUNCTION_CTL6, 0, 1, GC9107_ALLOW_SET_COMPLEMENT_RGB | 0x08 | GC9107_ALLOW_SET_FRAMERATE, + GC9107_SET_COMPLEMENT_RGB, 0, 1, GC9107_COMPLEMENT_WITH_LSB, + 0xAB, 0, 1, 0x0E, + GC9107_SET_FRAME_RATE, 0, 1, 0x19, + GC9XXX_SET_PIXEL_FORMAT, 0, 1, GC9107_PIXEL_FORMAT_16_BPP_IFPF, + GC9XXX_CMD_SLEEP_OFF, 120, 0, + GC9XXX_CMD_DISPLAY_ON, 20, 0 + }; + + // clang-format on + qp_comms_bulk_command_sequence(device, gc9107_init_sequence, sizeof(gc9107_init_sequence)); + + // Configure the rotation (i.e. the ordering and direction of memory writes in GRAM) + const uint8_t madctl[] = { + [QP_ROTATION_0] = GC9XXX_MADCTL_BGR, + [QP_ROTATION_90] = GC9XXX_MADCTL_BGR | GC9XXX_MADCTL_MX | GC9XXX_MADCTL_MV, + [QP_ROTATION_180] = GC9XXX_MADCTL_BGR | GC9XXX_MADCTL_MX | GC9XXX_MADCTL_MY, + [QP_ROTATION_270] = GC9XXX_MADCTL_BGR | GC9XXX_MADCTL_MV | GC9XXX_MADCTL_MY, + }; + qp_comms_command_databyte(device, GC9XXX_SET_MEM_ACS_CTL, madctl[rotation]); + + return true; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Driver vtable +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +const tft_panel_dc_reset_painter_driver_vtable_t gc9107_driver_vtable = { + .base = + { + .init = qp_gc9107_init, + .power = qp_tft_panel_power, + .clear = qp_tft_panel_clear, + .flush = qp_tft_panel_flush, + .pixdata = qp_tft_panel_pixdata, + .viewport = qp_tft_panel_viewport, + .palette_convert = qp_tft_panel_palette_convert_rgb565_swapped, + .append_pixels = qp_tft_panel_append_pixels_rgb565, + .append_pixdata = qp_tft_panel_append_pixdata, + }, + .num_window_bytes = 2, + .swap_window_coords = false, + .opcodes = + { + .display_on = GC9XXX_CMD_DISPLAY_ON, + .display_off = GC9XXX_CMD_DISPLAY_OFF, + .set_column_address = GC9XXX_SET_COL_ADDR, + .set_row_address = GC9XXX_SET_ROW_ADDR, + .enable_writes = GC9XXX_SET_MEM, + }, +}; + +#ifdef QUANTUM_PAINTER_GC9107_SPI_ENABLE +// Factory function for creating a handle to the GC9107 device +painter_device_t qp_gc9107_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode) { + for (uint32_t i = 0; i < GC9107_NUM_DEVICES; ++i) { + tft_panel_dc_reset_painter_device_t *driver = &gc9107_drivers[i]; + if (!driver->base.driver_vtable) { + driver->base.driver_vtable = (const painter_driver_vtable_t *)&gc9107_driver_vtable; + driver->base.comms_vtable = (const painter_comms_vtable_t *)&spi_comms_with_dc_vtable; + driver->base.native_bits_per_pixel = 16; // RGB565 + driver->base.panel_width = panel_width; + driver->base.panel_height = panel_height; + driver->base.rotation = QP_ROTATION_0; + driver->base.offset_x = 2; + driver->base.offset_y = 1; + + // SPI and other pin configuration + driver->base.comms_config = &driver->spi_dc_reset_config; + driver->spi_dc_reset_config.spi_config.chip_select_pin = chip_select_pin; + driver->spi_dc_reset_config.spi_config.divisor = spi_divisor; + driver->spi_dc_reset_config.spi_config.lsb_first = false; + driver->spi_dc_reset_config.spi_config.mode = spi_mode; + driver->spi_dc_reset_config.dc_pin = dc_pin; + driver->spi_dc_reset_config.reset_pin = reset_pin; + driver->spi_dc_reset_config.command_params_uses_command_pin = false; + + if (!qp_internal_register_device((painter_device_t)driver)) { + memset(driver, 0, sizeof(tft_panel_dc_reset_painter_device_t)); + return NULL; + } + + return (painter_device_t)driver; + } + } + return NULL; +} + +#endif // QUANTUM_PAINTER_GC9107_SPI_ENABLE diff --git a/drivers/painter/gc9xxx/qp_gc9107.h b/drivers/painter/gc9xxx/qp_gc9107.h new file mode 100644 index 0000000000..b0b08f7665 --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9107.h @@ -0,0 +1,37 @@ +// Copyright 2024 Fernando Birra (@gr1mr3aver) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#include "gpio.h" +#include "qp_internal.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9107 configurables (add to your keyboard's config.h) + +#ifndef GC9107_NUM_DEVICES +/** + * @def This controls the maximum number of GC9107 devices that Quantum Painter can communicate with at any one time. + * Increasing this number allows for multiple displays to be used. + */ +# define GC9107_NUM_DEVICES 1 +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9107 device factories + +#ifdef QUANTUM_PAINTER_GC9107_SPI_ENABLE +/** + * Factory method for an GC9107 SPI LCD device. + * + * @param panel_width[in] the width of the display panel + * @param panel_height[in] the height of the display panel + * @param chip_select_pin[in] the GPIO pin used for SPI chip select + * @param dc_pin[in] the GPIO pin used for D/C control + * @param reset_pin[in] the GPIO pin used for RST + * @param spi_divisor[in] the SPI divisor to use when communicating with the display + * @param spi_mode[in] the SPI mode to use when communicating with the display + * @return the device handle used with all drawing routines in Quantum Painter + */ +painter_device_t qp_gc9107_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode); + +#endif // QUANTUM_PAINTER_GC9107_SPI_ENABLE diff --git a/drivers/painter/gc9xxx/qp_gc9107_opcodes.h b/drivers/painter/gc9xxx/qp_gc9107_opcodes.h new file mode 100644 index 0000000000..e9b308eb49 --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9107_opcodes.h @@ -0,0 +1,135 @@ +// Copyright 2024 Fernando Birra +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9107 command opcodes +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define GC9107_GET_POWER_MODE 0x0A // Get power mode +#define GC9107_GET_MADCTL 0x0B // Get MADCTL +#define GC9107_GET_PIXEL_FMT 0x0C // Get pixel format +#define GC9107_GET_IMAGE_FMT 0x0D // Get image format +#define GC9107_GET_SIGNAL_MODE 0x0E // Get signal mode +#define GC9107_GET_DIAG_RESULT 0x0F // Get self-diagnostic results + +#define GC9107_SET_FRAME_RATE 0xA8 // Set frame rate +#define GC9107_SET_COMPLEMENT_RGB 0xAC // Set complement Principle RGB +#define GC9107_SET_BLANK_PORCH 0xAD // Set blank porch control, 0;front_porch[6:0],0;back_porch[6:0] +#define GC9107_SET_FUNCTION_CTL1 0xB1 // Set access to AVDD_VCL_CLK and VGH_VGL_CLK commands +#define GC9107_SET_FUNCTION_CTL2 0xB2 // Set access to VGH, VGH control commands +#define GC9107_SET_FUNCTION_CTL3 0xB3 // Set access to Gamma control commands +#define GC9107_SET_DISPLAY_INVERSION 0xB4 // Set Display Inversion control +#define GC9107_SET_FUNCTION_CTL6 0xB6 // Set access to commands SET_FRAME_RATE, SET_COMPLEMENT_RGB and SET_BLANK_PORCH +#define GC9107_SET_CUSTOM_ID_INFO 0xD3 // Set customized display id information +#define GC9107_AVDD_VCL_CLK 0xE3 // AVDD_CLK +#define GC9107_SET_VGH 0xE8 // Set VGH +#define GC9107_SET_VGL 0xE9 // Set VGL +#define GC9107_SET_VGH_VGL_CLK 0xEA // Set VGH and VGL clock divisors + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// GC9107 Parameter constants + +// Parameter values for +// GC9107_SET_PIXEL_FORMAT +#define GC9107_PIXEL_FORMAT_12_BPP_IFPF (0b001 << 0) // 12 bits per pixel +#define GC9107_PIXEL_FORMAT_16_BPP_IFPF (0b101 << 0) // 16 bits per pixel +#define GC9107_PIXEL_FORMAT_18_BPP_IFPB (0b110 << 0) // 18 bits per pixel + +// Parameter values for +// GC9107_SET_COMPLEMENT_RGB +#define GC9107_COMPLEMENT_WITH_0 0x00 // R0 <- B0 <- 0, except if data is FFh +#define GC9107_COMPLEMENT_WITH_1 0x40 // R0 <- B0 <- 1, except if data is 00h +#define GC9107_COMPLEMENT_WITH_MSB 0x80 // R0 <- R5, B0 <- B5 +#define GC9107_COMPLEMENT_WITH_LSB 0xC0 // R0 <- B0 <- G0 +// Parameter masks for +// GC9107_SET_FUNCTION_CTL1 +#define GC9107_ALLOW_AVDD_VCL_CLK 0b00001000 // Allow AVDD_VCL_CLK command +// Parameter masks for +// GC9107_SET_FUNCTION_CTL2 +#define GC9107_ALLOW_SET_VGH 0b00000001 // Allow GC9107_SET_VGH +#define GC9107_ALLOW_SET_VGL 0b00000010 // Allow GC9107_SET_VGL +#define GC9107_ALLOW_SET_VGH_VGL_CLK 0b00000100 // Allow GC9107_SET_VGH_VGL_CLK +// Parameter masks for +// GC9107_SET_FUNCTION_CTL3 +#define GC9107_ALLOW_SET_GAMMA1 0b00000001 // Allow GC9107_SET_GAMMA1 +#define GC9107_ALLOW_SET_GAMMA2 0b00000010 // Allow GC9107_SET_GAMMA2 +// Parameter mask for +// GC9107_SET_FUNCTION_CTL6 +#define GC9107_ALLOW_SET_FRAMERATE 0b000000001 // Allow GC9107_SET_FRAME_RATE +#define GC9107_ALLOW_SET_COMPLEMENT_RGB 0b000010000 // Allow GC9107_SET_COMPLEMENT_RGB +#define GC9107_ALLOW_SET_BLANK_PORCH 0b000100000 // Allow GFC9107_SET_BLANK_PORCH +// Parameter values for +// AVDD_CLK_AD part (Most significant nibble) +#define GC9107_AVDD_CLK_AD_2T 0x00 +#define GC9107_AVDD_CLK_AD_3T 0x10 +#define GC9107_AVDD_CLK_AD_4T 0x20 +#define GC9107_AVDD_CLK_AD_5T 0x30 +#define GC9107_AVDD_CLK_AD_6T 0x40 +#define GC9107_AVDD_CLK_AD_7T 0x50 +#define GC9107_AVDD_CLK_AD_8T 0x60 +#define GC9107_AVDD_CLK_AD_9T 0x70 +// Parameter values for +// VCL_CLK_AD part (Least significant nibble) +#define GC9107_VCL_CLK_AD_2T 0x00 +#define GC9107_VCL_CLK_AD_3T 0x01 +#define GC9107_VCL_CLK_AD_4T 0x02 +#define GC9107_VCL_CLK_AD_5T 0x03 +#define GC9107_VCL_CLK_AD_6T 0x04 +#define GC9107_VCL_CLK_AD_7T 0x05 +#define GC9107_VCL_CLK_AD_8T 0x06 +#define GC9107_VCL_CLK_AD_9T 0x07 +// Parameter values for +// GC9107_SET_VGH +#define GC9107_VGH_P100 0x20 // +10 V +#define GC9107_VGH_P110 0x21 // +11 V +#define GC9107_VGH_P120 0x22 // +12 V +#define GC9107_VGH_P130 0x23 // +13 V +#define GC9107_VGH_P140 0x24 // +14 V +#define GC9107_VGH_P150 0x25 // +15 V +// Parameter values for +// GC9107_SET_VGL +#define VGL_N_075 0x40 // -7.5 V +#define VGL_N_085 0x41 // -8.5 V +#define VGL_N_095 0x42 // -9.5 V +#define VGL_N_100 0x43 // -10.0 V +#define VGL_N_105 0x44 // -10.5 V +#define VGL_N_110 0x45 // -11.0 V +#define VGL_N_120 0x46 // -12.0 V +#define VGL_N_130 0x47 // -13.0 V +// Parameter masks for +// GC9107_SET_VGH_VGL_CLK (VGH Divisor) +#define GC9107_VGH_CLK_DIV_2 0x00 // Clock divisor = 2 -> 6.0 Mhz +#define GC9107_VGH_CLK_DIV_3 0x10 // Clock divisor = 3 -> 4.0 Mhz +#define GC9107_VGH_CLK_DIV_4 0x20 // Clock divisor = 4 -> 3.0 Mhz +#define GC9107_VGH_CLK_DIV_5 0x30 // Clock divisor = 5 -> 2.4 Mhz +#define GC9107_VGH_CLK_DIV_6 0x40 // Clock divisor = 6 -> 2.0 Mhz +#define GC9107_VGH_CLK_DIV_7 0x50 // Clock divisor = 7 -> 1.7 Mhz +#define GC9107_VGH_CLK_DIV_8 0x60 // Clock divisor = 8 -> 1.5 Mhz +#define GC9107_VGH_CLK_DIV_9 0x70 // Clock divisor = 9 -> 1.3 Mhz +#define GC9107_VGH_CLK_DIV_10 0x80 // Clock divisor = 10 -> 1.2 Mhz +#define GC9107_VGH_CLK_DIV_12 0x90 // Clock divisor = 12 -> 1.0 Mhz +#define GC9107_VGH_CLK_DIV_15 0xA0 // Clock divisor = 15 -> 0.8 Mhz +#define GC9107_VGH_CLK_DIV_20 0xB0 // Clock divisor = 20 -> 0.6 Mhz +#define GC9107_VGH_CLK_DIV_24 0xC0 // Clock divisor = 24 -> 0.5 Mhz +#define GC9107_VGH_CLK_DIV_30 0xD0 // Clock divisor = 30 -> 0.4 Mhz +#define GC9107_VGH_CLK_DIV_40 0xE0 // Clock divisor = 40 -> 0.3 Mhz +#define GC9107_VGH_CLK_DIV_60 0xE0 // Clock divisor = 40 -> 0.2 Mhz +// Parameter masks for +// GC9107_SET_VGH_VGL_CLK (VGL Divisor) +#define GC9107_VGL_CLK_DIV_2 0x00 // Clock divisor = 2 -> 6.0 Mhz +#define GC9107_VGL_CLK_DIV_3 0x01 // Clock divisor = 3 -> 4.0 Mhz +#define GC9107_VGL_CLK_DIV_4 0x02 // Clock divisor = 4 -> 3.0 Mhz +#define GC9107_VGL_CLK_DIV_5 0x03 // Clock divisor = 5 -> 2.4 Mhz +#define GC9107_VGL_CLK_DIV_6 0x04 // Clock divisor = 6 -> 2.0 Mhz +#define GC9107_VGL_CLK_DIV_7 0x05 // Clock divisor = 7 -> 1.7 Mhz +#define GC9107_VGL_CLK_DIV_8 0x06 // Clock divisor = 8 -> 1.5 Mhz +#define GC9107_VGL_CLK_DIV_9 0x07 // Clock divisor = 9 -> 1.3 Mhz +#define GC9107_VGL_CLK_DIV_10 0x08 // Clock divisor = 10 -> 1.2 Mhz +#define GC9107_VGL_CLK_DIV_12 0x09 // Clock divisor = 12 -> 1.0 Mhz +#define GC9107_VGL_CLK_DIV_15 0x0A // Clock divisor = 15 -> 0.8 Mhz +#define GC9107_VGL_CLK_DIV_20 0x0B // Clock divisor = 20 -> 0.6 Mhz +#define GC9107_VGL_CLK_DIV_24 0x0C // Clock divisor = 24 -> 0.5 Mhz +#define GC9107_VGL_CLK_DIV_30 0x0D // Clock divisor = 30 -> 0.4 Mhz +#define GC9107_VGL_CLK_DIV_40 0x0E // Clock divisor = 40 -> 0.3 Mhz +#define GC9107_VGL_CLK_DIV_60 0x0E // Clock divisor = 40 -> 0.2 Mhz diff --git a/drivers/painter/gc9xxx/qp_gc9a01.c b/drivers/painter/gc9xxx/qp_gc9a01.c new file mode 100644 index 0000000000..f037a4cc87 --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9a01.c @@ -0,0 +1,127 @@ +// Copyright 2021 Paul Cotter (@gr1mr3aver) +// Copyright 2023 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "qp_internal.h" +#include "qp_comms.h" +#include "qp_gc9a01.h" +#include "qp_gc9xxx_opcodes.h" +#include "qp_gc9a01_opcodes.h" +#include "qp_tft_panel.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Driver storage +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +tft_panel_dc_reset_painter_device_t gc9a01_drivers[GC9A01_NUM_DEVICES] = {0}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Initialization +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +__attribute__((weak)) bool qp_gc9a01_init(painter_device_t device, painter_rotation_t rotation) { + // A lot of these "unknown" opcodes are sourced from other OSS projects and are seemingly required for this display to function. + // clang-format off + + const uint8_t gc9a01_init_sequence[] = { + // Command, Delay, N, Data[N] + GC9XXX_SET_INTER_REG_ENABLE1, 0, 0, + GC9XXX_SET_INTER_REG_ENABLE2, 0, 0, + 0x84, 0, 1, 0x40, + GC9A01_SET_FUNCTION_CTL, 0, 3, 0x00, GC9A01_SOURCE_OUTPUT_SCAN_DIRECTION_S360_TO_S1 | GC9A01_GATE_OUTPUT_SCAN_DIRECTION_G1_TO_G32, GC9A01_LCD_DRIVE_LINE_240, // Only works if the previous command is present (undocumented) + GC9A01_SET_POWER_CTL_2, 0, 1, 0x20, + GC9A01_SET_POWER_CTL_3, 0, 1, 0x20, + GC9A01_SET_POWER_CTL_4, 0, 1, 0x22, + GC9XXX_SET_GAMMA1, 0, 6, 0x45, 0x09, 0x08, 0x08, 0x26, 0x2A, + GC9XXX_SET_GAMMA2, 0, 6, 0x43, 0x70, 0x72, 0x36, 0x37, 0x6F, + GC9A01_SET_GAMMA3, 0, 6, 0x45, 0x09, 0x08, 0x08, 0x26, 0x2A, + GC9A01_SET_GAMMA4, 0, 6, 0x43, 0x70, 0x72, 0x36, 0x37, 0x6F, + 0x66, 0, 10, 0x3C, 0x00, 0xCD, 0x67, 0x45, 0x45, 0x10, 0x00, 0x00, 0x00, + 0x67, 0, 10, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x01, 0x54, 0x10, 0x32, 0x98, + GC9XXX_CMD_TEARING_ON, 0, 0, + GC9XXX_SET_PIXEL_FORMAT, 0, 1, GC9A01_PIXEL_FORMAT_16_BPP_DBI, + GC9XXX_CMD_INVERT_ON, 0, 0, + GC9XXX_CMD_SLEEP_OFF, 120, 0, + GC9XXX_CMD_DISPLAY_ON, 20, 0 + }; + // clang-format on + + qp_comms_bulk_command_sequence(device, gc9a01_init_sequence, sizeof(gc9a01_init_sequence)); + + // Configure the rotation (i.e. the ordering and direction of memory writes in GRAM) + const uint8_t madctl[] = { + [QP_ROTATION_0] = GC9XXX_MADCTL_BGR, + [QP_ROTATION_90] = GC9XXX_MADCTL_BGR | GC9XXX_MADCTL_MX | GC9XXX_MADCTL_MV, + [QP_ROTATION_180] = GC9XXX_MADCTL_BGR | GC9XXX_MADCTL_MX | GC9XXX_MADCTL_MY, + [QP_ROTATION_270] = GC9XXX_MADCTL_BGR | GC9XXX_MADCTL_MV | GC9XXX_MADCTL_MY, + }; + qp_comms_command_databyte(device, GC9XXX_SET_MEM_ACS_CTL, madctl[rotation]); + + return true; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Driver vtable +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +const tft_panel_dc_reset_painter_driver_vtable_t gc9a01_driver_vtable = { + .base = + { + .init = qp_gc9a01_init, + .power = qp_tft_panel_power, + .clear = qp_tft_panel_clear, + .flush = qp_tft_panel_flush, + .pixdata = qp_tft_panel_pixdata, + .viewport = qp_tft_panel_viewport, + .palette_convert = qp_tft_panel_palette_convert_rgb565_swapped, + .append_pixels = qp_tft_panel_append_pixels_rgb565, + .append_pixdata = qp_tft_panel_append_pixdata, + }, + .num_window_bytes = 2, + .swap_window_coords = false, + .opcodes = + { + .display_on = GC9XXX_CMD_DISPLAY_ON, + .display_off = GC9XXX_CMD_DISPLAY_OFF, + .set_column_address = GC9XXX_SET_COL_ADDR, + .set_row_address = GC9XXX_SET_ROW_ADDR, + .enable_writes = GC9XXX_SET_MEM, + }, +}; + +#ifdef QUANTUM_PAINTER_GC9A01_SPI_ENABLE +// Factory function for creating a handle to the ILI9341 device +painter_device_t qp_gc9a01_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode) { + for (uint32_t i = 0; i < GC9A01_NUM_DEVICES; ++i) { + tft_panel_dc_reset_painter_device_t *driver = &gc9a01_drivers[i]; + if (!driver->base.driver_vtable) { + driver->base.driver_vtable = (const painter_driver_vtable_t *)&gc9a01_driver_vtable; + driver->base.comms_vtable = (const painter_comms_vtable_t *)&spi_comms_with_dc_vtable; + driver->base.native_bits_per_pixel = 16; // RGB565 + driver->base.panel_width = panel_width; + driver->base.panel_height = panel_height; + driver->base.rotation = QP_ROTATION_0; + driver->base.offset_x = 0; + driver->base.offset_y = 0; + + // SPI and other pin configuration + driver->base.comms_config = &driver->spi_dc_reset_config; + driver->spi_dc_reset_config.spi_config.chip_select_pin = chip_select_pin; + driver->spi_dc_reset_config.spi_config.divisor = spi_divisor; + driver->spi_dc_reset_config.spi_config.lsb_first = false; + driver->spi_dc_reset_config.spi_config.mode = spi_mode; + driver->spi_dc_reset_config.dc_pin = dc_pin; + driver->spi_dc_reset_config.reset_pin = reset_pin; + driver->spi_dc_reset_config.command_params_uses_command_pin = false; + + if (!qp_internal_register_device((painter_device_t)driver)) { + memset(driver, 0, sizeof(tft_panel_dc_reset_painter_device_t)); + return NULL; + } + + return (painter_device_t)driver; + } + } + return NULL; +} + +#endif // QUANTUM_PAINTER_GC9A01_SPI_ENABLE diff --git a/drivers/painter/gc9xxx/qp_gc9a01.h b/drivers/painter/gc9xxx/qp_gc9a01.h new file mode 100644 index 0000000000..31a3804b50 --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9a01.h @@ -0,0 +1,36 @@ +// Copyright 2021 Paul Cotter (@gr1mr3aver) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#include "gpio.h" +#include "qp_internal.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9A01 configurables (add to your keyboard's config.h) + +#ifndef GC9A01_NUM_DEVICES +/** + * @def This controls the maximum number of GC9A01 devices that Quantum Painter can communicate with at any one time. + * Increasing this number allows for multiple displays to be used. + */ +# define GC9A01_NUM_DEVICES 1 +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9A01 device factories + +#ifdef QUANTUM_PAINTER_GC9A01_SPI_ENABLE +/** + * Factory method for an GC9A01 SPI LCD device. + * + * @param panel_width[in] the width of the display panel + * @param panel_height[in] the height of the display panel + * @param chip_select_pin[in] the GPIO pin used for SPI chip select + * @param dc_pin[in] the GPIO pin used for D/C control + * @param reset_pin[in] the GPIO pin used for RST + * @param spi_divisor[in] the SPI divisor to use when communicating with the display + * @param spi_mode[in] the SPI mode to use when communicating with the display + * @return the device handle used with all drawing routines in Quantum Painter + */ +painter_device_t qp_gc9a01_make_spi_device(uint16_t panel_width, uint16_t panel_height, pin_t chip_select_pin, pin_t dc_pin, pin_t reset_pin, uint16_t spi_divisor, int spi_mode); +#endif // QUANTUM_PAINTER_GC9A01_SPI_ENABLE diff --git a/drivers/painter/gc9xxx/qp_gc9a01_opcodes.h b/drivers/painter/gc9xxx/qp_gc9a01_opcodes.h new file mode 100644 index 0000000000..5853902e68 --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9a01_opcodes.h @@ -0,0 +1,104 @@ +// Copyright 2021 Paul Cotter (@gr1mr3aver) +// Copyright 2024 Fernando Birra +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9A01 command opcodes +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define GC9A01_SET_MEM_CONT 0x3C // Set memory continue +#define GC9A01_SET_BRIGHTNESS 0x51 // Set brightness +#define GC9A01_SET_DISPLAY_CTL 0x53 // Set display ctl + +#define GC9A01_SET_RGB_IF_SIG_CTL 0xB0 // RGB IF signal ctl +#define GC9A01_SET_BLANKING_PORCH_CTL 0xB5 // Set blanking porch ctl +#define GC9A01_SET_FUNCTION_CTL 0xB6 // Set function ctl +#define GC9A01_SET_TEARING_EFFECT 0xBA // Set tering effect control +#define GC9A01_SET_POWER_CTL_7 0xA7 // Set power ctl 7 +#define GC9A01_SET_POWER_CTL_1 0xC1 // Set power ctl 1 +#define GC9A01_SET_POWER_CTL_2 0xC3 // Set power ctl 2 +#define GC9A01_SET_POWER_CTL_3 0xC4 // Set power ctl 3 +#define GC9A01_SET_POWER_CTL_4 0xC9 // Set power ctl 4 +#define GC9A01_SET_FRAME_RATE 0xE8 // Set frame rate +#define GC9A01_SET_SPI_2DATA 0xE9 // Set frame rate +#define GC9A01_SET_GAMMA3 0xF2 // Set gamma 3 +#define GC9A01_SET_GAMMA4 0xF3 // Set gamma 4 +#define GC9A01_SET_IF_CTL 0xF6 // Set interface control + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// GC9A01 MADCTL Flags +#define GC9A01_MADCTL_MH 0b00000100 + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// GC9A01 Parameter constants + +// Parameter values for +// GC9A01_SET_PIXEL_FORMAT +#define GC9A01_PIXEL_FORMAT_12_BPP_DBI (0b011 << 0) // 12 bits/pixel MCU interface format +#define GC9A01_PIXEL_FORMAT_16_BPP_DBI (0b101 << 0) // 16 bits/pixel MCU interface format +#define GC9A01_PIXEL_FORMAT_18_BPP_DBI (0b110 << 0) // 18 bits/pixel MCU interface format +#define GC9A01_PIXEL_FORMAT_16_BPP_DPI (0b101 << 4) // 16 bits/pixel RGB interface format +#define GC9A01_PIXEL_FORMAT_18_BPP_DPI (0b110 << 4) // 18 bits/pixel RGB interface format + +// Parameter values for +// GC9A01_SET_FUNCTION_CTL (2nd parameter) +#define GC9A01_SOURCE_OUTPUT_SCAN_DIRECTION_S1_TO_S360 0b00000000 +#define GC9A01_SOURCE_OUTPUT_SCAN_DIRECTION_S360_TO_S1 0b00100000 +#define GC9A01_GATE_OUTPUT_SCAN_DIRECTION_G1_TO_G32 0b00000000 +#define GC9A01_GATE_OUTPUT_SCAN_DIRECTION_G32_TO_G1 0b01000000 +#define GC9A01_SCAN_MODE_INTER 0x10 + +// Parameter values for +// GC9A01_SET_FUNCTION_CTL (3rd parameter) +#define GC9A01_LCD_DRIVE_LINE_16 0x01 +#define GC9A01_LCD_DRIVE_LINE_24 0x02 +#define GC9A01_LCD_DRIVE_LINE_32 0x03 +#define GC9A01_LCD_DRIVE_LINE_40 0x04 +#define GC9A01_LCD_DRIVE_LINE_48 0x05 +#define GC9A01_LCD_DRIVE_LINE_56 0x06 +#define GC9A01_LCD_DRIVE_LINE_64 0x07 +#define GC9A01_LCD_DRIVE_LINE_72 0x08 +#define GC9A01_LCD_DRIVE_LINE_80 0x09 +#define GC9A01_LCD_DRIVE_LINE_88 0x0A +#define GC9A01_LCD_DRIVE_LINE_96 0x0B +#define GC9A01_LCD_DRIVE_LINE_104 0x0C +#define GC9A01_LCD_DRIVE_LINE_112 0x0D +#define GC9A01_LCD_DRIVE_LINE_120 0x0E +#define GC9A01_LCD_DRIVE_LINE_128 0x0F +#define GC9A01_LCD_DRIVE_LINE_136 0x10 +#define GC9A01_LCD_DRIVE_LINE_144 0x11 +#define GC9A01_LCD_DRIVE_LINE_152 0x12 +#define GC9A01_LCD_DRIVE_LINE_160 0x13 +#define GC9A01_LCD_DRIVE_LINE_168 0x14 +#define GC9A01_LCD_DRIVE_LINE_176 0x15 +#define GC9A01_LCD_DRIVE_LINE_184 0x16 +#define GC9A01_LCD_DRIVE_LINE_192 0x17 +#define GC9A01_LCD_DRIVE_LINE_200 0x18 +#define GC9A01_LCD_DRIVE_LINE_208 0x19 +#define GC9A01_LCD_DRIVE_LINE_216 0x1A +#define GC9A01_LCD_DRIVE_LINE_224 0x1B +#define GC9A01_LCD_DRIVE_LINE_232 0x1C +#define GC9A01_LCD_DRIVE_LINE_240 0x1D + +// Parameter values for +// GC9A01_SET_DISPLAY_CTL +#define GC9A01_BRIGHTNESS_CONTROL_ON 0b00100000 +#define GC9A01_DIMMING_ON 0b00001000 +#define GC9A01_BACKLIGHT_ON 0b00000100 +#define GC9A01_BRIGHTNESS_CONTROL_OFF 0b00000000 +#define GC9A01_DIMMING_OFF 0b00000000 +#define GC9A01_BACKLIGHT_OFF 0b00000000 + +// Parameter values for +// GC9A01_SET_IF_CTL +#define GC9A01_DISPLAY_MODE_INTERNAL_CLOCK 0b00000000 +#define GC9A01_DISPLAY_MODE_RGB_INTERFACE 0b00000100 +#define GC9A01_DISPLAY_MODE_VSYNC_INTERFACE 0b00001000 +#define GC9A01_DSISPLAY_MODE_DISABLED 0b00001100 + +#define GC0A01_GRAM_INTERFACE_VSYNC 0b00000000 +#define GC9A01_GRAM_INTERFACE_RGB 0b00000010 + +#define GC9A01_RGB_INTERFACE_MODE_1_TRANSFER 0b00000000 +#define GC9A01_RGB_INTERFACE_MODE_3_TRANSFER 0b00000001 \ No newline at end of file diff --git a/drivers/painter/gc9xxx/qp_gc9xxx_opcodes.h b/drivers/painter/gc9xxx/qp_gc9xxx_opcodes.h new file mode 100644 index 0000000000..7e0fbf9110 --- /dev/null +++ b/drivers/painter/gc9xxx/qp_gc9xxx_opcodes.h @@ -0,0 +1,55 @@ +// Copyright 2021 Paul Cotter (@gr1mr3aver) +// Copyright 2024 Fernando Birra +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter GC9xxx command opcodes +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#define GC9XXX_GET_ID_INFO 0x04 // Get ID information +#define GC9XXX_GET_STATUS 0x09 // Get status + +#define GC9XXX_CMD_SLEEP_ON 0x10 // Enter sleep mode +#define GC9XXX_CMD_SLEEP_OFF 0x11 // Exit sleep mode +#define GC9XXX_CMD_PARTIAL_ON 0x12 // Enter partial mode +#define GC9XXX_CMD_PARTIAL_OFF 0x13 // Exit partial mode + +#define GC9XXX_CMD_INVERT_OFF 0x20 // Exit inverted mode +#define GC9XXX_CMD_INVERT_ON 0x21 // Enter inverted mode +#define GC9XXX_CMD_DISPLAY_OFF 0x28 // Disable display +#define GC9XXX_CMD_DISPLAY_ON 0x29 // Enable display +#define GC9XXX_SET_COL_ADDR 0x2A // Set column address (MSB(StartCol),LSB(StartCol),MSB(EndCol),LSB(EndCol) +#define GC9XXX_SET_ROW_ADDR 0x2B // Set row address (MSB(StartRow),LSB(StartRow),MSB(EndRow),LSB(EndRow) +#define GC9XXX_SET_MEM 0x2C // Set (write) memory + +#define GC9XXX_SET_PARTIAL_AREA 0x30 // Set partial area (MSB(StartRow),LSB(StartRow),MSB(EndRow),LSB(EndRow) +#define GC9XXX_SET_VSCROLL 0x33 // Set vertical scroll MSB(TFA),LSB(TFA),MSB(VSA),LSB(VSA)+ GC9107 extra param: MSB(BFA),LSB(BFA) +#define GC9XXX_CMD_TEARING_OFF 0x34 // Tearing effect line OFF +#define GC9XXX_CMD_TEARING_ON 0x35 // Tearing effect line ON +#define GC9XXX_SET_MEM_ACS_CTL 0x36 // Set mem access ctl +#define GC9XXX_SET_VSCROLL_ADDR 0x37 // Set vscroll start addr +#define GC9XXX_CMD_IDLE_OFF 0x38 // Exit idle mode +#define GC9XXX_CMD_IDLE_ON 0x39 // Enter idle mode +#define GC9XXX_SET_PIXEL_FORMAT 0x3A // Set pixel format +#define GC9XXX_SET_TEAR_SCANLINE 0x44 // Set tearing scanline (Scanline = LS bit of Param 1 (GC9A01) + Param 2(GC9XXX)) +#define GC9XXX_GET_TEAR_SCANLINE 0x45 // Get tearing scanline (Scanline = LS bit of Param 1 (GC9A01) + Param 2(GC9XXX)) +#define GC9XXX_GET_ID1 0xDA // Get ID1 +#define GC9XXX_GET_ID2 0xDB // Get ID2 +#define GC9XXX_GET_ID3 0xDC // Get ID3 +#define GC9XXX_SET_INTER_REG_ENABLE1 0xFE // Enable Inter Register 1 +#define GC9XXX_SET_INTER_REG_ENABLE2 0xEF // Enable Inter Register 2 +#define GC9XXX_SET_GAMMA1 0xF0 // Set gamma 1 +#define GC9XXX_SET_GAMMA2 0xF1 // Set gamma 2 + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// MADCTL Flags +#define GC9XXX_MADCTL_MY 0b10000000 // Mirror Y (row address order) +#define GC9XXX_MADCTL_MX 0b01000000 // Mirror X (column address order) +#define GC9XXX_MADCTL_MV 0b00100000 // Vertical Refresh Order (bottom to top) +#define GC9XXX_MADCTL_ML 0b00010000 +#define GC9XXX_MADCTL_BGR 0b00001000 +#define GC9XXX_MADCTL_RGB 0b00000000 + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// GC9XXX Parameter constants diff --git a/quantum/painter/qp.h b/quantum/painter/qp.h index 02acbf589a..820c418f43 100644 --- a/quantum/painter/qp.h +++ b/quantum/painter/qp.h @@ -539,6 +539,12 @@ int16_t qp_drawtext_recolor(painter_device_t device, uint16_t x, uint16_t y, pai # define GC9A01_NUM_DEVICES 0 #endif // QUANTUM_PAINTER_GC9A01_ENABLE +#ifdef QUANTUM_PAINTER_GC9107_ENABLE +# include "qp_gc9107.h" +#else // QUANTUM_PAINTER_GC9107_ENABLE +# define GC9107_NUM_DEVICES 0 +#endif // QUANTUM_PAINTER_GC9107_ENABLE + #ifdef QUANTUM_PAINTER_SSD1351_ENABLE # include "qp_ssd1351.h" #else // QUANTUM_PAINTER_SSD1351_ENABLE diff --git a/quantum/painter/qp_internal.c b/quantum/painter/qp_internal.c index 1f0f981796..7d4a6430af 100644 --- a/quantum/painter/qp_internal.c +++ b/quantum/painter/qp_internal.c @@ -16,6 +16,7 @@ enum { + (ST7789_NUM_DEVICES) // ST7789 + (ST7735_NUM_DEVICES) // ST7735 + (GC9A01_NUM_DEVICES) // GC9A01 + + (GC9107_NUM_DEVICES) // GC9107 + (SSD1351_NUM_DEVICES) // SSD1351 + (SH1106_NUM_DEVICES) // SH1106 }; diff --git a/quantum/painter/rules.mk b/quantum/painter/rules.mk index d991a6d742..7b2ab702ee 100644 --- a/quantum/painter/rules.mk +++ b/quantum/painter/rules.mk @@ -14,6 +14,7 @@ VALID_QUANTUM_PAINTER_DRIVERS := \ st7735_spi \ st7789_spi \ gc9a01_spi \ + gc9107_spi \ ssd1351_spi \ sh1106_i2c \ sh1106_spi @@ -131,10 +132,21 @@ define handle_quantum_painter_driver OPT_DEFS += -DQUANTUM_PAINTER_GC9A01_ENABLE -DQUANTUM_PAINTER_GC9A01_SPI_ENABLE COMMON_VPATH += \ $(DRIVER_PATH)/painter/tft_panel \ - $(DRIVER_PATH)/painter/gc9a01 + $(DRIVER_PATH)/painter/gc9xxx SRC += \ $(DRIVER_PATH)/painter/tft_panel/qp_tft_panel.c \ - $(DRIVER_PATH)/painter/gc9a01/qp_gc9a01.c + $(DRIVER_PATH)/painter/gc9xxx/qp_gc9a01.c + + else ifeq ($$(strip $$(CURRENT_PAINTER_DRIVER)),gc9107_spi) + QUANTUM_PAINTER_NEEDS_COMMS_SPI := yes + QUANTUM_PAINTER_NEEDS_COMMS_SPI_DC_RESET := yes + OPT_DEFS += -DQUANTUM_PAINTER_GC9107_ENABLE -DQUANTUM_PAINTER_GC9107_SPI_ENABLE + COMMON_VPATH += \ + $(DRIVER_PATH)/painter/tft_panel \ + $(DRIVER_PATH)/painter/gc9xxx + SRC += \ + $(DRIVER_PATH)/painter/tft_panel/qp_tft_panel.c \ + $(DRIVER_PATH)/painter/gc9xxx/qp_gc9107.c else ifeq ($$(strip $$(CURRENT_PAINTER_DRIVER)),ssd1351_spi) QUANTUM_PAINTER_NEEDS_COMMS_SPI := yes -- cgit v1.2.3 From c4a74be7f02ec64033638e93a49924df20fb2e57 Mon Sep 17 00:00:00 2001 From: Ryan Date: Thu, 13 Jun 2024 21:59:46 +1000 Subject: Add process_keycode handlers for new RGB Matrix and Underglow keycodes (#23896) --- quantum/process_keycode/process_rgb_matrix.c | 101 +++++++++++++++++++++++++++ quantum/process_keycode/process_rgb_matrix.h | 10 +++ quantum/process_keycode/process_underglow.c | 91 ++++++++++++++++++++++++ quantum/process_keycode/process_underglow.h | 10 +++ 4 files changed, 212 insertions(+) create mode 100644 quantum/process_keycode/process_rgb_matrix.c create mode 100644 quantum/process_keycode/process_rgb_matrix.h create mode 100644 quantum/process_keycode/process_underglow.c create mode 100644 quantum/process_keycode/process_underglow.h (limited to 'quantum') diff --git a/quantum/process_keycode/process_rgb_matrix.c b/quantum/process_keycode/process_rgb_matrix.c new file mode 100644 index 0000000000..fd2aa1a0c7 --- /dev/null +++ b/quantum/process_keycode/process_rgb_matrix.c @@ -0,0 +1,101 @@ +// Copyright 2024 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "process_rgb_matrix.h" +#include "rgb_matrix.h" +#include "action_util.h" +#include "keycodes.h" +#include "modifiers.h" + +bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record) { +#ifdef RGB_TRIGGER_ON_KEYDOWN + if (record->event.pressed) { +#else + if (!record->event.pressed) { +#endif + bool shifted = get_mods() & MOD_MASK_SHIFT; + switch (keycode) { + case QK_RGB_MATRIX_ON: + rgb_matrix_enable(); + return false; + case QK_RGB_MATRIX_OFF: + rgb_matrix_disable(); + return false; + case QK_RGB_MATRIX_TOGGLE: + rgb_matrix_toggle(); + return false; + case QK_RGB_MATRIX_MODE_NEXT: + if (shifted) { + rgb_matrix_step_reverse(); + } else { + rgb_matrix_step(); + } + return false; + case QK_RGB_MATRIX_MODE_PREVIOUS: + if (shifted) { + rgb_matrix_step(); + } else { + rgb_matrix_step_reverse(); + } + return false; + case QK_RGB_MATRIX_HUE_UP: + if (shifted) { + rgb_matrix_decrease_hue(); + } else { + rgb_matrix_increase_hue(); + } + return false; + case QK_RGB_MATRIX_HUE_DOWN: + if (shifted) { + rgb_matrix_increase_hue(); + } else { + rgb_matrix_decrease_hue(); + } + return false; + case QK_RGB_MATRIX_SATURATION_UP: + if (shifted) { + rgb_matrix_decrease_sat(); + } else { + rgb_matrix_increase_sat(); + } + return false; + case QK_RGB_MATRIX_SATURATION_DOWN: + if (shifted) { + rgb_matrix_increase_sat(); + } else { + rgb_matrix_decrease_sat(); + } + return false; + case QK_RGB_MATRIX_VALUE_UP: + if (shifted) { + rgb_matrix_decrease_val(); + } else { + rgb_matrix_increase_val(); + } + return false; + case QK_RGB_MATRIX_VALUE_DOWN: + if (shifted) { + rgb_matrix_increase_val(); + } else { + rgb_matrix_decrease_val(); + } + return false; + case QK_RGB_MATRIX_SPEED_UP: + if (shifted) { + rgb_matrix_decrease_speed(); + } else { + rgb_matrix_increase_speed(); + } + return false; + case QK_RGB_MATRIX_SPEED_DOWN: + if (shifted) { + rgb_matrix_increase_speed(); + } else { + rgb_matrix_decrease_speed(); + } + return false; + } + } + + return true; +} diff --git a/quantum/process_keycode/process_rgb_matrix.h b/quantum/process_keycode/process_rgb_matrix.h new file mode 100644 index 0000000000..a02bf57b5f --- /dev/null +++ b/quantum/process_keycode/process_rgb_matrix.h @@ -0,0 +1,10 @@ +// Copyright 2024 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include "action.h" + +bool process_rgb_matrix(uint16_t keycode, keyrecord_t *record); diff --git a/quantum/process_keycode/process_underglow.c b/quantum/process_keycode/process_underglow.c new file mode 100644 index 0000000000..779672ac07 --- /dev/null +++ b/quantum/process_keycode/process_underglow.c @@ -0,0 +1,91 @@ +// Copyright 2024 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "process_underglow.h" +#include "rgblight.h" +#include "action_util.h" +#include "keycodes.h" +#include "modifiers.h" + +bool process_underglow(uint16_t keycode, keyrecord_t *record) { + if (record->event.pressed) { + uint8_t shifted = get_mods() & MOD_MASK_SHIFT; + switch (keycode) { + case QK_UNDERGLOW_TOGGLE: + rgblight_toggle(); + return false; + case QK_UNDERGLOW_MODE_NEXT: + if (shifted) { + rgblight_step_reverse(); + } else { + rgblight_step(); + } + return false; + case QK_UNDERGLOW_MODE_PREVIOUS: + if (shifted) { + rgblight_step(); + } else { + rgblight_step_reverse(); + } + return false; + case QK_UNDERGLOW_HUE_UP: + if (shifted) { + rgblight_decrease_hue(); + } else { + rgblight_increase_hue(); + } + return false; + case QK_UNDERGLOW_HUE_DOWN: + if (shifted) { + rgblight_increase_hue(); + } else { + rgblight_decrease_hue(); + } + return false; + case QK_UNDERGLOW_SATURATION_UP: + if (shifted) { + rgblight_decrease_sat(); + } else { + rgblight_increase_sat(); + } + return false; + case QK_UNDERGLOW_SATURATION_DOWN: + if (shifted) { + rgblight_increase_sat(); + } else { + rgblight_decrease_sat(); + } + return false; + case QK_UNDERGLOW_VALUE_UP: + if (shifted) { + rgblight_decrease_val(); + } else { + rgblight_increase_val(); + } + return false; + case QK_UNDERGLOW_VALUE_DOWN: + if (shifted) { + rgblight_increase_hue(); + } else { + rgblight_decrease_hue(); + } + return false; + case QK_UNDERGLOW_SPEED_UP: + if (shifted) { + rgblight_decrease_speed(); + } else { + rgblight_increase_speed(); + } + return false; + case QK_UNDERGLOW_SPEED_DOWN: + if (shifted) { + rgblight_increase_speed(); + } else { + rgblight_decrease_speed(); + } + return false; + } + } + + return true; +} diff --git a/quantum/process_keycode/process_underglow.h b/quantum/process_keycode/process_underglow.h new file mode 100644 index 0000000000..b409cafbb8 --- /dev/null +++ b/quantum/process_keycode/process_underglow.h @@ -0,0 +1,10 @@ +// Copyright 2024 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include +#include "action.h" + +bool process_underglow(uint16_t keycode, keyrecord_t *record); -- cgit v1.2.3 From 55538b2e1e743ec1a209e61880d52bb5d2156669 Mon Sep 17 00:00:00 2001 From: Ryan Date: Thu, 13 Jun 2024 22:19:45 +1000 Subject: APA102: API rework (#23355) --- docs/drivers/apa102.md | 47 ++++++++++++++++++++++++++++++------- drivers/led/apa102.c | 23 +++++++++++++----- drivers/led/apa102.h | 15 +++--------- quantum/rgblight/rgblight_drivers.c | 8 +++++++ 4 files changed, 67 insertions(+), 26 deletions(-) (limited to 'quantum') diff --git a/docs/drivers/apa102.md b/docs/drivers/apa102.md index 88868a73b5..197b18869e 100644 --- a/docs/drivers/apa102.md +++ b/docs/drivers/apa102.md @@ -26,20 +26,51 @@ Add the following to your `config.h`: ## API {#api} -### `void apa102_setleds(rgb_led_t *start_led, uint16_t num_leds)` +### `void apa102_init(void)` {#api-apa102-init} -Send RGB data to the APA102 LED chain. +Initialize the LED driver. This function should be called first. -#### Arguments {#api-apa102-setleds-arguments} +--- + +### `void apa102_set_color(uint16_t index, uint8_t red, uint8_t green, uint8_t blue)` {#api-apa102-set-color} + +Set the color of a single LED. This function does not immediately update the LEDs; call `apa102_flush()` after you are finished. + +#### Arguments {#api-apa102-set-color-arguments} + + - `uint16_t index` + The LED index in the APA102 chain. + - `uint8_t red` + The red value to set. + - `uint8_t green` + The green value to set. + - `uint8_t blue` + The blue value to set. + +--- + +### `void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue)` {#api-apa102-set-color-all} + +Set the color of all LEDs. + +#### Arguments {#api-apa102-set-color-all-arguments} + + - `uint8_t red` + The red value to set. + - `uint8_t green` + The green value to set. + - `uint8_t blue` + The blue value to set. + +--- + +### `void apa102_flush(void)` {#api-apa102-flush} - - `rgb_led_t *start_led` - A pointer to the LED array. - - `uint16_t num_leds` - The length of the LED array. +Flush the PWM values to the LED chain. --- -### `void apa102_set_brightness(uint8_t brightness)` +### `void apa102_set_brightness(uint8_t brightness)` {#api-apa102-set-brightness} Set the global brightness. diff --git a/drivers/led/apa102.c b/drivers/led/apa102.c index b171b07b12..0cf0ecb401 100644 --- a/drivers/led/apa102.c +++ b/drivers/led/apa102.c @@ -53,7 +53,8 @@ io_wait; \ } while (0) -uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS; +rgb_led_t apa102_leds[APA102_LED_COUNT]; +uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS; static void apa102_send_byte(uint8_t byte) { APA102_SEND_BIT(byte, 7); @@ -121,14 +122,24 @@ void apa102_init(void) { gpio_set_pin_output(APA102_CI_PIN); } -void apa102_setleds(rgb_led_t *start_led, uint16_t num_leds) { - rgb_led_t *end = start_led + num_leds; +void apa102_set_color(uint16_t index, uint8_t red, uint8_t green, uint8_t blue) { + apa102_leds[index].r = red; + apa102_leds[index].g = green; + apa102_leds[index].b = blue; +} + +void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue) { + for (uint16_t i = 0; i < APA102_LED_COUNT; i++) { + apa102_set_color(i, red, green, blue); + } +} +void apa102_flush(void) { apa102_start_frame(); - for (rgb_led_t *led = start_led; led < end; led++) { - apa102_send_frame(led->r, led->g, led->b, apa102_led_brightness); + for (uint8_t i = 0; i < APA102_LED_COUNT; i++) { + apa102_send_frame(apa102_leds[i].r, apa102_leds[i].g, apa102_leds[i].b, apa102_led_brightness); } - apa102_end_frame(num_leds); + apa102_end_frame(APA102_LED_COUNT); } void apa102_set_brightness(uint8_t brightness) { diff --git a/drivers/led/apa102.h b/drivers/led/apa102.h index 5e2f78658b..42f1344f0c 100644 --- a/drivers/led/apa102.h +++ b/drivers/led/apa102.h @@ -32,17 +32,8 @@ #define APA102_MAX_BRIGHTNESS 31 void apa102_init(void); - -/* User Interface - * - * Input: - * start_led: An array of GRB data describing the LED colors - * num_leds: The number of LEDs to write - * - * The functions will perform the following actions: - * - Set the data-out pin as output - * - Send out the LED data - */ -void apa102_setleds(rgb_led_t *start_led, uint16_t num_leds); +void apa102_set_color(uint16_t index, uint8_t red, uint8_t green, uint8_t blue); +void apa102_set_color_all(uint8_t red, uint8_t green, uint8_t blue); +void apa102_flush(void); void apa102_set_brightness(uint8_t brightness); diff --git a/quantum/rgblight/rgblight_drivers.c b/quantum/rgblight/rgblight_drivers.c index 8902b8f842..76e9031aec 100644 --- a/quantum/rgblight/rgblight_drivers.c +++ b/quantum/rgblight/rgblight_drivers.c @@ -14,6 +14,14 @@ const rgblight_driver_t rgblight_driver = { #elif defined(RGBLIGHT_APA102) # include "apa102.h" +// Temporary shim +static void apa102_setleds(rgb_led_t *ledarray, uint16_t number_of_leds) { + for (uint16_t i = 0; i < number_of_leds; i++) { + apa102_set_color(i, ledarray[i].r, ledarray[i].g, ledarray[i].b); + } + apa102_flush(); +} + const rgblight_driver_t rgblight_driver = { .init = apa102_init, .setleds = apa102_setleds, -- cgit v1.2.3 From 751a6b5bc4404e8398b360a925cb95e17be848d8 Mon Sep 17 00:00:00 2001 From: Amir Date: Fri, 21 Jun 2024 02:42:16 +0330 Subject: add farsi keymap extras (#23650) --- .../keycodes/extras/keycodes_farsi_0.0.1.hjson | 616 +++++++++++++++++++++ docs/reference_keymap_extras.md | 1 + quantum/keymap_extras/keymap_farsi.h | 171 ++++++ 3 files changed, 788 insertions(+) create mode 100644 data/constants/keycodes/extras/keycodes_farsi_0.0.1.hjson create mode 100644 quantum/keymap_extras/keymap_farsi.h (limited to 'quantum') diff --git a/data/constants/keycodes/extras/keycodes_farsi_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_farsi_0.0.1.hjson new file mode 100644 index 0000000000..d59b6fab26 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_farsi_0.0.1.hjson @@ -0,0 +1,616 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ + * │ │ ۱ │ ۲ │ ۳ │ ۴ │ ۵ │ ۶ │ ۷ │ ۸ │ ۹ │ ۰ │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ض │ ص │ ث │ ق │ ف │ غ │ ع │ ه │ خ │ ح │ ج │ چ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐ │ + * │ │ ش │ س │ ی │ ب │ ل │ ا │ ت │ ن │ م │ ک │ گ │ \ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ ظ │ ط │ ز │ ر │ ذ │ د │ پ │ و │ . │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "FA_ZWJ", + "label": "(zero-width joiner)", + } + "KC_1": { + "key": "FA_1A", + "label": "۱", + } + "KC_2": { + "key": "FA_2A", + "label": "۲", + } + "KC_3": { + "key": "FA_3A", + "label": "۳", + } + "KC_4": { + "key": "FA_4A", + "label": "۴", + } + "KC_5": { + "key": "FA_5A", + "label": "۵", + } + "KC_6": { + "key": "FA_6A", + "label": "۶", + } + "KC_7": { + "key": "FA_7A", + "label": "۷", + } + "KC_8": { + "key": "FA_8A", + "label": "۸", + } + "KC_9": { + "key": "FA_9A", + "label": "۹", + } + "KC_0": { + "key": "FA_0A", + "label": "۰", + } + "KC_MINS": { + "key": "FA_MINS", + "label": "-", + } + "KC_EQL": { + "key": "FA_EQL", + "label": "=", + } + "KC_Q": { + "key": "FA_ZAD", + "label": "ض", + } + "KC_W": { + "key": "FA_SAD", + "label": "ص", + } + "KC_E": { + "key": "FA_SE", + "label": "ث", + } + "KC_R": { + "key": "FA_QAF", + "label": "ق", + } + "KC_T": { + "key": "FA_FE", + "label": "ف", + } + "KC_Y": { + "key": "FA_GHYN", + "label": "غ", + } + "KC_U": { + "key": "FA_EYN", + "label": "ع", + } + "KC_I": { + "key": "FA_HE", + "label": "ه", + } + "KC_O": { + "key": "FA_KHE", + "label": "خ", + } + "KC_P": { + "key": "FA_HEJ", + "label": "ح", + } + "KC_LBRC": { + "key": "FA_JIM", + "label": "ج", + } + "KC_RBRC": { + "key": "FA_CHE", + "label": "چ", + } + "KC_A": { + "key": "FA_SHIN", + "label": "ش", + } + "KC_S": { + "key": "FA_SIN", + "label": "س", + } + "KC_D": { + "key": "FA_YE", + "label": "ی", + } + "KC_F": { + "key": "FA_BE", + "label": "ب", + } + "KC_G": { + "key": "FA_LAM", + "label": "ل", + } + "KC_H": { + "key": "FA_ALEF", + "label": "ا", + } + "KC_J": { + "key": "FA_TE", + "label": "ت", + } + "KC_K": { + "key": "FA_NOON", + "label": "ن", + } + "KC_L": { + "key": "FA_MIM", + "label": "م", + } + "KC_SCLN": { + "key": "FA_KAF", + "label": "ک", + } + "KC_QUOT": { + "key": "FA_GAF", + "label": "گ", + } + "KC_BSLS": { + "key": "FA_BSLS", + "label": "\\", + } + "KC_LT": { + "key": "FA_LT", + "label": "<", + } + "KC_Z": { + "key": "FA_ZA", + "label": "ظ", + } + "KC_X": { + "key": "FA_TA", + "label": "ط", + } + "KC_C": { + "key": "FA_ZE", + "label": "ز", + } + "KC_V": { + "key": "FA_RE", + "label": "ر", + } + "KC_B": { + "key": "FA_ZAL", + "label": "ذ", + } + "KC_N": { + "key": "FA_DAL", + "label": "د", + } + "KC_M": { + "key": "FA_PE", + "label": "پ", + } + "KC_COMM": { + "key": "FA_WAW", + "label": "و", + } + "KC_DOT": { + "key": "FA_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "FA_SLSH", + "label": "/", + } + "KC_SPC": { + "key": "FA_SPC", + "label": " ", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ + * │ ÷ │ ! │ ٬ │ ٫ │ ﷼ │ ٪ │ × │ ، │ * │ ) │ ( │ ـ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ْ │ ٌ │ ٍ │ ً │ ُ │ ِ │ َ │ ّ │ ] │ [ │ } │ { │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐ │ + * │ │ ؤ │ ئ │ ي │ إ │ أ │ آ │ ة │ » │ « │ : │ ؛ │ | │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ ك │ ٓ │ ژ │ ٰ │ │ ٔ │ ء │ │ │ ؟ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(FA_ZWJ)": { + "key": "FA_DIV", + "label": "÷", + } + "S(FA_1A)": { + "key": "FA_EXLM", + "label": "!", + } + "S(FA_2A)": { + "key": "FA_THS", + "label": "٬", + } + "S(FA_3A)": { + "key": "FA_DECS", + "label": "٫", + } + "S(FA_4A)": { + "key": "FA_RIAL", + "label": "﷼", + } + "S(FA_5A)": { + "key": "FA_PRCA", + "label": "٪", + } + "S(FA_6A)": { + "key": "FA_MUL", + "label": "×", + } + "S(FA_7A)": { + "key": "FA_COMA", + "label": "،", + } + "S(FA_8A)": { + "key": "FA_ASTR", + "label": "*", + } + "S(FA_9A)": { + "key": "FA_RPRN", + "label": ")", + } + "S(FA_0A)": { + "key": "FA_LPRN", + "label": "(", + } + "S(FA_MINS)": { + "key": "FA_TATW", + "label": "ـ", + } + "S(FA_EQL)": { + "key": "FA_PLUS", + "label": "+", + } + "S(FA_ZAD)": { + "key": "FA_SUK", + "label": "ْ", + } + "S(FA_SAD)": { + "key": "FA_DMTN", + "label": "ٌ", + } + "S(FA_SE)": { + "key": "FA_KSTN", + "label": "ٍ", + } + "S(FA_QAF)": { + "key": "FA_FTHN", + "label": "ً", + } + "S(FA_FE)": { + "key": "FA_DMM", + "label": "ُ", + } + "S(FA_GHYN)": { + "key": "FA_KAS", + "label": "ِ", + } + "S(FA_EYN)": { + "key": "FA_FAT", + "label": "َ", + } + "S(FA_HE)": { + "key": "FA_TSDD", + "label": "", + } + "S(FA_KHE)": { + "key": "FA_RBRC", + "label": "]", + } + "S(FA_HEJ)": { + "key": "FA_LBRC", + "label": "[", + } + "S(FA_JIM)": { + "key": "FA_RCBR", + "label": "}", + } + "S(FA_CHE)": { + "key": "FA_LCBR", + "label": "{", + } + "S(FA_SHIN)": { + "key": "FA_HMZV", + "label": "ؤ", + } + "S(FA_SIN)": { + "key": "FA_HMZY", + "label": "ئ", + } + "S(FA_YE)": { + "key": "FA_YEA", + "label": "ي", + } + "S(FA_BE)": { + "key": "FA_HMZU", + "label": "إ", + } + "S(FA_LAM)": { + "key": "FA_HMZO", + "label": "أ", + } + "S(FA_ALEF)": { + "key": "FA_MALF", + "label": "آ", + } + "S(FA_TE)": { + "key": "FA_TEHM", + "label": "ة", + } + "S(FA_NOON)": { + "key": "FA_RQOT", + "label": "»", + } + "S(FA_MIM)": { + "key": "FA_LQOT", + "label": "«", + } + "S(FA_KAF)": { + "key": "FA_COLN", + "label": ":", + } + "S(FA_GAF)": { + "key": "FA_SCLA", + "label": "؛", + } + "S(FA_LT)": { + "key": "FA_GT", + "label": ">", + } + "S(FA_ZA)": { + "key": "FA_KAFA", + "label": "ك", + } + "S(FA_TA)": { + "key": "FA_MADO", + "label": "ٓ", + } + "S(FA_ZE)": { + "key": "FA_JEH", + "label": "ژ", + } + "S(FA_RE)": { + "key": "FA_SUPA", + "label": "ٰ", + } + "S(FA_ZAL)": { + "key": "FA_ZWNJ", + "label": "(zero-width non-joiner)", + } + "S(FA_DAL)": { + "key": "FA_HMZA", + "label": "ٔ", + } + "S(FA_PE)": { + "key": "FA_HMZ", + "label": "ء", + } + "S(FA_SLSH)": { + "key": "FA_QSA", + "label": "؟", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ + * │ ~ │ ` │ @ │ # │ $ │ % │ ^ │ & │ • │ │ │ _ │ − │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ° │ │ € │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐ │ + * │ │ │ │ ى │ │ │ ٱ │ │ ﴾ │ ﴿ │ ; │ " │ ‐ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ ٖ │ │ ٕ │ … │ , │ ' │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(FA_ZWJ)": { + "key": "FA_TILD", + "label": "~", + } + "ALGR(FA_1A)": { + "key": "FA_GRV", + "label": "`", + } + "ALGR(FA_2A)": { + "key": "FA_AT", + "label": "@", + } + "ALGR(FA_3A)": { + "key": "FA_HASH", + "label": "#", + } + "ALGR(FA_4A)": { + "key": "FA_DLR", + "label": "$", + } + "ALGR(FA_5A)": { + "key": "FA_PERC", + "label": "%", + } + "ALGR(FA_6A)": { + "key": "FA_CIRC", + "label": "^", + } + "ALGR(FA_7A)": { + "key": "FA_AMPR", + "label": "&", + } + "ALGR(FA_8A)": { + "key": "FA_BULT", + "label": "•", + } + "ALGR(FA_9A)": { + "key": "FA_LRM", + "label": "(left-to-right mark)", + } + "ALGR(FA_0A)": { + "key": "FA_RLM", + "label": "(right-to-left mark)", + } + "ALGR(FA_MINS)": { + "key": "FA_UNDS", + "label": "_", + } + "ALGR(FA_EQL)": { + "key": "FA_DMNS", + "label": "− (dead)", + } + "ALGR(FA_ZAD)": { + "key": "FA_DEG", + "label": "°", + } + "ALGR(FA_SE)": { + "key": "FA_EURO", + "label": "€", + } + "ALGR(FA_HE)": { + "key": "FA_LRO", + "label": "(left-to-right override)", + } + "ALGR(FA_KHE)": { + "key": "FA_RLO", + "label": "(right-to-left override)", + } + "ALGR(FA_HEJ)": { + "key": "FA_PDF", + "label": "(pop directional formatting)", + } + "ALGR(FA_JIM)": { + "key": "FA_LRE", + "label": "(left-to-right embedding)", + } + "ALGR(FA_CHE)": { + "key": "FA_RLE", + "label": "(right-to-left embedding)", + } + "ALGR(FA_YE)": { + "key": "FA_ALFM", + "label": "ى", + } + "ALGR(FA_ALEF)": { + "key": "FA_ALFW", + "label": "ٱ", + } + "ALGR(FA_NOON)": { + "key": "FA_LORP", + "label": "﴾", + } + "ALGR(FA_MIM)": { + "key": "FA_RORP", + "label": "﴿", + } + "ALGR(FA_KAF)": { + "key": "FA_SCLN", + "label": ";", + } + "ALGR(FA_GAF)": { + "key": "FA_DQT", + "label": "\"", + } + "ALGR(FA_BSLS)": { + "key": "FA_MINA", + "label": "-", + } + "ALGR(FA_ZA)": { + "key": "FA_PIPE", + "label": "|", + } + "ALGR(FA_RA)": { + "key": "FA_SUBA", + "label": "ٖ", + } + "ALGR(FA_DAL)": { + "key": "FA_HMZB", + "label": "ء", + } + "ALGR(FA_PE)": { + "key": "FA_ELLP", + "label": "…", + } + "ALGR(FA_WAW)": { + "key": "FA_COMM", + "label": ",", + } + "ALGR(FA_DOT)": { + "key": "FA_QUOT", + "label": "'", + } + "ALGR(FA_SLSH)": { + "key": "FA_QUES", + "label": "?", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐ + * │ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┐ │ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ ¦ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(FA_1A))": { + "key": "FA_1", + "label": "1", + } + "S(ALGR(FA_2A))": { + "key": "FA_2", + "label": "2", + } + "S(ALGR(FA_3A))": { + "key": "FA_3", + "label": "3", + } + "S(ALGR(FA_4A))": { + "key": "FA_4", + "label": "4", + } + "S(ALGR(FA_5A))": { + "key": "FA_5", + "label": "5", + } + "S(ALGR(FA_6A))": { + "key": "FA_6", + "label": "6", + } + "S(ALGR(FA_7A))": { + "key": "FA_7", + "label": "7", + } + "S(ALGR(FA_8A))": { + "key": "FA_8", + "label": "8", + } + "S(ALGR(FA_9A))": { + "key": "FA_9", + "label": "9", + } + "S(ALGR(FA_0A))": { + "key": "FA_0", + "label": "0", + } + "S(ALGR(FA_LT))": { + "key": "FA_BRKP", + "label": "¦", + } + "S(ALGR(FA_SPC))": { + "key": "FA_NNBS", + "label": "(narrow non-breaking space)", + } + } +} diff --git a/docs/reference_keymap_extras.md b/docs/reference_keymap_extras.md index 191e0d4ea8..d45183b6c6 100644 --- a/docs/reference_keymap_extras.md +++ b/docs/reference_keymap_extras.md @@ -33,6 +33,7 @@ These headers are located in [`quantum/keymap_extras/`](https://github.com/qmk/q |English (US International) |`keymap_us_international.h` |`sendstring_us_international.h` | |English (US International, Linux)|`keymap_us_international_linux.h`| | |Estonian |`keymap_estonian.h` |`sendstring_estonian.h` | +|Farsi |`keymap_farsi.h` | | |Finnish |`keymap_finnish.h` |`sendstring_finnish.h` | |French |`keymap_french.h` |`sendstring_french.h` | |French (AFNOR) |`keymap_french_afnor.h` |`sendstring_french_afnor.h` | diff --git a/quantum/keymap_extras/keymap_farsi.h b/quantum/keymap_extras/keymap_farsi.h new file mode 100644 index 0000000000..d268917513 --- /dev/null +++ b/quantum/keymap_extras/keymap_farsi.h @@ -0,0 +1,171 @@ +// Copyright 2024 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ + +#pragma once +#include "keycodes.h" +// clang-format off + +// Aliases +#define FA_ZWJ KC_GRV // (zero-width joiner) +#define FA_1A KC_1 // ۱ +#define FA_2A KC_2 // ۲ +#define FA_3A KC_3 // ۳ +#define FA_4A KC_4 // ۴ +#define FA_5A KC_5 // ۵ +#define FA_6A KC_6 // ۶ +#define FA_7A KC_7 // ۷ +#define FA_8A KC_8 // ۸ +#define FA_9A KC_9 // ۹ +#define FA_0A KC_0 // ۰ +#define FA_MINS KC_MINS // - +#define FA_EQL KC_EQL // = +#define FA_ZAD KC_Q // ض +#define FA_SAD KC_W // ص +#define FA_SE KC_E // ث +#define FA_QAF KC_R // ق +#define FA_FE KC_T // ف +#define FA_GHYN KC_Y // غ +#define FA_EYN KC_U // ع +#define FA_HE KC_I // ه +#define FA_KHE KC_O // خ +#define FA_HEJ KC_P // ح +#define FA_JIM KC_LBRC // ج +#define FA_CHE KC_RBRC // چ +#define FA_SHIN KC_A // ش +#define FA_SIN KC_S // س +#define FA_YE KC_D // ی +#define FA_BE KC_F // ب +#define FA_LAM KC_G // ل +#define FA_ALEF KC_H // ا +#define FA_TE KC_J // ت +#define FA_NOON KC_K // ن +#define FA_MIM KC_L // م +#define FA_KAF KC_SCLN // ک +#define FA_GAF KC_QUOT // گ +#define FA_BSLS KC_BSLS // (backslash) +#define FA_LT KC_LT // < +#define FA_ZA KC_Z // ظ +#define FA_TA KC_X // ط +#define FA_ZE KC_C // ز +#define FA_RE KC_V // ر +#define FA_ZAL KC_B // ذ +#define FA_DAL KC_N // د +#define FA_PE KC_M // پ +#define FA_WAW KC_COMM // و +#define FA_DOT KC_DOT // . +#define FA_SLSH KC_SLSH // / +#define FA_SPC KC_SPC // +#define FA_DIV S(FA_ZWJ) // ÷ +#define FA_EXLM S(FA_1A) // ! +#define FA_THS S(FA_2A) // ٬ +#define FA_DECS S(FA_3A) // ٫ +#define FA_RIAL S(FA_4A) // ﷼ +#define FA_PRCA S(FA_5A) // ٪ +#define FA_MUL S(FA_6A) // × +#define FA_COMA S(FA_7A) // ، +#define FA_ASTR S(FA_8A) // * +#define FA_RPRN S(FA_9A) // ) +#define FA_LPRN S(FA_0A) // ( +#define FA_TATW S(FA_MINS) // ـ +#define FA_PLUS S(FA_EQL) // + +#define FA_SUK S(FA_ZAD) // ْ +#define FA_DMTN S(FA_SAD) // ٌ +#define FA_KSTN S(FA_SE) // ٍ +#define FA_FTHN S(FA_QAF) // ً +#define FA_DMM S(FA_FE) // ُ +#define FA_KAS S(FA_GHYN) // ِ +#define FA_FAT S(FA_EYN) // َ +#define FA_TSDD S(FA_HE) // +#define FA_RBRC S(FA_KHE) // ] +#define FA_LBRC S(FA_HEJ) // [ +#define FA_RCBR S(FA_JIM) // } +#define FA_LCBR S(FA_CHE) // { +#define FA_HMZV S(FA_SHIN) // ؤ +#define FA_HMZY S(FA_SIN) // ئ +#define FA_YEA S(FA_YE) // ي +#define FA_HMZU S(FA_BE) // إ +#define FA_HMZO S(FA_LAM) // أ +#define FA_MALF S(FA_ALEF) // آ +#define FA_TEHM S(FA_TE) // ة +#define FA_RQOT S(FA_NOON) // » +#define FA_LQOT S(FA_MIM) // « +#define FA_COLN S(FA_KAF) // : +#define FA_SCLA S(FA_GAF) // ؛ +#define FA_GT S(FA_LT) // > +#define FA_KAFA S(FA_ZA) // ك +#define FA_MADO S(FA_TA) // ٓ +#define FA_JEH S(FA_ZE) // ژ +#define FA_SUPA S(FA_RE) // ٰ +#define FA_ZWNJ S(FA_ZAL) // (zero-width non-joiner) +#define FA_HMZA S(FA_DAL) // ٔ +#define FA_HMZ S(FA_PE) // ء +#define FA_QSA S(FA_SLSH) // ؟ +#define FA_TILD ALGR(FA_ZWJ) // ~ +#define FA_GRV ALGR(FA_1A) // ` +#define FA_AT ALGR(FA_2A) // @ +#define FA_HASH ALGR(FA_3A) // # +#define FA_DLR ALGR(FA_4A) // $ +#define FA_PERC ALGR(FA_5A) // % +#define FA_CIRC ALGR(FA_6A) // ^ +#define FA_AMPR ALGR(FA_7A) // & +#define FA_BULT ALGR(FA_8A) // • +#define FA_LRM ALGR(FA_9A) // (left-to-right mark) +#define FA_RLM ALGR(FA_0A) // (right-to-left mark) +#define FA_UNDS ALGR(FA_MINS) // _ +#define FA_DMNS ALGR(FA_EQL) // − (dead) +#define FA_DEG ALGR(FA_ZAD) // ° +#define FA_EURO ALGR(FA_SE) // € +#define FA_LRO ALGR(FA_HE) // (left-to-right override) +#define FA_RLO ALGR(FA_KHE) // (right-to-left override) +#define FA_PDF ALGR(FA_HEJ) // (pop directional formatting) +#define FA_LRE ALGR(FA_JIM) // (left-to-right embedding) +#define FA_RLE ALGR(FA_CHE) // (right-to-left embedding) +#define FA_ALFM ALGR(FA_YE) // ى +#define FA_ALFW ALGR(FA_ALEF) // ٱ +#define FA_LORP ALGR(FA_NOON) // ﴾ +#define FA_RORP ALGR(FA_MIM) // ﴿ +#define FA_SCLN ALGR(FA_KAF) // ; +#define FA_DQT ALGR(FA_GAF) // " +#define FA_MINA ALGR(FA_BSLS) // - +#define FA_PIPE ALGR(FA_ZA) // | +#define FA_SUBA ALGR(FA_RA) // ٖ +#define FA_HMZB ALGR(FA_DAL) // ء +#define FA_ELLP ALGR(FA_PE) // … +#define FA_COMM ALGR(FA_WAW) // , +#define FA_QUOT ALGR(FA_DOT) // ' +#define FA_QUES ALGR(FA_SLSH) // ? +#define FA_1 S(ALGR(FA_1A)) // 1 +#define FA_2 S(ALGR(FA_2A)) // 2 +#define FA_3 S(ALGR(FA_3A)) // 3 +#define FA_4 S(ALGR(FA_4A)) // 4 +#define FA_5 S(ALGR(FA_5A)) // 5 +#define FA_6 S(ALGR(FA_6A)) // 6 +#define FA_7 S(ALGR(FA_7A)) // 7 +#define FA_8 S(ALGR(FA_8A)) // 8 +#define FA_9 S(ALGR(FA_9A)) // 9 +#define FA_0 S(ALGR(FA_0A)) // 0 +#define FA_BRKP S(ALGR(FA_LT)) // ¦ +#define FA_NNBS S(ALGR(FA_SPC)) // (narrow non-breaking space) + -- cgit v1.2.3 From cb39df273de782be1145dc5184bfd47d823531d5 Mon Sep 17 00:00:00 2001 From: Joel Challis Date: Sat, 22 Jun 2024 09:10:58 +0100 Subject: Remove deprecated `led_set_user` (#23979) --- docs/features/led_indicators.md | 7 +------ keyboards/converter/usb_usb/custom_matrix.cpp | 1 - keyboards/sirius/unigo66/custom_matrix.cpp | 1 - quantum/led.c | 11 +++-------- quantum/led.h | 3 --- 5 files changed, 4 insertions(+), 19 deletions(-) (limited to 'quantum') diff --git a/docs/features/led_indicators.md b/docs/features/led_indicators.md index 8435c69a55..211fda2581 100644 --- a/docs/features/led_indicators.md +++ b/docs/features/led_indicators.md @@ -21,9 +21,8 @@ There are three ways to get the lock LED state: The `host_keyboard_led_state()` may reflect an updated state before `led_update_user()` is called. ::: -Two deprecated functions that provide the LED state as `uint8_t`: +Deprecated functions that provide the LED state as `uint8_t`: -* `uint8_t led_set_user(uint8_t usb_led)` * `uint8_t host_keyboard_leds()` ## Configuration Options @@ -50,10 +49,6 @@ When the configuration options do not provide enough flexibility, the following Both receives LED state as a struct parameter. Returning `true` in `led_update_user()` will allow the keyboard level code in `led_update_kb()` to run as well. Returning `false` will override the keyboard level code, depending on how the keyboard level function is set up. -::: tip -This boolean return type of `led_update_user` allows for overriding keyboard LED controls, and is thus recommended over the void `led_set_user` function. -::: - ### Example of keyboard LED update implementation This is a template indicator function that can be implemented on keyboard level code: diff --git a/keyboards/converter/usb_usb/custom_matrix.cpp b/keyboards/converter/usb_usb/custom_matrix.cpp index ca0855a82b..e1ef695570 100644 --- a/keyboards/converter/usb_usb/custom_matrix.cpp +++ b/keyboards/converter/usb_usb/custom_matrix.cpp @@ -229,7 +229,6 @@ extern "C" { if (kbd2.isReady()) kbd2.SetReport(0, 0, 2, 0, 1, &usb_led); if (kbd3.isReady()) kbd3.SetReport(0, 0, 2, 0, 1, &usb_led); if (kbd4.isReady()) kbd4.SetReport(0, 0, 2, 0, 1, &usb_led); - led_set_user(usb_led); led_update_kb((led_t){.raw = usb_led}); } } diff --git a/keyboards/sirius/unigo66/custom_matrix.cpp b/keyboards/sirius/unigo66/custom_matrix.cpp index 25648a5f78..879a0e7c15 100644 --- a/keyboards/sirius/unigo66/custom_matrix.cpp +++ b/keyboards/sirius/unigo66/custom_matrix.cpp @@ -216,7 +216,6 @@ extern "C" kbd2.SetReport(0, 0, 2, 0, 1, &usb_led); kbd3.SetReport(0, 0, 2, 0, 1, &usb_led); kbd4.SetReport(0, 0, 2, 0, 1, &usb_led); - led_set_user(usb_led); led_update_kb((led_t){.raw = usb_led}); } diff --git a/quantum/led.c b/quantum/led.c index e2b5985109..aec3edc823 100644 --- a/quantum/led.c +++ b/quantum/led.c @@ -56,19 +56,15 @@ static void handle_backlight_caps_lock(led_t led_state) { #endif static uint32_t last_led_modification_time = 0; -uint32_t last_led_activity_time(void) { + +uint32_t last_led_activity_time(void) { return last_led_modification_time; } + uint32_t last_led_activity_elapsed(void) { return timer_elapsed32(last_led_modification_time); } -/** \brief Lock LED set callback - keymap/user level - * - * \deprecated Use led_update_user() instead. - */ -__attribute__((weak)) void led_set_user(uint8_t usb_led) {} - /** \brief Lock LED update callback - keymap/user level * * \return True if led_update_kb() should run its own code, false otherwise. @@ -146,7 +142,6 @@ __attribute__((weak)) void led_set(uint8_t usb_led) { handle_backlight_caps_lock((led_t)usb_led); #endif - led_set_user(usb_led); led_update_kb((led_t)usb_led); } diff --git a/quantum/led.h b/quantum/led.h index b9fad670ae..669e93e194 100644 --- a/quantum/led.h +++ b/quantum/led.h @@ -48,9 +48,6 @@ void led_wakeup(void); void led_task(void); -/* Deprecated callbacks */ -void led_set_user(uint8_t usb_led); - /* Callbacks */ bool led_update_user(led_t led_state); bool led_update_kb(led_t led_state); -- cgit v1.2.3 From bc0c69570b8a8b1d9a754a280053e49a825b24d7 Mon Sep 17 00:00:00 2001 From: Ryan Date: Wed, 3 Jul 2024 17:18:27 +1000 Subject: Rename encoder pins defines (#24003) --- docs/features/encoders.md | 28 +++++++++---------- docs/features/split_keyboard.md | 4 +-- drivers/encoder/encoder_quadrature.c | 18 ++++++------- .../dailycraft/wings42/rev2/keymaps/via/config.h | 4 +-- keyboards/handwired/sick68/keymaps/via/config.h | 4 +-- .../kapcave/gskt00/keymaps/default-poly/config.h | 4 +-- keyboards/pica40/rev2/rev2.c | 4 +-- keyboards/ploopyco/mouse/config.h | 4 +-- keyboards/ploopyco/ploopyco.c | 4 +-- keyboards/ploopyco/trackball/config.h | 4 +-- keyboards/ploopyco/trackball_mini/config.h | 4 +-- keyboards/ploopyco/trackball_thumb/config.h | 4 +-- keyboards/rgbkb/sol/keymaps/default/keymap.c | 2 +- keyboards/rgbkb/sol/rev2/config.h | 8 +++--- keyboards/terrazzo/readme.md | 4 +-- lib/python/qmk/cli/generate/config_h.py | 4 +-- lib/python/qmk/info.py | 4 +-- quantum/encoder.h | 31 ++++++++++++++-------- quantum/encoder/tests/config_mock.h | 4 +-- .../tests/config_mock_split_left_eq_right.h | 8 +++--- .../tests/config_mock_split_left_gt_right.h | 8 +++--- .../tests/config_mock_split_left_lt_right.h | 8 +++--- quantum/encoder/tests/config_mock_split_no_left.h | 8 +++--- quantum/encoder/tests/config_mock_split_no_right.h | 8 +++--- quantum/encoder/tests/config_mock_split_role.h | 8 +++--- 25 files changed, 100 insertions(+), 91 deletions(-) (limited to 'quantum') diff --git a/docs/features/encoders.md b/docs/features/encoders.md index 3d1cac79af..eea70dafec 100644 --- a/docs/features/encoders.md +++ b/docs/features/encoders.md @@ -9,15 +9,15 @@ ENCODER_ENABLE = yes and this to your `config.h`: ```c -#define ENCODERS_PAD_A { B12 } -#define ENCODERS_PAD_B { B13 } +#define ENCODER_A_PINS { B12 } +#define ENCODER_B_PINS { B13 } ``` Each PAD_A/B variable defines an array so multiple encoders can be defined, e.g.: ```c -#define ENCODERS_PAD_A { encoder1a, encoder2a } -#define ENCODERS_PAD_B { encoder1b, encoder2b } +#define ENCODER_A_PINS { encoder1a, encoder2a } +#define ENCODER_B_PINS { encoder1b, encoder2b } ``` If your encoder's clockwise directions are incorrect, you can swap the A & B pad definitions. They can also be flipped with a define: @@ -49,8 +49,8 @@ For 4× encoders you also can assign default position if encoder skips pulses wh If you are using different pinouts for the encoders on each half of a split keyboard, you can define the pinout (and optionally, resolutions) for the right half like this: ```c -#define ENCODERS_PAD_A_RIGHT { encoder1a, encoder2a } -#define ENCODERS_PAD_B_RIGHT { encoder1b, encoder2b } +#define ENCODER_A_PINS_RIGHT { encoder1a, encoder2a } +#define ENCODER_B_PINS_RIGHT { encoder1b, encoder2b } #define ENCODER_RESOLUTIONS_RIGHT { 2, 4 } ``` @@ -59,11 +59,11 @@ If the `_RIGHT` definitions aren't specified in your `config.h`, then the non-`_ Additionally, if one side does not have an encoder, you can specify `{}` for the pins/resolution -- for example, a split keyboard with only a right-side encoder: ```c -#define ENCODERS_PAD_A { } -#define ENCODERS_PAD_B { } +#define ENCODER_A_PINS { } +#define ENCODER_B_PINS { } #define ENCODER_RESOLUTIONS { } -#define ENCODERS_PAD_A_RIGHT { B12 } -#define ENCODERS_PAD_B_RIGHT { B13 } +#define ENCODER_A_PINS_RIGHT { B12 } +#define ENCODER_B_PINS_RIGHT { B13 } #define ENCODER_RESOLUTIONS_RIGHT { 4 } ``` @@ -174,13 +174,13 @@ Multiple encoders may share pins so long as each encoder has a distinct pair of For example you can support two encoders using only 3 pins like this ``` -#define ENCODERS_PAD_A { B1, B1 } -#define ENCODERS_PAD_B { B2, B3 } +#define ENCODER_A_PINS { B1, B1 } +#define ENCODER_B_PINS { B2, B3 } ``` You could even support three encoders using only three pins (one per encoder) however in this configuration, rotating two encoders which share pins simultaneously will often generate incorrect output. For example: ``` -#define ENCODERS_PAD_A { B1, B1, B2 } -#define ENCODERS_PAD_B { B2, B3, B3 } +#define ENCODER_A_PINS { B1, B1, B2 } +#define ENCODER_B_PINS { B2, B3, B3 } ``` Here rotating Encoder 0 `B1 B2` and Encoder 1 `B1 B3` could be interpreted as rotating Encoder 2 `B2 B3` or `B3 B2` depending on the timing. This may still be a useful configuration depending on your use case diff --git a/docs/features/split_keyboard.md b/docs/features/split_keyboard.md index 6efa1c2a35..49582c3946 100644 --- a/docs/features/split_keyboard.md +++ b/docs/features/split_keyboard.md @@ -417,8 +417,8 @@ This allows you to specify a different set of pins for the matrix on the right s This allows you to specify a different set of direct pins for the right side. ```c -#define ENCODERS_PAD_A_RIGHT { encoder1a, encoder2a } -#define ENCODERS_PAD_B_RIGHT { encoder1b, encoder2b } +#define ENCODER_A_PINS_RIGHT { encoder1a, encoder2a } +#define ENCODER_B_PINS_RIGHT { encoder1b, encoder2b } ``` This allows you to specify a different set of encoder pins for the right side. diff --git a/drivers/encoder/encoder_quadrature.c b/drivers/encoder/encoder_quadrature.c index cd589bf1e2..086f500391 100644 --- a/drivers/encoder/encoder_quadrature.c +++ b/drivers/encoder/encoder_quadrature.c @@ -22,7 +22,7 @@ #endif #undef ENCODER_DEFAULT_PIN_API_IMPL -#if defined(ENCODERS_PAD_A) && defined(ENCODERS_PAD_B) +#if defined(ENCODER_A_PINS) && defined(ENCODER_B_PINS) // Inform the quadrature driver that it needs to implement pin init/read functions # define ENCODER_DEFAULT_PIN_API_IMPL #endif @@ -34,8 +34,8 @@ __attribute__((weak)) uint8_t encoder_quadrature_read_pin(uint8_t index, bool pa #ifdef ENCODER_DEFAULT_PIN_API_IMPL -static pin_t encoders_pad_a[NUM_ENCODERS_MAX_PER_SIDE] = ENCODERS_PAD_A; -static pin_t encoders_pad_b[NUM_ENCODERS_MAX_PER_SIDE] = ENCODERS_PAD_B; +static pin_t encoders_pad_a[NUM_ENCODERS_MAX_PER_SIDE] = ENCODER_A_PINS; +static pin_t encoders_pad_b[NUM_ENCODERS_MAX_PER_SIDE] = ENCODER_B_PINS; __attribute__((weak)) void encoder_wait_pullup_charge(void) { wait_us(100); @@ -123,25 +123,25 @@ void encoder_driver_init(void) { // here, but it's the simplest solution. memset(encoder_state, 0, sizeof(encoder_state)); memset(encoder_pulses, 0, sizeof(encoder_pulses)); - const pin_t encoders_pad_a_left[] = ENCODERS_PAD_A; - const pin_t encoders_pad_b_left[] = ENCODERS_PAD_B; + const pin_t encoders_pad_a_left[] = ENCODER_A_PINS; + const pin_t encoders_pad_b_left[] = ENCODER_B_PINS; for (uint8_t i = 0; i < thisCount; i++) { encoders_pad_a[i] = encoders_pad_a_left[i]; encoders_pad_b[i] = encoders_pad_b_left[i]; } #endif -#if defined(SPLIT_KEYBOARD) && defined(ENCODERS_PAD_A_RIGHT) && defined(ENCODERS_PAD_B_RIGHT) +#if defined(SPLIT_KEYBOARD) && defined(ENCODER_A_PINS_RIGHT) && defined(ENCODER_B_PINS_RIGHT) // Re-initialise the pads if it's the right-hand side if (!isLeftHand) { - const pin_t encoders_pad_a_right[] = ENCODERS_PAD_A_RIGHT; - const pin_t encoders_pad_b_right[] = ENCODERS_PAD_B_RIGHT; + const pin_t encoders_pad_a_right[] = ENCODER_A_PINS_RIGHT; + const pin_t encoders_pad_b_right[] = ENCODER_B_PINS_RIGHT; for (uint8_t i = 0; i < thisCount; i++) { encoders_pad_a[i] = encoders_pad_a_right[i]; encoders_pad_b[i] = encoders_pad_b_right[i]; } } -#endif // defined(SPLIT_KEYBOARD) && defined(ENCODERS_PAD_A_RIGHT) && defined(ENCODERS_PAD_B_RIGHT) +#endif // defined(SPLIT_KEYBOARD) && defined(ENCODER_A_PINS_RIGHT) && defined(ENCODER_B_PINS_RIGHT) // Encoder resolutions is defined differently in config.h, so concatenate #if defined(SPLIT_KEYBOARD) && defined(ENCODER_RESOLUTIONS) diff --git a/keyboards/dailycraft/wings42/rev2/keymaps/via/config.h b/keyboards/dailycraft/wings42/rev2/keymaps/via/config.h index 3e0c8d146a..6a9ab04738 100644 --- a/keyboards/dailycraft/wings42/rev2/keymaps/via/config.h +++ b/keyboards/dailycraft/wings42/rev2/keymaps/via/config.h @@ -15,6 +15,6 @@ */ #pragma once -#define ENCODERS_PAD_A { B5, B6 } -#define ENCODERS_PAD_B { B4, B2 } +#define ENCODER_A_PINS { B5, B6 } +#define ENCODER_B_PINS { B4, B2 } #define ENCODER_RESOLUTION 4 diff --git a/keyboards/handwired/sick68/keymaps/via/config.h b/keyboards/handwired/sick68/keymaps/via/config.h index 4ce1e3e785..bf6fd3ea4f 100644 --- a/keyboards/handwired/sick68/keymaps/via/config.h +++ b/keyboards/handwired/sick68/keymaps/via/config.h @@ -15,6 +15,6 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ -#define ENCODERS_PAD_A { F0 } -#define ENCODERS_PAD_B { F1 } +#define ENCODER_A_PINS { F0 } +#define ENCODER_B_PINS { F1 } #define ENCODER_RESOLUTION 4 diff --git a/keyboards/kapcave/gskt00/keymaps/default-poly/config.h b/keyboards/kapcave/gskt00/keymaps/default-poly/config.h index 40a7c6ec47..9d03a669c8 100644 --- a/keyboards/kapcave/gskt00/keymaps/default-poly/config.h +++ b/keyboards/kapcave/gskt00/keymaps/default-poly/config.h @@ -16,8 +16,8 @@ along with this program. If not, see . */ #pragma once -#define ENCODERS_PAD_A { D5 } -#define ENCODERS_PAD_B { D3 } +#define ENCODER_A_PINS { D5 } +#define ENCODER_B_PINS { D3 } #define WS2812_DI_PIN D0 #define RGBLIGHT_EFFECT_BREATHING diff --git a/keyboards/pica40/rev2/rev2.c b/keyboards/pica40/rev2/rev2.c index 0ba9a53734..b5d79508fc 100644 --- a/keyboards/pica40/rev2/rev2.c +++ b/keyboards/pica40/rev2/rev2.c @@ -6,8 +6,8 @@ #ifdef ENCODER_ENABLE // code based on encoder.c -#define ENCODER_PIN_A (((pin_t[])ENCODERS_PAD_A)[0]) -#define ENCODER_PIN_B (((pin_t[])ENCODERS_PAD_B)[0]) +#define ENCODER_PIN_A (((pin_t[])ENCODER_A_PINS)[0]) +#define ENCODER_PIN_B (((pin_t[])ENCODER_B_PINS)[0]) // custom handler that returns encoder B pin status from slave side void encoder_sync_slave_handler(uint8_t in_buflen, const void *in_data, uint8_t out_buflen, void *out_data) { diff --git a/keyboards/ploopyco/mouse/config.h b/keyboards/ploopyco/mouse/config.h index 0375a8875a..0f8774dcd7 100644 --- a/keyboards/ploopyco/mouse/config.h +++ b/keyboards/ploopyco/mouse/config.h @@ -38,5 +38,5 @@ /* Custom encoder needs to specify just how many encoders we have */ #define NUM_ENCODERS 1 -#define ENCODERS_PAD_A { F0 } -#define ENCODERS_PAD_B { F4 } +#define ENCODER_A_PINS { F0 } +#define ENCODER_B_PINS { F4 } diff --git a/keyboards/ploopyco/ploopyco.c b/keyboards/ploopyco/ploopyco.c index e4726238f2..a6f76203d6 100644 --- a/keyboards/ploopyco/ploopyco.c +++ b/keyboards/ploopyco/ploopyco.c @@ -71,8 +71,8 @@ float scroll_accumulated_v = 0; #ifdef ENCODER_ENABLE uint16_t lastScroll = 0; // Previous confirmed wheel event uint16_t lastMidClick = 0; // Stops scrollwheel from being read if it was pressed -pin_t encoder_pins_a[1] = ENCODERS_PAD_A; -pin_t encoder_pins_b[1] = ENCODERS_PAD_B; +pin_t encoder_pins_a[1] = ENCODER_A_PINS; +pin_t encoder_pins_b[1] = ENCODER_B_PINS; bool debug_encoder = false; bool encoder_update_kb(uint8_t index, bool clockwise) { diff --git a/keyboards/ploopyco/trackball/config.h b/keyboards/ploopyco/trackball/config.h index 80457d062a..2aac27437a 100644 --- a/keyboards/ploopyco/trackball/config.h +++ b/keyboards/ploopyco/trackball/config.h @@ -38,5 +38,5 @@ /* Custom encoder needs to specify just how many encoders we have */ #define NUM_ENCODERS 1 -#define ENCODERS_PAD_A { F0 } -#define ENCODERS_PAD_B { F4 } +#define ENCODER_A_PINS { F0 } +#define ENCODER_B_PINS { F4 } diff --git a/keyboards/ploopyco/trackball_mini/config.h b/keyboards/ploopyco/trackball_mini/config.h index c5d2d5694e..2e0b570bba 100644 --- a/keyboards/ploopyco/trackball_mini/config.h +++ b/keyboards/ploopyco/trackball_mini/config.h @@ -38,5 +38,5 @@ /* Custom encoder needs to specify just how many encoders we have */ #define NUM_ENCODERS 1 -#define ENCODERS_PAD_A { F0 } -#define ENCODERS_PAD_B { F4 } +#define ENCODER_A_PINS { F0 } +#define ENCODER_B_PINS { F4 } diff --git a/keyboards/ploopyco/trackball_thumb/config.h b/keyboards/ploopyco/trackball_thumb/config.h index 631456d9d3..f03ffc7699 100644 --- a/keyboards/ploopyco/trackball_thumb/config.h +++ b/keyboards/ploopyco/trackball_thumb/config.h @@ -42,5 +42,5 @@ /* Custom encoder needs to specify just how many encoders we have */ #define NUM_ENCODERS 1 -#define ENCODERS_PAD_A { F4 } -#define ENCODERS_PAD_B { F0 } +#define ENCODER_A_PINS { F4 } +#define ENCODER_B_PINS { F0 } diff --git a/keyboards/rgbkb/sol/keymaps/default/keymap.c b/keyboards/rgbkb/sol/keymaps/default/keymap.c index 4a6511cbfc..8997e9a582 100644 --- a/keyboards/rgbkb/sol/keymaps/default/keymap.c +++ b/keyboards/rgbkb/sol/keymaps/default/keymap.c @@ -201,7 +201,7 @@ const rgb_matrix_f rgb_matrix_functions[6][2] = { #ifdef ENCODER_ENABLE -static pin_t encoders_pad_a[] = ENCODERS_PAD_A; +static pin_t encoders_pad_a[] = ENCODER_A_PINS; #define NUMBER_OF_ENCODERS ARRAY_SIZE(encoders_pad_a) const uint16_t PROGMEM encoders[][NUMBER_OF_ENCODERS * 2][2] = { diff --git a/keyboards/rgbkb/sol/rev2/config.h b/keyboards/rgbkb/sol/rev2/config.h index ab5150051a..5867c6dfe3 100644 --- a/keyboards/rgbkb/sol/rev2/config.h +++ b/keyboards/rgbkb/sol/rev2/config.h @@ -49,12 +49,12 @@ along with this program. If not, see . // Encoder support #ifndef EXTRA_ENCODERS_ENABLE -#define ENCODERS_PAD_A { D2 } -#define ENCODERS_PAD_B { D6 } +#define ENCODER_A_PINS { D2 } +#define ENCODER_B_PINS { D6 } #else #ifdef OLED_ENABLE #error Extra encoders cannot be enabled at the same time as the OLED Driver as they use the same pins. #endif -#define ENCODERS_PAD_A { D2, D1, B0 } -#define ENCODERS_PAD_B { D6, B1, D0 } +#define ENCODER_A_PINS { D2, D1, B0 } +#define ENCODER_B_PINS { D6, B1, D0 } #endif diff --git a/keyboards/terrazzo/readme.md b/keyboards/terrazzo/readme.md index e0f4f3457f..828819f7b4 100644 --- a/keyboards/terrazzo/readme.md +++ b/keyboards/terrazzo/readme.md @@ -82,8 +82,8 @@ Change pinouts, Pro Micro does not have the "F0" pin. Set encoder to just top or bottom position. ``` -#define ENCODERS_PAD_A { C6 } -#define ENCODERS_PAD_B { D4 } +#define ENCODER_A_PINS { C6 } +#define ENCODER_B_PINS { D4 } ``` ## Encoder Setup diff --git a/lib/python/qmk/cli/generate/config_h.py b/lib/python/qmk/cli/generate/config_h.py index fc681300a3..d613f7b92c 100755 --- a/lib/python/qmk/cli/generate/config_h.py +++ b/lib/python/qmk/cli/generate/config_h.py @@ -135,8 +135,8 @@ def generate_encoder_config(encoder_json, config_h_lines, postfix=''): b_pads.append(encoder["pin_b"]) resolutions.append(encoder.get("resolution", None)) - config_h_lines.append(generate_define(f'ENCODERS_PAD_A{postfix}', f'{{ {", ".join(a_pads)} }}')) - config_h_lines.append(generate_define(f'ENCODERS_PAD_B{postfix}', f'{{ {", ".join(b_pads)} }}')) + config_h_lines.append(generate_define(f'ENCODER_A_PINS{postfix}', f'{{ {", ".join(a_pads)} }}')) + config_h_lines.append(generate_define(f'ENCODER_B_PINS{postfix}', f'{{ {", ".join(b_pads)} }}')) if None in resolutions: cli.log.debug(f"Unable to generate ENCODER_RESOLUTION{postfix} configuration") diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py index 091a11854c..5b3b249015 100644 --- a/lib/python/qmk/info.py +++ b/lib/python/qmk/info.py @@ -375,8 +375,8 @@ def _extract_audio(info_data, config_c): def _extract_encoders_values(config_c, postfix=''): """Common encoder extraction logic """ - a_pad = config_c.get(f'ENCODERS_PAD_A{postfix}', '').replace(' ', '')[1:-1] - b_pad = config_c.get(f'ENCODERS_PAD_B{postfix}', '').replace(' ', '')[1:-1] + a_pad = config_c.get(f'ENCODER_A_PINS{postfix}', '').replace(' ', '')[1:-1] + b_pad = config_c.get(f'ENCODER_B_PINS{postfix}', '').replace(' ', '')[1:-1] resolutions = config_c.get(f'ENCODER_RESOLUTIONS{postfix}', '').replace(' ', '')[1:-1] default_resolution = config_c.get('ENCODER_RESOLUTION', None) diff --git a/quantum/encoder.h b/quantum/encoder.h index 317a91f1da..1d2f1f46c7 100644 --- a/quantum/encoder.h +++ b/quantum/encoder.h @@ -22,6 +22,21 @@ #include "gpio.h" #include "util.h" +// ======== DEPRECATED DEFINES - DO NOT USE ======== +#ifdef ENCODERS_PAD_A +# define ENCODER_A_PINS ENCODERS_PAD_A +#endif +#ifdef ENCODERS_PAD_B +# define ENCODER_B_PINS ENCODERS_PAD_B +#endif +#ifdef ENCODERS_PAD_A_RIGHT +# define ENCODER_A_PINS_RIGHT ENCODERS_PAD_A_RIGHT +#endif +#ifdef ENCODERS_PAD_B_RIGHT +# define ENCODER_B_PINS_RIGHT ENCODERS_PAD_B_RIGHT +#endif +// ======== + #ifdef ENCODER_ENABLE __attribute__((weak)) bool should_process_encoder(void); @@ -36,16 +51,16 @@ bool encoder_update_user(uint8_t index, bool clockwise); # ifdef SPLIT_KEYBOARD -# if defined(ENCODERS_PAD_A_RIGHT) +# if defined(ENCODER_A_PINS_RIGHT) # ifndef NUM_ENCODERS_LEFT -# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A)) +# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODER_A_PINS)) # endif # ifndef NUM_ENCODERS_RIGHT -# define NUM_ENCODERS_RIGHT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A_RIGHT)) +# define NUM_ENCODERS_RIGHT ARRAY_SIZE(((pin_t[])ENCODER_A_PINS_RIGHT)) # endif # else # ifndef NUM_ENCODERS_LEFT -# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A)) +# define NUM_ENCODERS_LEFT ARRAY_SIZE(((pin_t[])ENCODER_A_PINS)) # endif # ifndef NUM_ENCODERS_RIGHT # define NUM_ENCODERS_RIGHT NUM_ENCODERS_LEFT @@ -58,19 +73,13 @@ bool encoder_update_user(uint8_t index, bool clockwise); # else // SPLIT_KEYBOARD # ifndef NUM_ENCODERS -# define NUM_ENCODERS ARRAY_SIZE(((pin_t[])ENCODERS_PAD_A)) +# define NUM_ENCODERS ARRAY_SIZE(((pin_t[])ENCODER_A_PINS)) # endif # define NUM_ENCODERS_LEFT NUM_ENCODERS # define NUM_ENCODERS_RIGHT 0 # endif // SPLIT_KEYBOARD -# ifndef NUM_ENCODERS -# define NUM_ENCODERS 0 -# define NUM_ENCODERS_LEFT 0 -# define NUM_ENCODERS_RIGHT 0 -# endif // NUM_ENCODERS - # define NUM_ENCODERS_MAX_PER_SIDE MAX(NUM_ENCODERS_LEFT, NUM_ENCODERS_RIGHT) # ifndef MAX_QUEUED_ENCODER_EVENTS diff --git a/quantum/encoder/tests/config_mock.h b/quantum/encoder/tests/config_mock.h index 9eb59ddc88..b5a1537d8a 100644 --- a/quantum/encoder/tests/config_mock.h +++ b/quantum/encoder/tests/config_mock.h @@ -7,9 +7,9 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ { 0 } -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ { 1 } #ifdef __cplusplus diff --git a/quantum/encoder/tests/config_mock_split_left_eq_right.h b/quantum/encoder/tests/config_mock_split_left_eq_right.h index ea795657ef..a4aa051ef1 100644 --- a/quantum/encoder/tests/config_mock_split_left_eq_right.h +++ b/quantum/encoder/tests/config_mock_split_left_eq_right.h @@ -7,13 +7,13 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ { 0, 2 } -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ { 1, 3 } -#define ENCODERS_PAD_A_RIGHT \ +#define ENCODER_A_PINS_RIGHT \ { 4, 6 } -#define ENCODERS_PAD_B_RIGHT \ +#define ENCODER_B_PINS_RIGHT \ { 5, 7 } #ifdef __cplusplus diff --git a/quantum/encoder/tests/config_mock_split_left_gt_right.h b/quantum/encoder/tests/config_mock_split_left_gt_right.h index abcfe03918..77190797ad 100644 --- a/quantum/encoder/tests/config_mock_split_left_gt_right.h +++ b/quantum/encoder/tests/config_mock_split_left_gt_right.h @@ -7,13 +7,13 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ { 0, 2, 4 } -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ { 1, 3, 5 } -#define ENCODERS_PAD_A_RIGHT \ +#define ENCODER_A_PINS_RIGHT \ { 6, 8 } -#define ENCODERS_PAD_B_RIGHT \ +#define ENCODER_B_PINS_RIGHT \ { 7, 9 } #ifdef __cplusplus diff --git a/quantum/encoder/tests/config_mock_split_left_lt_right.h b/quantum/encoder/tests/config_mock_split_left_lt_right.h index 075c774b0d..61808e866e 100644 --- a/quantum/encoder/tests/config_mock_split_left_lt_right.h +++ b/quantum/encoder/tests/config_mock_split_left_lt_right.h @@ -7,13 +7,13 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ { 0, 2 } -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ { 1, 3 } -#define ENCODERS_PAD_A_RIGHT \ +#define ENCODER_A_PINS_RIGHT \ { 4, 6, 8 } -#define ENCODERS_PAD_B_RIGHT \ +#define ENCODER_B_PINS_RIGHT \ { 5, 7, 9 } #ifdef __cplusplus diff --git a/quantum/encoder/tests/config_mock_split_no_left.h b/quantum/encoder/tests/config_mock_split_no_left.h index dfd8358929..599e584ff1 100644 --- a/quantum/encoder/tests/config_mock_split_no_left.h +++ b/quantum/encoder/tests/config_mock_split_no_left.h @@ -7,13 +7,13 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ {} -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ {} -#define ENCODERS_PAD_A_RIGHT \ +#define ENCODER_A_PINS_RIGHT \ { 0, 2 } -#define ENCODERS_PAD_B_RIGHT \ +#define ENCODER_B_PINS_RIGHT \ { 1, 3 } #ifdef __cplusplus diff --git a/quantum/encoder/tests/config_mock_split_no_right.h b/quantum/encoder/tests/config_mock_split_no_right.h index 5683eade8c..c3f753014c 100644 --- a/quantum/encoder/tests/config_mock_split_no_right.h +++ b/quantum/encoder/tests/config_mock_split_no_right.h @@ -7,13 +7,13 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ { 0, 2 } -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ { 1, 3 } -#define ENCODERS_PAD_A_RIGHT \ +#define ENCODER_A_PINS_RIGHT \ {} -#define ENCODERS_PAD_B_RIGHT \ +#define ENCODER_B_PINS_RIGHT \ {} #ifdef __cplusplus diff --git a/quantum/encoder/tests/config_mock_split_role.h b/quantum/encoder/tests/config_mock_split_role.h index ea795657ef..a4aa051ef1 100644 --- a/quantum/encoder/tests/config_mock_split_role.h +++ b/quantum/encoder/tests/config_mock_split_role.h @@ -7,13 +7,13 @@ #define MATRIX_COLS 1 /* Here, "pins" from 0 to 31 are allowed. */ -#define ENCODERS_PAD_A \ +#define ENCODER_A_PINS \ { 0, 2 } -#define ENCODERS_PAD_B \ +#define ENCODER_B_PINS \ { 1, 3 } -#define ENCODERS_PAD_A_RIGHT \ +#define ENCODER_A_PINS_RIGHT \ { 4, 6 } -#define ENCODERS_PAD_B_RIGHT \ +#define ENCODER_B_PINS_RIGHT \ { 5, 7 } #ifdef __cplusplus -- cgit v1.2.3 From f8596b40a4bb15a1881138baa8b8787277e2e622 Mon Sep 17 00:00:00 2001 From: Ryan Date: Wed, 3 Jul 2024 18:35:54 +1000 Subject: Normalise mouse keycodes (#23975) --- data/constants/keycodes/keycodes_0.0.5.hjson | 0 data/constants/keycodes/keycodes_0.0.5_basic.hjson | 175 +++++++++++++++++++++ docs/features/encoders.md | 8 +- docs/features/mouse_keys.md | 82 +++++----- docs/features/repeat_key.md | 8 +- docs/keycodes.md | 39 ++--- drivers/sensors/cirque_pinnacle_gestures.h | 2 +- .../lib/satisfaction75/satisfaction_encoder.c | 6 +- keyboards/dichotomy/keymaps/default/keymap.c | 16 +- quantum/action.c | 6 +- quantum/encoder.c | 4 +- quantum/keycode.h | 8 +- quantum/keycodes.h | 80 +++++----- quantum/mousekey.c | 112 ++++++------- quantum/pointing_device/pointing_device.c | 2 +- .../pointing_device/pointing_device_auto_mouse.h | 2 +- quantum/quantum_keycodes_legacy.h | 39 +++++ quantum/repeat_key.c | 8 +- tests/test_common/keycode_table.cpp | 38 ++--- 19 files changed, 426 insertions(+), 209 deletions(-) create mode 100644 data/constants/keycodes/keycodes_0.0.5.hjson create mode 100644 data/constants/keycodes/keycodes_0.0.5_basic.hjson (limited to 'quantum') diff --git a/data/constants/keycodes/keycodes_0.0.5.hjson b/data/constants/keycodes/keycodes_0.0.5.hjson new file mode 100644 index 0000000000..e69de29bb2 diff --git a/data/constants/keycodes/keycodes_0.0.5_basic.hjson b/data/constants/keycodes/keycodes_0.0.5_basic.hjson new file mode 100644 index 0000000000..79b6bf6596 --- /dev/null +++ b/data/constants/keycodes/keycodes_0.0.5_basic.hjson @@ -0,0 +1,175 @@ +{ + "keycodes": { + "0x00CD": { + "group": "mouse", + "key": "QK_MOUSE_CURSOR_UP", + "label": "Mouse cursor up", + "aliases": [ + "!reset!", + "MS_UP" + ] + }, + "0x00CE": { + "group": "mouse", + "key": "QK_MOUSE_CURSOR_DOWN", + "label": "Mouse cursor down", + "aliases": [ + "!reset!", + "MS_DOWN" + ] + }, + "0x00CF": { + "group": "mouse", + "key": "QK_MOUSE_CURSOR_LEFT", + "label": "Mouse cursor left", + "aliases": [ + "!reset!", + "MS_LEFT" + ] + }, + "0x00D0": { + "group": "mouse", + "key": "QK_MOUSE_CURSOR_RIGHT", + "label": "Mouse cursor right", + "aliases": [ + "!reset!", + "MS_RGHT" + ] + }, + "0x00D1": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_1", + "label": "Mouse button 1", + "aliases": [ + "!reset!", + "MS_BTN1" + ] + }, + "0x00D2": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_2", + "label": "Mouse button 2", + "aliases": [ + "!reset!", + "MS_BTN2" + ] + }, + "0x00D3": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_3", + "label": "Mouse button 3", + "aliases": [ + "!reset!", + "MS_BTN3" + ] + }, + "0x00D4": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_4", + "label": "Mouse button 4", + "aliases": [ + "!reset!", + "MS_BTN4" + ] + }, + "0x00D5": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_5", + "label": "Mouse button 5", + "aliases": [ + "!reset!", + "MS_BTN5" + ] + }, + "0x00D6": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_6", + "label": "Mouse button 6", + "aliases": [ + "!reset!", + "MS_BTN6" + ] + }, + "0x00D7": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_7", + "label": "Mouse button 7", + "aliases": [ + "!reset!", + "MS_BTN7" + ] + }, + "0x00D8": { + "group": "mouse", + "key": "QK_MOUSE_BUTTON_8", + "label": "Mouse button 8", + "aliases": [ + "!reset!", + "MS_BTN8" + ] + }, + "0x00D9": { + "group": "mouse", + "key": "QK_MOUSE_WHEEL_UP", + "label": "Mouse wheel up", + "aliases": [ + "!reset!", + "MS_WHLU" + ] + }, + "0x00DA": { + "group": "mouse", + "key": "QK_MOUSE_WHEEL_DOWN", + "label": "Mouse wheel down", + "aliases": [ + "!reset!", + "MS_WHLD" + ] + }, + "0x00DB": { + "group": "mouse", + "key": "QK_MOUSE_WHEEL_LEFT", + "label": "Mouse wheel left", + "aliases": [ + "!reset!", + "MS_WHLL" + ] + }, + "0x00DC": { + "group": "mouse", + "key": "QK_MOUSE_WHEEL_RIGHT", + "label": "Mouse wheel right", + "aliases": [ + "!reset!", + "MS_WHLR" + ] + }, + "0x00DD": { + "group": "mouse", + "key": "QK_MOUSE_ACCELERATION_0", + "label": "Set mouse acceleration to 0", + "aliases": [ + "!reset!", + "MS_ACL0" + ] + }, + "0x00DE": { + "group": "mouse", + "key": "QK_MOUSE_ACCELERATION_1", + "label": "Set mouse acceleration to 1", + "aliases": [ + "!reset!", + "MS_ACL1" + ] + }, + "0x00DF": { + "group": "mouse", + "key": "QK_MOUSE_ACCELERATION_2", + "label": "Set mouse acceleration to 2", + "aliases": [ + "!reset!", + "MS_ACL2" + ] + } + } +} diff --git a/docs/features/encoders.md b/docs/features/encoders.md index eea70dafec..73cbb4f3f3 100644 --- a/docs/features/encoders.md +++ b/docs/features/encoders.md @@ -84,10 +84,10 @@ Your `keymap.c` will then need an encoder mapping defined (for four layers and t ```c #if defined(ENCODER_MAP_ENABLE) const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = { - [0] = { ENCODER_CCW_CW(KC_MS_WH_UP, KC_MS_WH_DOWN), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) }, - [1] = { ENCODER_CCW_CW(RGB_HUD, RGB_HUI), ENCODER_CCW_CW(RGB_SAD, RGB_SAI) }, - [2] = { ENCODER_CCW_CW(RGB_VAD, RGB_VAI), ENCODER_CCW_CW(RGB_SPD, RGB_SPI) }, - [3] = { ENCODER_CCW_CW(RGB_RMOD, RGB_MOD), ENCODER_CCW_CW(KC_RIGHT, KC_LEFT) }, + [0] = { ENCODER_CCW_CW(MS_WHLU, MS_WHLD), ENCODER_CCW_CW(KC_VOLD, KC_VOLU) }, + [1] = { ENCODER_CCW_CW(RGB_HUD, RGB_HUI), ENCODER_CCW_CW(RGB_SAD, RGB_SAI) }, + [2] = { ENCODER_CCW_CW(RGB_VAD, RGB_VAI), ENCODER_CCW_CW(RGB_SPD, RGB_SPI) }, + [3] = { ENCODER_CCW_CW(RGB_RMOD, RGB_MOD), ENCODER_CCW_CW(KC_RIGHT, KC_LEFT) }, }; #endif ``` diff --git a/docs/features/mouse_keys.md b/docs/features/mouse_keys.md index c2b3e98f42..4cc06c992a 100644 --- a/docs/features/mouse_keys.md +++ b/docs/features/mouse_keys.md @@ -18,27 +18,27 @@ MOUSEKEY_ENABLE = yes In your keymap you can use the following keycodes to map key presses to mouse actions: -|Key |Aliases |Description | -|----------------|---------|-----------------| -|`KC_MS_UP` |`KC_MS_U`|Move cursor up | -|`KC_MS_DOWN` |`KC_MS_D`|Move cursor down | -|`KC_MS_LEFT` |`KC_MS_L`|Move cursor left | -|`KC_MS_RIGHT` |`KC_MS_R`|Move cursor right| -|`KC_MS_BTN1` |`KC_BTN1`|Press button 1 | -|`KC_MS_BTN2` |`KC_BTN2`|Press button 2 | -|`KC_MS_BTN3` |`KC_BTN3`|Press button 3 | -|`KC_MS_BTN4` |`KC_BTN4`|Press button 4 | -|`KC_MS_BTN5` |`KC_BTN5`|Press button 5 | -|`KC_MS_BTN6` |`KC_BTN6`|Press button 6 | -|`KC_MS_BTN7` |`KC_BTN7`|Press button 7 | -|`KC_MS_BTN8` |`KC_BTN8`|Press button 8 | -|`KC_MS_WH_UP` |`KC_WH_U`|Move wheel up | -|`KC_MS_WH_DOWN` |`KC_WH_D`|Move wheel down | -|`KC_MS_WH_LEFT` |`KC_WH_L`|Move wheel left | -|`KC_MS_WH_RIGHT`|`KC_WH_R`|Move wheel right | -|`KC_MS_ACCEL0` |`KC_ACL0`|Set speed to 0 | -|`KC_MS_ACCEL1` |`KC_ACL1`|Set speed to 1 | -|`KC_MS_ACCEL2` |`KC_ACL2`|Set speed to 2 | +|Key |Aliases |Description | +|-------------------------|---------|---------------------------| +|`QK_MOUSE_CURSOR_UP` |`MS_UP` |Mouse cursor up | +|`QK_MOUSE_CURSOR_DOWN` |`MS_DOWN`|Mouse cursor down | +|`QK_MOUSE_CURSOR_LEFT` |`MS_LEFT`|Mouse cursor left | +|`QK_MOUSE_CURSOR_RIGHT` |`MS_RGHT`|Mouse cursor right | +|`QK_MOUSE_BUTTON_1` |`MS_BTN1`|Mouse button 1 | +|`QK_MOUSE_BUTTON_2` |`MS_BTN2`|Mouse button 2 | +|`QK_MOUSE_BUTTON_3` |`MS_BTN3`|Mouse button 3 | +|`QK_MOUSE_BUTTON_4` |`MS_BTN4`|Mouse button 4 | +|`QK_MOUSE_BUTTON_5` |`MS_BTN5`|Mouse button 5 | +|`QK_MOUSE_BUTTON_6` |`MS_BTN6`|Mouse button 6 | +|`QK_MOUSE_BUTTON_7` |`MS_BTN7`|Mouse button 7 | +|`QK_MOUSE_BUTTON_8` |`MS_BTN8`|Mouse button 8 | +|`QK_MOUSE_WHEEL_UP` |`MS_WHLU`|Mouse wheel up | +|`QK_MOUSE_WHEEL_DOWN` |`MS_WHLD`|Mouse wheel down | +|`QK_MOUSE_WHEEL_LEFT` |`MS_WHLL`|Mouse wheel left | +|`QK_MOUSE_WHEEL_RIGHT` |`MS_WHLR`|Mouse wheel right | +|`QK_MOUSE_ACCELERATION_0`|`MS_ACL0`|Set mouse acceleration to 0| +|`QK_MOUSE_ACCELERATION_1`|`MS_ACL1`|Set mouse acceleration to 1| +|`QK_MOUSE_ACCELERATION_2`|`MS_ACL2`|Set mouse acceleration to 2| ## Configuring mouse keys @@ -106,17 +106,17 @@ Tips: ### Constant mode -In this mode you can define multiple different speeds for both the cursor and the mouse wheel. There is no acceleration. `KC_ACL0`, `KC_ACL1` and `KC_ACL2` change the cursor and scroll speed to their respective setting. +In this mode you can define multiple different speeds for both the cursor and the mouse wheel. There is no acceleration. `MS_ACL0`, `MS_ACL1` and `MS_ACL2` change the cursor and scroll speed to their respective setting. You can choose whether speed selection is momentary or tap-to-select: * **Momentary:** The chosen speed is only active while you hold the respective key. When the key is raised, mouse keys returns to the unmodified speed. -* **Tap-to-select:** The chosen speed is activated when you press the respective key and remains active even after the key has been raised. The default speed is that of `KC_ACL1`. There is no unmodified speed. +* **Tap-to-select:** The chosen speed is activated when you press the respective key and remains active even after the key has been raised. The default speed is that of `MS_ACL1`. There is no unmodified speed. The default speeds from slowest to fastest are as follows: -* **Momentary:** `KC_ACL0` < `KC_ACL1` < *unmodified* < `KC_ACL2` -* **Tap-to-select:** `KC_ACL0` < `KC_ACL1` < `KC_ACL2` +* **Momentary:** `MS_ACL0` < `MS_ACL1` < *unmodified* < `MS_ACL2` +* **Tap-to-select:** `MS_ACL0` < `MS_ACL1` < `MS_ACL2` To use constant speed mode, you must at least define `MK_3_SPEED` in your keymap’s `config.h` file: @@ -138,32 +138,32 @@ Use the following settings if you want to adjust cursor movement or scrolling: |`MK_MOMENTARY_ACCEL` |*Not defined*|Enable momentary speed selection | |`MK_C_OFFSET_UNMOD` |16 |Cursor offset per movement (unmodified) | |`MK_C_INTERVAL_UNMOD`|16 |Time between cursor movements (unmodified) | -|`MK_C_OFFSET_0` |1 |Cursor offset per movement (`KC_ACL0`) | -|`MK_C_INTERVAL_0` |32 |Time between cursor movements (`KC_ACL0`) | -|`MK_C_OFFSET_1` |4 |Cursor offset per movement (`KC_ACL1`) | -|`MK_C_INTERVAL_1` |16 |Time between cursor movements (`KC_ACL1`) | -|`MK_C_OFFSET_2` |32 |Cursor offset per movement (`KC_ACL2`) | -|`MK_C_INTERVAL_2` |16 |Time between cursor movements (`KC_ACL2`) | +|`MK_C_OFFSET_0` |1 |Cursor offset per movement (`MS_ACL0`) | +|`MK_C_INTERVAL_0` |32 |Time between cursor movements (`MS_ACL0`) | +|`MK_C_OFFSET_1` |4 |Cursor offset per movement (`MS_ACL1`) | +|`MK_C_INTERVAL_1` |16 |Time between cursor movements (`MS_ACL1`) | +|`MK_C_OFFSET_2` |32 |Cursor offset per movement (`MS_ACL2`) | +|`MK_C_INTERVAL_2` |16 |Time between cursor movements (`MS_ACL2`) | |`MK_W_OFFSET_UNMOD` |1 |Scroll steps per scroll action (unmodified)| |`MK_W_INTERVAL_UNMOD`|40 |Time between scroll steps (unmodified) | -|`MK_W_OFFSET_0` |1 |Scroll steps per scroll action (`KC_ACL0`) | -|`MK_W_INTERVAL_0` |360 |Time between scroll steps (`KC_ACL0`) | -|`MK_W_OFFSET_1` |1 |Scroll steps per scroll action (`KC_ACL1`) | -|`MK_W_INTERVAL_1` |120 |Time between scroll steps (`KC_ACL1`) | -|`MK_W_OFFSET_2` |1 |Scroll steps per scroll action (`KC_ACL2`) | -|`MK_W_INTERVAL_2` |20 |Time between scroll steps (`KC_ACL2`) | +|`MK_W_OFFSET_0` |1 |Scroll steps per scroll action (`MS_ACL0`) | +|`MK_W_INTERVAL_0` |360 |Time between scroll steps (`MS_ACL0`) | +|`MK_W_OFFSET_1` |1 |Scroll steps per scroll action (`MS_ACL1`) | +|`MK_W_INTERVAL_1` |120 |Time between scroll steps (`MS_ACL1`) | +|`MK_W_OFFSET_2` |1 |Scroll steps per scroll action (`MS_ACL2`) | +|`MK_W_INTERVAL_2` |20 |Time between scroll steps (`MS_ACL2`) | ### Combined mode -This mode functions like **Accelerated** mode, however, you can hold `KC_ACL0`, `KC_ACL1` and `KC_ACL2` +This mode functions like **Accelerated** mode, however, you can hold `MS_ACL0`, `MS_ACL1` and `MS_ACL2` to momentarily (while held) set the cursor and scroll speeds to constant speeds. When no acceleration keys are held, this mode is identical to **Accelerated** mode, and can be modified using all of the relevant settings. -* **KC_ACL0:** This acceleration sets your cursor to the slowest possible speed. This is useful for very +* **MS_ACL0:** This acceleration sets your cursor to the slowest possible speed. This is useful for very small and detailed movements of the cursor. -* **KC_ACL1:** This acceleration sets your cursor to half the maximum (user defined) speed. -* **KC_ACL2:** This acceleration sets your cursor to the maximum (computer defined) speed. This is +* **MS_ACL1:** This acceleration sets your cursor to half the maximum (user defined) speed. +* **MS_ACL2:** This acceleration sets your cursor to the maximum (computer defined) speed. This is useful for moving the cursor large distances without much accuracy. To use combined speed mode, you must at least define `MK_COMBINED` in your keymap’s `config.h` file: diff --git a/docs/features/repeat_key.md b/docs/features/repeat_key.md index 53495e0f4d..7f2bdc44e6 100644 --- a/docs/features/repeat_key.md +++ b/docs/features/repeat_key.md @@ -60,10 +60,10 @@ with mods, like Ctrl + Left ↔ Ctrl + Right Arrow. |`KC_UP` ↔ `KC_DOWN` | Up ↔ Down Arrow | |`KC_HOME` ↔ `KC_END` | Home ↔ End | |`KC_PGUP` ↔ `KC_PGDN` | Page Up ↔ Page Down | -|`KC_MS_L` ↔ `KC_MS_R` | Mouse Cursor Left ↔ Right | -|`KC_MS_U` ↔ `KC_MS_D` | Mouse Cursor Up ↔ Down | -|`KC_WH_L` ↔ `KC_WH_R` | Mouse Wheel Left ↔ Right | -|`KC_WH_U` ↔ `KC_WH_D` | Mouse Wheel Up ↔ Down | +|`MS_LEFT` ↔ `MS_RGHT` | Mouse Cursor Left ↔ Right | +|`MS_UP` ↔ `MS_DOWN` | Mouse Cursor Up ↔ Down | +|`MS_WHLL` ↔ `MS_WHLR` | Mouse Wheel Left ↔ Right | +|`MS_WHLU` ↔ `MS_WHLD` | Mouse Wheel Up ↔ Down | **Misc** diff --git a/docs/keycodes.md b/docs/keycodes.md index 4c91d98fa7..ea8b2e7b65 100644 --- a/docs/keycodes.md +++ b/docs/keycodes.md @@ -611,24 +611,27 @@ See also: [MIDI](features/midi) See also: [Mouse Keys](features/mouse_keys) -|Key |Aliases |Description | -|----------------|---------|---------------------------| -|`KC_MS_UP` |`KC_MS_U`|Mouse Cursor Up | -|`KC_MS_DOWN` |`KC_MS_D`|Mouse Cursor Down | -|`KC_MS_LEFT` |`KC_MS_L`|Mouse Cursor Left | -|`KC_MS_RIGHT` |`KC_MS_R`|Mouse Cursor Right | -|`KC_MS_BTN1` |`KC_BTN1`|Mouse Button 1 | -|`KC_MS_BTN2` |`KC_BTN2`|Mouse Button 2 | -|`KC_MS_BTN3` |`KC_BTN3`|Mouse Button 3 | -|`KC_MS_BTN4` |`KC_BTN4`|Mouse Button 4 | -|`KC_MS_BTN5` |`KC_BTN5`|Mouse Button 5 | -|`KC_MS_WH_UP` |`KC_WH_U`|Mouse Wheel Up | -|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down | -|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left | -|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right | -|`KC_MS_ACCEL0` |`KC_ACL0`|Set mouse acceleration to 0| -|`KC_MS_ACCEL1` |`KC_ACL1`|Set mouse acceleration to 1| -|`KC_MS_ACCEL2` |`KC_ACL2`|Set mouse acceleration to 2| +|Key |Aliases |Description | +|-------------------------|---------|---------------------------| +|`QK_MOUSE_CURSOR_UP` |`MS_UP` |Mouse cursor up | +|`QK_MOUSE_CURSOR_DOWN` |`MS_DOWN`|Mouse cursor down | +|`QK_MOUSE_CURSOR_LEFT` |`MS_LEFT`|Mouse cursor left | +|`QK_MOUSE_CURSOR_RIGHT` |`MS_RGHT`|Mouse cursor right | +|`QK_MOUSE_BUTTON_1` |`MS_BTN1`|Mouse button 1 | +|`QK_MOUSE_BUTTON_2` |`MS_BTN2`|Mouse button 2 | +|`QK_MOUSE_BUTTON_3` |`MS_BTN3`|Mouse button 3 | +|`QK_MOUSE_BUTTON_4` |`MS_BTN4`|Mouse button 4 | +|`QK_MOUSE_BUTTON_5` |`MS_BTN5`|Mouse button 5 | +|`QK_MOUSE_BUTTON_6` |`MS_BTN6`|Mouse button 6 | +|`QK_MOUSE_BUTTON_7` |`MS_BTN7`|Mouse button 7 | +|`QK_MOUSE_BUTTON_8` |`MS_BTN8`|Mouse button 8 | +|`QK_MOUSE_WHEEL_UP` |`MS_WHLU`|Mouse wheel up | +|`QK_MOUSE_WHEEL_DOWN` |`MS_WHLD`|Mouse wheel down | +|`QK_MOUSE_WHEEL_LEFT` |`MS_WHLL`|Mouse wheel left | +|`QK_MOUSE_WHEEL_RIGHT` |`MS_WHLR`|Mouse wheel right | +|`QK_MOUSE_ACCELERATION_0`|`MS_ACL0`|Set mouse acceleration to 0| +|`QK_MOUSE_ACCELERATION_1`|`MS_ACL1`|Set mouse acceleration to 1| +|`QK_MOUSE_ACCELERATION_2`|`MS_ACL2`|Set mouse acceleration to 2| ## Modifiers {#modifiers} diff --git a/drivers/sensors/cirque_pinnacle_gestures.h b/drivers/sensors/cirque_pinnacle_gestures.h index d2aa206b2b..1412c86f7e 100644 --- a/drivers/sensors/cirque_pinnacle_gestures.h +++ b/drivers/sensors/cirque_pinnacle_gestures.h @@ -28,7 +28,7 @@ typedef struct { # ifndef CIRQUE_PINNACLE_TAPPING_TERM # include "action.h" # include "action_tapping.h" -# define CIRQUE_PINNACLE_TAPPING_TERM GET_TAPPING_TERM(KC_BTN1, &(keyrecord_t){}) +# define CIRQUE_PINNACLE_TAPPING_TERM GET_TAPPING_TERM(QK_MOUSE_BUTTON_1, &(keyrecord_t){}) # endif # ifndef CIRQUE_PINNACLE_TOUCH_DEBOUNCE # define CIRQUE_PINNACLE_TOUCH_DEBOUNCE (CIRQUE_PINNACLE_TAPPING_TERM * 8) diff --git a/keyboards/cannonkeys/lib/satisfaction75/satisfaction_encoder.c b/keyboards/cannonkeys/lib/satisfaction75/satisfaction_encoder.c index aab005ebd8..7e0b82e9e7 100644 --- a/keyboards/cannonkeys/lib/satisfaction75/satisfaction_encoder.c +++ b/keyboards/cannonkeys/lib/satisfaction75/satisfaction_encoder.c @@ -101,7 +101,7 @@ uint16_t handle_encoder_clockwise(void){ mapped_code = KC_MEDIA_NEXT_TRACK; break; case ENC_MODE_SCROLL: - mapped_code = KC_WH_D; + mapped_code = QK_MOUSE_WHEEL_DOWN; break; #ifdef BACKLIGHT_ENABLE case ENC_MODE_BACKLIGHT: @@ -143,7 +143,7 @@ uint16_t handle_encoder_ccw(void){ mapped_code = KC_MEDIA_PREV_TRACK; break; case ENC_MODE_SCROLL: - mapped_code = KC_WH_U; + mapped_code = QK_MOUSE_WHEEL_UP; break; #ifdef BACKLIGHT_ENABLE case ENC_MODE_BACKLIGHT: @@ -186,7 +186,7 @@ uint16_t handle_encoder_press(void){ mapped_code = KC_MEDIA_PLAY_PAUSE; break; case ENC_MODE_SCROLL: - mapped_code = KC_BTN3; + mapped_code = QK_MOUSE_BUTTON_3; break; #ifdef BACKLIGHT_ENABLE case ENC_MODE_BACKLIGHT: diff --git a/keyboards/dichotomy/keymaps/default/keymap.c b/keyboards/dichotomy/keymaps/default/keymap.c index b83f7b82e9..b92beb73cc 100755 --- a/keyboards/dichotomy/keymaps/default/keymap.c +++ b/keyboards/dichotomy/keymaps/default/keymap.c @@ -28,9 +28,9 @@ enum dichotomy_keycodes NUMKEY, SFTKEY, MOUKEY, - MS_BTN1, - MS_BTN2, - MS_BTN3 + CK_MSE1, + CK_MSE2, + CK_MSE3 }; #define CUSTOM_LONGPRESS 150 @@ -46,7 +46,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { NUMKEY, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, CK_QE, SFTKEY, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, MOUKEY, KC_LCTL, KC_LALT, KC_LGUI, KC_RGUI, KC_RALT, KC_RCTL, - MS_BTN3, KC_LBRC, KC_LPRN, KC_SPC, KC_SPC, KC_RPRN, KC_RBRC, MS_BTN3 + CK_MSE3, KC_LBRC, KC_LPRN, KC_SPC, KC_SPC, KC_RPRN, KC_RBRC, CK_MSE3 ), [_SF] = LAYOUT( /* Shifted layout, small changes (because angle brackets have been moved to thumb cluster buttons) */ @@ -75,7 +75,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { [_MS] = LAYOUT( /* Mouse layer, including buttons for clicking. */ _______, _______, _______, _______, _______, _______, KC_VOLU, KC_HOME, KC_PGUP, _______, _______, _______, - _______, _______, _______, _______, _______, _______, _______, MS_BTN1, MS_BTN2, _______, _______, _______, + _______, _______, _______, _______, _______, _______, _______, CK_MSE1, CK_MSE2, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_VOLD, KC_END, KC_PGDN, _______, _______, _______, _______, _______, _______, _______, KC_UP, _______, _______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_RGHT, _______ @@ -311,7 +311,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { break; //mouse buttons, for 1-3, to update the mouse report: - case MS_BTN1: + case CK_MSE1: currentReport = pointing_device_get_report(); if (record->event.pressed) { if (shift_held && shift_suspended){ @@ -327,7 +327,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { pointing_device_set_report(currentReport); returnVal = false; break; - case MS_BTN2: + case CK_MSE2: currentReport = pointing_device_get_report(); if (record->event.pressed) { if (shift_held && shift_suspended){ @@ -343,7 +343,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { pointing_device_set_report(currentReport); returnVal = false; break; - case MS_BTN3: + case CK_MSE3: currentReport = pointing_device_get_report(); if (record->event.pressed) { if (shift_held && shift_suspended){ diff --git a/quantum/action.c b/quantum/action.c index 74ef55e5eb..a39631ba3e 100644 --- a/quantum/action.c +++ b/quantum/action.c @@ -329,7 +329,7 @@ void register_mouse(uint8_t mouse_keycode, bool pressed) { // should mousekeys send report, or does something else handle this? switch (mouse_keycode) { # if defined(PS2_MOUSE_ENABLE) || defined(POINTING_DEVICE_ENABLE) - case KC_MS_BTN1 ... KC_MS_BTN8: + case QK_MOUSE_BUTTON_1 ... QK_MOUSE_BUTTON_8: // let pointing device handle the buttons // expand if/when it handles more of the code # if defined(POINTING_DEVICE_ENABLE) @@ -351,8 +351,8 @@ void register_mouse(uint8_t mouse_keycode, bool pressed) { #ifdef PS2_MOUSE_ENABLE // make sure that ps2 mouse has button report synced - if (KC_MS_BTN1 <= mouse_keycode && mouse_keycode <= KC_MS_BTN3) { - uint8_t tmp_button_msk = MOUSE_BTN_MASK(mouse_keycode - KC_MS_BTN1); + if (QK_MOUSE_BUTTON_1 <= mouse_keycode && mouse_keycode <= QK_MOUSE_BUTTON_3) { + uint8_t tmp_button_msk = MOUSE_BTN_MASK(mouse_keycode - QK_MOUSE_BUTTON_1); tp_buttons = pressed ? tp_buttons | tmp_button_msk : tp_buttons & ~tmp_button_msk; } #endif diff --git a/quantum/encoder.c b/quantum/encoder.c index 2ddbf3ee1e..27d7b1fc80 100644 --- a/quantum/encoder.c +++ b/quantum/encoder.c @@ -160,7 +160,7 @@ __attribute__((weak)) bool encoder_update_kb(uint8_t index, bool clockwise) { # if defined(EXTRAKEY_ENABLE) tap_code_delay(KC_VOLU, 10); # elif defined(MOUSEKEY_ENABLE) - tap_code_delay(KC_MS_WH_UP, 10); + tap_code_delay(QK_MOUSE_WHEEL_UP, 10); # else tap_code_delay(KC_PGDN, 10); # endif @@ -168,7 +168,7 @@ __attribute__((weak)) bool encoder_update_kb(uint8_t index, bool clockwise) { # if defined(EXTRAKEY_ENABLE) tap_code_delay(KC_VOLD, 10); # elif defined(MOUSEKEY_ENABLE) - tap_code_delay(KC_MS_WH_DOWN, 10); + tap_code_delay(QK_MOUSE_WHEEL_DOWN, 10); # else tap_code_delay(KC_PGUP, 10); # endif diff --git a/quantum/keycode.h b/quantum/keycode.h index df1452d296..4ff6894a01 100644 --- a/quantum/keycode.h +++ b/quantum/keycode.h @@ -29,10 +29,10 @@ along with this program. If not, see . #define IS_ANY(code) (KC_A <= (code) && (code) <= 0xFF) #define IS_MOUSEKEY(code) IS_MOUSE_KEYCODE(code) -#define IS_MOUSEKEY_MOVE(code) (KC_MS_UP <= (code) && (code) <= KC_MS_RIGHT) -#define IS_MOUSEKEY_BUTTON(code) (KC_MS_BTN1 <= (code) && (code) <= KC_MS_BTN8) -#define IS_MOUSEKEY_WHEEL(code) (KC_MS_WH_UP <= (code) && (code) <= KC_MS_WH_RIGHT) -#define IS_MOUSEKEY_ACCEL(code) (KC_MS_ACCEL0 <= (code) && (code) <= KC_MS_ACCEL2) +#define IS_MOUSEKEY_MOVE(code) (QK_MOUSE_CURSOR_UP <= (code) && (code) <= QK_MOUSE_CURSOR_RIGHT) +#define IS_MOUSEKEY_BUTTON(code) (QK_MOUSE_BUTTON_1 <= (code) && (code) <= QK_MOUSE_BUTTON_8) +#define IS_MOUSEKEY_WHEEL(code) (QK_MOUSE_WHEEL_UP <= (code) && (code) <= QK_MOUSE_WHEEL_RIGHT) +#define IS_MOUSEKEY_ACCEL(code) (QK_MOUSE_ACCELERATION_0 <= (code) && (code) <= QK_MOUSE_ACCELERATION_2) #define MOD_BIT(code) (1 << ((code)&0x07)) diff --git a/quantum/keycodes.h b/quantum/keycodes.h index c92028ab43..f461e4a586 100644 --- a/quantum/keycodes.h +++ b/quantum/keycodes.h @@ -283,25 +283,25 @@ enum qk_keycode_defines { KC_ASSISTANT = 0x00C0, KC_MISSION_CONTROL = 0x00C1, KC_LAUNCHPAD = 0x00C2, - KC_MS_UP = 0x00CD, - KC_MS_DOWN = 0x00CE, - KC_MS_LEFT = 0x00CF, - KC_MS_RIGHT = 0x00D0, - KC_MS_BTN1 = 0x00D1, - KC_MS_BTN2 = 0x00D2, - KC_MS_BTN3 = 0x00D3, - KC_MS_BTN4 = 0x00D4, - KC_MS_BTN5 = 0x00D5, - KC_MS_BTN6 = 0x00D6, - KC_MS_BTN7 = 0x00D7, - KC_MS_BTN8 = 0x00D8, - KC_MS_WH_UP = 0x00D9, - KC_MS_WH_DOWN = 0x00DA, - KC_MS_WH_LEFT = 0x00DB, - KC_MS_WH_RIGHT = 0x00DC, - KC_MS_ACCEL0 = 0x00DD, - KC_MS_ACCEL1 = 0x00DE, - KC_MS_ACCEL2 = 0x00DF, + QK_MOUSE_CURSOR_UP = 0x00CD, + QK_MOUSE_CURSOR_DOWN = 0x00CE, + QK_MOUSE_CURSOR_LEFT = 0x00CF, + QK_MOUSE_CURSOR_RIGHT = 0x00D0, + QK_MOUSE_BUTTON_1 = 0x00D1, + QK_MOUSE_BUTTON_2 = 0x00D2, + QK_MOUSE_BUTTON_3 = 0x00D3, + QK_MOUSE_BUTTON_4 = 0x00D4, + QK_MOUSE_BUTTON_5 = 0x00D5, + QK_MOUSE_BUTTON_6 = 0x00D6, + QK_MOUSE_BUTTON_7 = 0x00D7, + QK_MOUSE_BUTTON_8 = 0x00D8, + QK_MOUSE_WHEEL_UP = 0x00D9, + QK_MOUSE_WHEEL_DOWN = 0x00DA, + QK_MOUSE_WHEEL_LEFT = 0x00DB, + QK_MOUSE_WHEEL_RIGHT = 0x00DC, + QK_MOUSE_ACCELERATION_0 = 0x00DD, + QK_MOUSE_ACCELERATION_1 = 0x00DE, + QK_MOUSE_ACCELERATION_2 = 0x00DF, KC_LEFT_CTRL = 0x00E0, KC_LEFT_SHIFT = 0x00E1, KC_LEFT_ALT = 0x00E2, @@ -926,25 +926,25 @@ enum qk_keycode_defines { KC_ASST = KC_ASSISTANT, KC_MCTL = KC_MISSION_CONTROL, KC_LPAD = KC_LAUNCHPAD, - KC_MS_U = KC_MS_UP, - KC_MS_D = KC_MS_DOWN, - KC_MS_L = KC_MS_LEFT, - KC_MS_R = KC_MS_RIGHT, - KC_BTN1 = KC_MS_BTN1, - KC_BTN2 = KC_MS_BTN2, - KC_BTN3 = KC_MS_BTN3, - KC_BTN4 = KC_MS_BTN4, - KC_BTN5 = KC_MS_BTN5, - KC_BTN6 = KC_MS_BTN6, - KC_BTN7 = KC_MS_BTN7, - KC_BTN8 = KC_MS_BTN8, - KC_WH_U = KC_MS_WH_UP, - KC_WH_D = KC_MS_WH_DOWN, - KC_WH_L = KC_MS_WH_LEFT, - KC_WH_R = KC_MS_WH_RIGHT, - KC_ACL0 = KC_MS_ACCEL0, - KC_ACL1 = KC_MS_ACCEL1, - KC_ACL2 = KC_MS_ACCEL2, + MS_UP = QK_MOUSE_CURSOR_UP, + MS_DOWN = QK_MOUSE_CURSOR_DOWN, + MS_LEFT = QK_MOUSE_CURSOR_LEFT, + MS_RGHT = QK_MOUSE_CURSOR_RIGHT, + MS_BTN1 = QK_MOUSE_BUTTON_1, + MS_BTN2 = QK_MOUSE_BUTTON_2, + MS_BTN3 = QK_MOUSE_BUTTON_3, + MS_BTN4 = QK_MOUSE_BUTTON_4, + MS_BTN5 = QK_MOUSE_BUTTON_5, + MS_BTN6 = QK_MOUSE_BUTTON_6, + MS_BTN7 = QK_MOUSE_BUTTON_7, + MS_BTN8 = QK_MOUSE_BUTTON_8, + MS_WHLU = QK_MOUSE_WHEEL_UP, + MS_WHLD = QK_MOUSE_WHEEL_DOWN, + MS_WHLL = QK_MOUSE_WHEEL_LEFT, + MS_WHLR = QK_MOUSE_WHEEL_RIGHT, + MS_ACL0 = QK_MOUSE_ACCELERATION_0, + MS_ACL1 = QK_MOUSE_ACCELERATION_1, + MS_ACL2 = QK_MOUSE_ACCELERATION_2, KC_LCTL = KC_LEFT_CTRL, KC_LSFT = KC_LEFT_SHIFT, KC_LALT = KC_LEFT_ALT, @@ -1457,7 +1457,7 @@ enum qk_keycode_defines { #define IS_BASIC_KEYCODE(code) ((code) >= KC_A && (code) <= KC_EXSEL) #define IS_SYSTEM_KEYCODE(code) ((code) >= KC_SYSTEM_POWER && (code) <= KC_SYSTEM_WAKE) #define IS_CONSUMER_KEYCODE(code) ((code) >= KC_AUDIO_MUTE && (code) <= KC_LAUNCHPAD) -#define IS_MOUSE_KEYCODE(code) ((code) >= KC_MS_UP && (code) <= KC_MS_ACCEL2) +#define IS_MOUSE_KEYCODE(code) ((code) >= QK_MOUSE_CURSOR_UP && (code) <= QK_MOUSE_ACCELERATION_2) #define IS_MODIFIER_KEYCODE(code) ((code) >= KC_LEFT_CTRL && (code) <= KC_RIGHT_GUI) #define IS_SWAP_HANDS_KEYCODE(code) ((code) >= QK_SWAP_HANDS_TOGGLE && (code) <= QK_SWAP_HANDS_ONE_SHOT) #define IS_MAGIC_KEYCODE(code) ((code) >= QK_MAGIC_SWAP_CONTROL_CAPS_LOCK && (code) <= QK_MAGIC_TOGGLE_ESCAPE_CAPS_LOCK) @@ -1482,7 +1482,7 @@ enum qk_keycode_defines { #define BASIC_KEYCODE_RANGE KC_A ... KC_EXSEL #define SYSTEM_KEYCODE_RANGE KC_SYSTEM_POWER ... KC_SYSTEM_WAKE #define CONSUMER_KEYCODE_RANGE KC_AUDIO_MUTE ... KC_LAUNCHPAD -#define MOUSE_KEYCODE_RANGE KC_MS_UP ... KC_MS_ACCEL2 +#define MOUSE_KEYCODE_RANGE QK_MOUSE_CURSOR_UP ... QK_MOUSE_ACCELERATION_2 #define MODIFIER_KEYCODE_RANGE KC_LEFT_CTRL ... KC_RIGHT_GUI #define SWAP_HANDS_KEYCODE_RANGE QK_SWAP_HANDS_TOGGLE ... QK_SWAP_HANDS_ONE_SHOT #define MAGIC_KEYCODE_RANGE QK_MAGIC_SWAP_CONTROL_CAPS_LOCK ... QK_MAGIC_TOGGLE_ESCAPE_CAPS_LOCK diff --git a/quantum/mousekey.c b/quantum/mousekey.c index 3910811752..8683cfdffa 100644 --- a/quantum/mousekey.c +++ b/quantum/mousekey.c @@ -407,42 +407,42 @@ void mousekey_on(uint8_t code) { # ifdef MOUSEKEY_INERTIA // initial keypress sets impulse and activates first frame of movement - if ((code == KC_MS_UP) || (code == KC_MS_DOWN)) { - mousekey_y_dir = (code == KC_MS_DOWN) ? 1 : -1; + if ((code == QK_MOUSE_CURSOR_UP) || (code == QK_MOUSE_CURSOR_DOWN)) { + mousekey_y_dir = (code == QK_MOUSE_CURSOR_DOWN) ? 1 : -1; if (mousekey_frame < 2) mouse_report.y = move_unit(1); - } else if ((code == KC_MS_LEFT) || (code == KC_MS_RIGHT)) { - mousekey_x_dir = (code == KC_MS_RIGHT) ? 1 : -1; + } else if ((code == QK_MOUSE_CURSOR_LEFT) || (code == QK_MOUSE_CURSOR_RIGHT)) { + mousekey_x_dir = (code == QK_MOUSE_CURSOR_RIGHT) ? 1 : -1; if (mousekey_frame < 2) mouse_report.x = move_unit(0); } # else // no inertia - if (code == KC_MS_UP) + if (code == QK_MOUSE_CURSOR_UP) mouse_report.y = move_unit() * -1; - else if (code == KC_MS_DOWN) + else if (code == QK_MOUSE_CURSOR_DOWN) mouse_report.y = move_unit(); - else if (code == KC_MS_LEFT) + else if (code == QK_MOUSE_CURSOR_LEFT) mouse_report.x = move_unit() * -1; - else if (code == KC_MS_RIGHT) + else if (code == QK_MOUSE_CURSOR_RIGHT) mouse_report.x = move_unit(); # endif // inertia or not - else if (code == KC_MS_WH_UP) + else if (code == QK_MOUSE_WHEEL_UP) mouse_report.v = wheel_unit(); - else if (code == KC_MS_WH_DOWN) + else if (code == QK_MOUSE_WHEEL_DOWN) mouse_report.v = wheel_unit() * -1; - else if (code == KC_MS_WH_LEFT) + else if (code == QK_MOUSE_WHEEL_LEFT) mouse_report.h = wheel_unit() * -1; - else if (code == KC_MS_WH_RIGHT) + else if (code == QK_MOUSE_WHEEL_RIGHT) mouse_report.h = wheel_unit(); else if (IS_MOUSEKEY_BUTTON(code)) - mouse_report.buttons |= 1 << (code - KC_MS_BTN1); - else if (code == KC_MS_ACCEL0) + mouse_report.buttons |= 1 << (code - QK_MOUSE_BUTTON_1); + else if (code == QK_MOUSE_ACCELERATION_0) mousekey_accel |= (1 << 0); - else if (code == KC_MS_ACCEL1) + else if (code == QK_MOUSE_ACCELERATION_1) mousekey_accel |= (1 << 1); - else if (code == KC_MS_ACCEL2) + else if (code == QK_MOUSE_ACCELERATION_2) mousekey_accel |= (1 << 2); } @@ -450,43 +450,43 @@ void mousekey_off(uint8_t code) { # ifdef MOUSEKEY_INERTIA // key release clears impulse unless opposite direction is held - if ((code == KC_MS_UP) && (mousekey_y_dir < 1)) + if ((code == QK_MOUSE_CURSOR_UP) && (mousekey_y_dir < 1)) mousekey_y_dir = 0; - else if ((code == KC_MS_DOWN) && (mousekey_y_dir > -1)) + else if ((code == QK_MOUSE_CURSOR_DOWN) && (mousekey_y_dir > -1)) mousekey_y_dir = 0; - else if ((code == KC_MS_LEFT) && (mousekey_x_dir < 1)) + else if ((code == QK_MOUSE_CURSOR_LEFT) && (mousekey_x_dir < 1)) mousekey_x_dir = 0; - else if ((code == KC_MS_RIGHT) && (mousekey_x_dir > -1)) + else if ((code == QK_MOUSE_CURSOR_RIGHT) && (mousekey_x_dir > -1)) mousekey_x_dir = 0; # else // no inertia - if (code == KC_MS_UP && mouse_report.y < 0) + if (code == QK_MOUSE_CURSOR_UP && mouse_report.y < 0) mouse_report.y = 0; - else if (code == KC_MS_DOWN && mouse_report.y > 0) + else if (code == QK_MOUSE_CURSOR_DOWN && mouse_report.y > 0) mouse_report.y = 0; - else if (code == KC_MS_LEFT && mouse_report.x < 0) + else if (code == QK_MOUSE_CURSOR_LEFT && mouse_report.x < 0) mouse_report.x = 0; - else if (code == KC_MS_RIGHT && mouse_report.x > 0) + else if (code == QK_MOUSE_CURSOR_RIGHT && mouse_report.x > 0) mouse_report.x = 0; # endif // inertia or not - else if (code == KC_MS_WH_UP && mouse_report.v > 0) + else if (code == QK_MOUSE_WHEEL_UP && mouse_report.v > 0) mouse_report.v = 0; - else if (code == KC_MS_WH_DOWN && mouse_report.v < 0) + else if (code == QK_MOUSE_WHEEL_DOWN && mouse_report.v < 0) mouse_report.v = 0; - else if (code == KC_MS_WH_LEFT && mouse_report.h < 0) + else if (code == QK_MOUSE_WHEEL_LEFT && mouse_report.h < 0) mouse_report.h = 0; - else if (code == KC_MS_WH_RIGHT && mouse_report.h > 0) + else if (code == QK_MOUSE_WHEEL_RIGHT && mouse_report.h > 0) mouse_report.h = 0; else if (IS_MOUSEKEY_BUTTON(code)) - mouse_report.buttons &= ~(1 << (code - KC_MS_BTN1)); - else if (code == KC_MS_ACCEL0) + mouse_report.buttons &= ~(1 << (code - QK_MOUSE_BUTTON_1)); + else if (code == QK_MOUSE_ACCELERATION_0) mousekey_accel &= ~(1 << 0); - else if (code == KC_MS_ACCEL1) + else if (code == QK_MOUSE_ACCELERATION_1) mousekey_accel &= ~(1 << 1); - else if (code == KC_MS_ACCEL2) + else if (code == QK_MOUSE_ACCELERATION_2) mousekey_accel &= ~(1 << 2); if (mouse_report.x == 0 && mouse_report.y == 0) { mousekey_repeat = 0; @@ -568,29 +568,29 @@ void mousekey_on(uint8_t code) { uint16_t const c_offset = c_offsets[mk_speed]; uint16_t const w_offset = w_offsets[mk_speed]; uint8_t const old_speed = mk_speed; - if (code == KC_MS_UP) + if (code == QK_MOUSE_CURSOR_UP) mouse_report.y = c_offset * -1; - else if (code == KC_MS_DOWN) + else if (code == QK_MOUSE_CURSOR_DOWN) mouse_report.y = c_offset; - else if (code == KC_MS_LEFT) + else if (code == QK_MOUSE_CURSOR_LEFT) mouse_report.x = c_offset * -1; - else if (code == KC_MS_RIGHT) + else if (code == QK_MOUSE_CURSOR_RIGHT) mouse_report.x = c_offset; - else if (code == KC_MS_WH_UP) + else if (code == QK_MOUSE_WHEEL_UP) mouse_report.v = w_offset; - else if (code == KC_MS_WH_DOWN) + else if (code == QK_MOUSE_WHEEL_DOWN) mouse_report.v = w_offset * -1; - else if (code == KC_MS_WH_LEFT) + else if (code == QK_MOUSE_WHEEL_LEFT) mouse_report.h = w_offset * -1; - else if (code == KC_MS_WH_RIGHT) + else if (code == QK_MOUSE_WHEEL_RIGHT) mouse_report.h = w_offset; else if (IS_MOUSEKEY_BUTTON(code)) - mouse_report.buttons |= 1 << (code - KC_MS_BTN1); - else if (code == KC_MS_ACCEL0) + mouse_report.buttons |= 1 << (code - QK_MOUSE_BUTTON_1); + else if (code == QK_MOUSE_ACCELERATION_0) mk_speed = mkspd_0; - else if (code == KC_MS_ACCEL1) + else if (code == QK_MOUSE_ACCELERATION_1) mk_speed = mkspd_1; - else if (code == KC_MS_ACCEL2) + else if (code == QK_MOUSE_ACCELERATION_2) mk_speed = mkspd_2; if (mk_speed != old_speed) adjust_speed(); } @@ -599,30 +599,30 @@ void mousekey_off(uint8_t code) { # ifdef MK_MOMENTARY_ACCEL uint8_t const old_speed = mk_speed; # endif - if (code == KC_MS_UP && mouse_report.y < 0) + if (code == QK_MOUSE_CURSOR_UP && mouse_report.y < 0) mouse_report.y = 0; - else if (code == KC_MS_DOWN && mouse_report.y > 0) + else if (code == QK_MOUSE_CURSOR_DOWN && mouse_report.y > 0) mouse_report.y = 0; - else if (code == KC_MS_LEFT && mouse_report.x < 0) + else if (code == QK_MOUSE_CURSOR_LEFT && mouse_report.x < 0) mouse_report.x = 0; - else if (code == KC_MS_RIGHT && mouse_report.x > 0) + else if (code == QK_MOUSE_CURSOR_RIGHT && mouse_report.x > 0) mouse_report.x = 0; - else if (code == KC_MS_WH_UP && mouse_report.v > 0) + else if (code == QK_MOUSE_WHEEL_UP && mouse_report.v > 0) mouse_report.v = 0; - else if (code == KC_MS_WH_DOWN && mouse_report.v < 0) + else if (code == QK_MOUSE_WHEEL_DOWN && mouse_report.v < 0) mouse_report.v = 0; - else if (code == KC_MS_WH_LEFT && mouse_report.h < 0) + else if (code == QK_MOUSE_WHEEL_LEFT && mouse_report.h < 0) mouse_report.h = 0; - else if (code == KC_MS_WH_RIGHT && mouse_report.h > 0) + else if (code == QK_MOUSE_WHEEL_RIGHT && mouse_report.h > 0) mouse_report.h = 0; else if (IS_MOUSEKEY_BUTTON(code)) - mouse_report.buttons &= ~(1 << (code - KC_MS_BTN1)); + mouse_report.buttons &= ~(1 << (code - QK_MOUSE_BUTTON_1)); # ifdef MK_MOMENTARY_ACCEL - else if (code == KC_MS_ACCEL0) + else if (code == QK_MOUSE_ACCELERATION_0) mk_speed = mkspd_DEFAULT; - else if (code == KC_MS_ACCEL1) + else if (code == QK_MOUSE_ACCELERATION_1) mk_speed = mkspd_DEFAULT; - else if (code == KC_MS_ACCEL2) + else if (code == QK_MOUSE_ACCELERATION_2) mk_speed = mkspd_DEFAULT; if (mk_speed != old_speed) adjust_speed(); # endif diff --git a/quantum/pointing_device/pointing_device.c b/quantum/pointing_device/pointing_device.c index 4682aceb14..74ce9108a9 100644 --- a/quantum/pointing_device/pointing_device.c +++ b/quantum/pointing_device/pointing_device.c @@ -498,7 +498,7 @@ __attribute__((weak)) report_mouse_t pointing_device_task_combined_user(report_m __attribute__((weak)) void pointing_device_keycode_handler(uint16_t keycode, bool pressed) { if IS_MOUSEKEY_BUTTON (keycode) { - local_mouse_report.buttons = pointing_device_handle_buttons(local_mouse_report.buttons, pressed, keycode - KC_MS_BTN1); + local_mouse_report.buttons = pointing_device_handle_buttons(local_mouse_report.buttons, pressed, keycode - QK_MOUSE_BUTTON_1); pointing_device_send(); } } diff --git a/quantum/pointing_device/pointing_device_auto_mouse.h b/quantum/pointing_device/pointing_device_auto_mouse.h index a596c065a3..2c0d4d1043 100644 --- a/quantum/pointing_device/pointing_device_auto_mouse.h +++ b/quantum/pointing_device/pointing_device_auto_mouse.h @@ -37,7 +37,7 @@ # define AUTO_MOUSE_TIME 650 #endif #ifndef AUTO_MOUSE_DELAY -# define AUTO_MOUSE_DELAY GET_TAPPING_TERM(KC_MS_BTN1, &(keyrecord_t){}) +# define AUTO_MOUSE_DELAY GET_TAPPING_TERM(QK_MOUSE_BUTTON_1, &(keyrecord_t){}) #endif #ifndef AUTO_MOUSE_DEBOUNCE # define AUTO_MOUSE_DEBOUNCE 25 diff --git a/quantum/quantum_keycodes_legacy.h b/quantum/quantum_keycodes_legacy.h index 6ea5e13f3a..e1562077e5 100644 --- a/quantum/quantum_keycodes_legacy.h +++ b/quantum/quantum_keycodes_legacy.h @@ -16,3 +16,42 @@ #define RGB_VAD QK_UNDERGLOW_VALUE_DOWN #define RGB_SPI QK_UNDERGLOW_SPEED_UP #define RGB_SPD QK_UNDERGLOW_SPEED_DOWN + +#define KC_MS_UP QK_MOUSE_CURSOR_UP +#define KC_MS_U QK_MOUSE_CURSOR_UP +#define KC_MS_DOWN QK_MOUSE_CURSOR_DOWN +#define KC_MS_D QK_MOUSE_CURSOR_DOWN +#define KC_MS_LEFT QK_MOUSE_CURSOR_LEFT +#define KC_MS_L QK_MOUSE_CURSOR_LEFT +#define KC_MS_RIGHT QK_MOUSE_CURSOR_RIGHT +#define KC_MS_R QK_MOUSE_CURSOR_RIGHT +#define KC_MS_BTN1 QK_MOUSE_BUTTON_1 +#define KC_BTN1 QK_MOUSE_BUTTON_1 +#define KC_MS_BTN2 QK_MOUSE_BUTTON_2 +#define KC_BTN2 QK_MOUSE_BUTTON_2 +#define KC_MS_BTN3 QK_MOUSE_BUTTON_3 +#define KC_BTN3 QK_MOUSE_BUTTON_3 +#define KC_MS_BTN4 QK_MOUSE_BUTTON_4 +#define KC_BTN4 QK_MOUSE_BUTTON_4 +#define KC_MS_BTN5 QK_MOUSE_BUTTON_5 +#define KC_BTN5 QK_MOUSE_BUTTON_5 +#define KC_MS_BTN6 QK_MOUSE_BUTTON_6 +#define KC_BTN6 QK_MOUSE_BUTTON_6 +#define KC_MS_BTN7 QK_MOUSE_BUTTON_7 +#define KC_BTN7 QK_MOUSE_BUTTON_7 +#define KC_MS_BTN8 QK_MOUSE_BUTTON_8 +#define KC_BTN8 QK_MOUSE_BUTTON_8 +#define KC_MS_WH_UP QK_MOUSE_WHEEL_UP +#define KC_WH_U QK_MOUSE_WHEEL_UP +#define KC_MS_WH_DOWN QK_MOUSE_WHEEL_DOWN +#define KC_WH_D QK_MOUSE_WHEEL_DOWN +#define KC_MS_WH_LEFT QK_MOUSE_WHEEL_LEFT +#define KC_WH_L QK_MOUSE_WHEEL_LEFT +#define KC_MS_WH_RIGHT QK_MOUSE_WHEEL_RIGHT +#define KC_WH_R QK_MOUSE_WHEEL_RIGHT +#define KC_MS_ACCEL0 QK_MOUSE_ACCELERATION_0 +#define KC_ACL0 QK_MOUSE_ACCELERATION_0 +#define KC_MS_ACCEL1 QK_MOUSE_ACCELERATION_1 +#define KC_ACL1 QK_MOUSE_ACCELERATION_1 +#define KC_MS_ACCEL2 QK_MOUSE_ACCELERATION_2 +#define KC_ACL2 QK_MOUSE_ACCELERATION_2 diff --git a/quantum/repeat_key.c b/quantum/repeat_key.c index 4567428723..56f242f8b8 100644 --- a/quantum/repeat_key.c +++ b/quantum/repeat_key.c @@ -220,10 +220,10 @@ uint16_t get_alt_repeat_key_keycode(void) { {KC_BRIU, KC_BRID}, // Brightness Up / Down. #endif // EXTRAKEY_ENABLE #ifdef MOUSEKEY_ENABLE - {KC_MS_L, KC_MS_R}, // Mouse Cursor Left / Right. - {KC_MS_U, KC_MS_D}, // Mouse Cursor Up / Down. - {KC_WH_L, KC_WH_R}, // Mouse Wheel Left / Right. - {KC_WH_U, KC_WH_D}, // Mouse Wheel Up / Down. + {MS_LEFT, MS_RGHT}, // Mouse Cursor Left / Right. + {MS_UP, MS_DOWN}, // Mouse Cursor Up / Down. + {MS_WHLL, MS_WHLR}, // Mouse Wheel Left / Right. + {MS_WHLU, MS_WHLD}, // Mouse Wheel Up / Down. #endif // MOUSEKEY_ENABLE }; // clang-format on diff --git a/tests/test_common/keycode_table.cpp b/tests/test_common/keycode_table.cpp index 18dd536027..4c28ab4d20 100644 --- a/tests/test_common/keycode_table.cpp +++ b/tests/test_common/keycode_table.cpp @@ -225,25 +225,25 @@ std::map KEYCODE_ID_TABLE = { {KC_ASSISTANT, "KC_ASSISTANT"}, {KC_MISSION_CONTROL, "KC_MISSION_CONTROL"}, {KC_LAUNCHPAD, "KC_LAUNCHPAD"}, - {KC_MS_UP, "KC_MS_UP"}, - {KC_MS_DOWN, "KC_MS_DOWN"}, - {KC_MS_LEFT, "KC_MS_LEFT"}, - {KC_MS_RIGHT, "KC_MS_RIGHT"}, - {KC_MS_BTN1, "KC_MS_BTN1"}, - {KC_MS_BTN2, "KC_MS_BTN2"}, - {KC_MS_BTN3, "KC_MS_BTN3"}, - {KC_MS_BTN4, "KC_MS_BTN4"}, - {KC_MS_BTN5, "KC_MS_BTN5"}, - {KC_MS_BTN6, "KC_MS_BTN6"}, - {KC_MS_BTN7, "KC_MS_BTN7"}, - {KC_MS_BTN8, "KC_MS_BTN8"}, - {KC_MS_WH_UP, "KC_MS_WH_UP"}, - {KC_MS_WH_DOWN, "KC_MS_WH_DOWN"}, - {KC_MS_WH_LEFT, "KC_MS_WH_LEFT"}, - {KC_MS_WH_RIGHT, "KC_MS_WH_RIGHT"}, - {KC_MS_ACCEL0, "KC_MS_ACCEL0"}, - {KC_MS_ACCEL1, "KC_MS_ACCEL1"}, - {KC_MS_ACCEL2, "KC_MS_ACCEL2"}, + {QK_MOUSE_CURSOR_UP, "QK_MOUSE_CURSOR_UP"}, + {QK_MOUSE_CURSOR_DOWN, "QK_MOUSE_CURSOR_DOWN"}, + {QK_MOUSE_CURSOR_LEFT, "QK_MOUSE_CURSOR_LEFT"}, + {QK_MOUSE_CURSOR_RIGHT, "QK_MOUSE_CURSOR_RIGHT"}, + {QK_MOUSE_BUTTON_1, "QK_MOUSE_BUTTON_1"}, + {QK_MOUSE_BUTTON_2, "QK_MOUSE_BUTTON_2"}, + {QK_MOUSE_BUTTON_3, "QK_MOUSE_BUTTON_3"}, + {QK_MOUSE_BUTTON_4, "QK_MOUSE_BUTTON_4"}, + {QK_MOUSE_BUTTON_5, "QK_MOUSE_BUTTON_5"}, + {QK_MOUSE_BUTTON_6, "QK_MOUSE_BUTTON_6"}, + {QK_MOUSE_BUTTON_7, "QK_MOUSE_BUTTON_7"}, + {QK_MOUSE_BUTTON_8, "QK_MOUSE_BUTTON_8"}, + {QK_MOUSE_WHEEL_UP, "QK_MOUSE_WHEEL_UP"}, + {QK_MOUSE_WHEEL_DOWN, "QK_MOUSE_WHEEL_DOWN"}, + {QK_MOUSE_WHEEL_LEFT, "QK_MOUSE_WHEEL_LEFT"}, + {QK_MOUSE_WHEEL_RIGHT, "QK_MOUSE_WHEEL_RIGHT"}, + {QK_MOUSE_ACCELERATION_0, "QK_MOUSE_ACCELERATION_0"}, + {QK_MOUSE_ACCELERATION_1, "QK_MOUSE_ACCELERATION_1"}, + {QK_MOUSE_ACCELERATION_2, "QK_MOUSE_ACCELERATION_2"}, {KC_LEFT_CTRL, "KC_LEFT_CTRL"}, {KC_LEFT_SHIFT, "KC_LEFT_SHIFT"}, {KC_LEFT_ALT, "KC_LEFT_ALT"}, -- cgit v1.2.3 From 4ae0ca5a11c475ee49bbce13d29edbf9bd6fc636 Mon Sep 17 00:00:00 2001 From: Nick Brassel Date: Sat, 6 Jul 2024 09:57:54 +1000 Subject: Tap dance introspection (#24049) --- quantum/keymap_introspection.c | 23 +++++++++++++++++++++++ quantum/keymap_introspection.h | 25 +++++++++++++++++++++++-- quantum/process_keycode/process_tap_dance.c | 12 +++++++++--- quantum/process_keycode/process_tap_dance.h | 4 +--- tests/tap_dance/examples.c | 3 ++- tests/tap_dance/tap_dance_layers/test.mk | 2 +- tests/tap_dance/test.mk | 3 +-- 7 files changed, 60 insertions(+), 12 deletions(-) (limited to 'quantum') diff --git a/quantum/keymap_introspection.c b/quantum/keymap_introspection.c index 71e3b429ea..4e95125335 100644 --- a/quantum/keymap_introspection.c +++ b/quantum/keymap_introspection.c @@ -109,3 +109,26 @@ __attribute__((weak)) combo_t* combo_get(uint16_t combo_idx) { } #endif // defined(COMBO_ENABLE) + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Tap Dance + +#if defined(TAP_DANCE_ENABLE) + +uint16_t tap_dance_count_raw(void) { + return sizeof(tap_dance_actions) / sizeof(tap_dance_action_t); +} + +uint16_t tap_dance_count(void) { + return tap_dance_count_raw(); +} + +tap_dance_action_t* tap_dance_get_raw(uint16_t tap_dance_idx) { + return &tap_dance_actions[tap_dance_idx]; +} + +tap_dance_action_t* tap_dance_get(uint16_t tap_dance_idx) { + return tap_dance_get_raw(tap_dance_idx); +} + +#endif // defined(TAP_DANCE_ENABLE) diff --git a/quantum/keymap_introspection.h b/quantum/keymap_introspection.h index f7516bf42a..bc4dd93b4c 100644 --- a/quantum/keymap_introspection.h +++ b/quantum/keymap_introspection.h @@ -61,9 +61,30 @@ uint16_t combo_count_raw(void); // Get the number of combos defined in the user's keymap, potentially stored dynamically uint16_t combo_count(void); -// Get the keycode for the encoder mapping location, stored in firmware rather than any other persistent storage +// Get the combo definition, stored in firmware rather than any other persistent storage combo_t* combo_get_raw(uint16_t combo_idx); -// Get the keycode for the encoder mapping location, potentially stored dynamically +// Get the combo definition, potentially stored dynamically combo_t* combo_get(uint16_t combo_idx); #endif // defined(COMBO_ENABLE) + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Tap Dance + +#if defined(TAP_DANCE_ENABLE) + +// Forward declaration of tap_dance_action_t so we don't need to deal with header reordering +struct tap_dance_action_t; +typedef struct tap_dance_action_t tap_dance_action_t; + +// Get the number of tap dances defined in the user's keymap, stored in firmware rather than any other persistent storage +uint16_t tap_dance_count_raw(void); +// Get the number of tap dances defined in the user's keymap, potentially stored dynamically +uint16_t tap_dance_count(void); + +// Get the tap dance definitions, stored in firmware rather than any other persistent storage +tap_dance_action_t* tap_dance_get_raw(uint16_t tap_dance_idx); +// Get the tap dance definitions, potentially stored dynamically +tap_dance_action_t* tap_dance_get(uint16_t tap_dance_idx); + +#endif // defined(TAP_DANCE_ENABLE) diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index ce3b8fc81f..11df62763d 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -21,6 +21,7 @@ #include "action_util.h" #include "timer.h" #include "wait.h" +#include "keymap_introspection.h" static uint16_t active_td; static uint16_t last_tap_time; @@ -133,7 +134,7 @@ bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) { if (!active_td || keycode == active_td) return false; - action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(active_td)]; + action = tap_dance_get(QK_TAP_DANCE_GET_INDEX(active_td)); action->state.interrupted = true; action->state.interrupting_keycode = keycode; process_tap_dance_action_on_dance_finished(action); @@ -150,11 +151,16 @@ bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) { } bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { + int td_index; tap_dance_action_t *action; switch (keycode) { case QK_TAP_DANCE ... QK_TAP_DANCE_MAX: - action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(keycode)]; + td_index = QK_TAP_DANCE_GET_INDEX(keycode); + if (td_index >= tap_dance_count()) { + return false; + } + action = tap_dance_get(td_index); action->state.pressed = record->event.pressed; if (record->event.pressed) { @@ -182,7 +188,7 @@ void tap_dance_task(void) { if (!active_td || timer_elapsed(last_tap_time) <= GET_TAPPING_TERM(active_td, &(keyrecord_t){})) return; - action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(active_td)]; + action = tap_dance_get(QK_TAP_DANCE_GET_INDEX(active_td)); if (!action->state.interrupted) { process_tap_dance_action_on_dance_finished(action); } diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index c0137c14a3..5cccbdf439 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -35,7 +35,7 @@ typedef struct { typedef void (*tap_dance_user_fn_t)(tap_dance_state_t *state, void *user_data); -typedef struct { +typedef struct tap_dance_action_t { tap_dance_state_t state; struct { tap_dance_user_fn_t on_each_tap; @@ -78,8 +78,6 @@ typedef struct { #define TD_INDEX(code) QK_TAP_DANCE_GET_INDEX(code) #define TAP_DANCE_KEYCODE(state) TD(((tap_dance_action_t *)state) - tap_dance_actions) -extern tap_dance_action_t tap_dance_actions[]; - void reset_tap_dance(tap_dance_state_t *state); /* To be used internally */ diff --git a/tests/tap_dance/examples.c b/tests/tap_dance/examples.c index 5377b397d3..4b6bdb2090 100644 --- a/tests/tap_dance/examples.c +++ b/tests/tap_dance/examples.c @@ -16,6 +16,7 @@ #include "quantum.h" #include "examples.h" +#include "keymap_introspection.h" // Example code from the tap dance documentation, adapted for testing @@ -83,7 +84,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case TD(CT_CLN): - action = &tap_dance_actions[QK_TAP_DANCE_GET_INDEX(keycode)]; + action = tap_dance_get(QK_TAP_DANCE_GET_INDEX(keycode)); if (!record->event.pressed && action->state.count && !action->state.finished) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)action->user_data; tap_code16(tap_hold->tap); diff --git a/tests/tap_dance/tap_dance_layers/test.mk b/tests/tap_dance/tap_dance_layers/test.mk index b4cdc9b088..a677fda648 100644 --- a/tests/tap_dance/tap_dance_layers/test.mk +++ b/tests/tap_dance/tap_dance_layers/test.mk @@ -7,4 +7,4 @@ TAP_DANCE_ENABLE = yes -SRC += tap_dance_defs.c +INTROSPECTION_KEYMAP_C = tap_dance_defs.c diff --git a/tests/tap_dance/test.mk b/tests/tap_dance/test.mk index 041d9b4dc9..0e727da9e8 100644 --- a/tests/tap_dance/test.mk +++ b/tests/tap_dance/test.mk @@ -18,5 +18,4 @@ # -------------------------------------------------------------------------------- TAP_DANCE_ENABLE = yes - -SRC += examples.c +INTROSPECTION_KEYMAP_C = examples.c -- cgit v1.2.3 From 1552cf2ddca1668c5230506de03e6b4a870f8961 Mon Sep 17 00:00:00 2001 From: Ryan Date: Sat, 13 Jul 2024 18:41:05 +1000 Subject: Update atomic GPIO macros in keyboard custom matrix (#23796) --- keyboards/argyle/matrix.c | 12 +++--- keyboards/gmmk/numpad/matrix.c | 16 +++---- keyboards/halfcliff/matrix.c | 20 ++++----- .../symmetric70_proto/matrix_debug/matrix.c | 20 ++++----- keyboards/keychron/c2_pro/matrix.c | 18 ++++---- keyboards/keychron/q10/matrix.c | 50 +++++++++++----------- keyboards/keychron/q12/matrix.c | 50 +++++++++++----------- keyboards/keychron/q1v2/matrix.c | 42 +++++++++--------- keyboards/keychron/q3/matrix.c | 42 +++++++++--------- keyboards/keychron/q5/matrix.c | 50 +++++++++++----------- keyboards/keychron/q6/matrix.c | 50 +++++++++++----------- keyboards/keychron/q65/matrix.c | 22 +++++----- keyboards/keychron/v1/matrix.c | 18 ++++---- keyboards/keychron/v10/matrix.c | 18 ++++---- keyboards/keychron/v3/matrix.c | 18 ++++---- keyboards/keychron/v5/matrix.c | 18 ++++---- keyboards/keychron/v6/matrix.c | 18 ++++---- keyboards/rate/pistachio_pro/matrix.c | 20 ++++----- keyboards/work_louder/micro/matrix.c | 16 +++---- quantum/matrix.c | 22 +++++----- 20 files changed, 270 insertions(+), 270 deletions(-) (limited to 'quantum') diff --git a/keyboards/argyle/matrix.c b/keyboards/argyle/matrix.c index d435b368c2..661310ade0 100644 --- a/keyboards/argyle/matrix.c +++ b/keyboards/argyle/matrix.c @@ -24,21 +24,21 @@ along with this program. If not, see . static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -55,7 +55,7 @@ static inline uint8_t readMatrixPin(pin_t pin) { static bool select_row(uint8_t row) { pin_t pin = row_pins[row]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } return false; @@ -64,7 +64,7 @@ static bool select_row(uint8_t row) { static void unselect_row(uint8_t row) { pin_t pin = row_pins[row]; if (pin != NO_PIN) { - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); } } @@ -84,7 +84,7 @@ static void init_pins(void) { for (uint8_t x = 0; x < MATRIX_COLS; x++) { if (col_pins[x] != NO_PIN) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } } diff --git a/keyboards/gmmk/numpad/matrix.c b/keyboards/gmmk/numpad/matrix.c index 4ec41bdb73..8d6e641a77 100644 --- a/keyboards/gmmk/numpad/matrix.c +++ b/keyboards/gmmk/numpad/matrix.c @@ -19,21 +19,21 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define MATRIX_ROW_SHIFTER ((matrix_row_t)1) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -50,7 +50,7 @@ static inline uint8_t readMatrixPin(pin_t pin) { static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } return false; @@ -60,9 +60,9 @@ static void unselect_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { # ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); # else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); # endif } } @@ -78,10 +78,10 @@ __attribute__((weak)) void matrix_init_custom(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } - setPinInputHigh_atomic(B8); + gpio_atomic_set_pin_input_high(B8); } __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter) { // Start with a clear matrix row diff --git a/keyboards/halfcliff/matrix.c b/keyboards/halfcliff/matrix.c index ad3ad6ba09..790f8c41bb 100644 --- a/keyboards/halfcliff/matrix.c +++ b/keyboards/halfcliff/matrix.c @@ -50,25 +50,25 @@ matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } void matrix_print(void) {} -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } } // matrix code -static void select_row(uint8_t row) { setPinOutput_writeLow(row_pins[row]); } +static void select_row(uint8_t row) { gpio_atomic_set_pin_output_low(row_pins[row]); } -static void unselect_row(uint8_t row) { setPinInputHigh_atomic(row_pins[row]); } +static void unselect_row(uint8_t row) { gpio_atomic_set_pin_input_high(row_pins[row]); } static void unselect_rows(void) { for (uint8_t x = 0; x < ROWS_PER_HAND; x++) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } @@ -103,24 +103,24 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) return false; } -static void select_col(uint8_t col) { setPinOutput_writeLow(col_pins[col]); } +static void select_col(uint8_t col) { gpio_atomic_set_pin_output_low(col_pins[col]); } -static void unselect_col(uint8_t col) { setPinInputHigh_atomic(col_pins[col]); } +static void unselect_col(uint8_t col) { gpio_atomic_set_pin_input_high(col_pins[col]); } static void unselect_cols(void) { for (uint8_t x = 0; x < MATRIX_COLS; x++) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } static void init_pins(void) { unselect_rows(); for (uint8_t x = 0; x < MATRIX_COLS; x++) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } unselect_cols(); for (uint8_t x = 0; x < ROWS_PER_HAND; x++) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } diff --git a/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c b/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c index 786c1b4a73..fa9b6ef0fd 100644 --- a/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c +++ b/keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c @@ -60,14 +60,14 @@ static const uint8_t delay_sel[] = {MATRIX_IO_DELAY_MULSEL}; extern matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } } @@ -108,13 +108,13 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) #elif defined(DIODE_DIRECTION) # if (DIODE_DIRECTION == COL2ROW) -static void select_row(uint8_t row) { setPinOutput_writeLow(row_pins[row]); } +static void select_row(uint8_t row) { gpio_atomic_set_pin_output_low(row_pins[row]); } -static void unselect_row(uint8_t row) { setPinInputHigh_atomic(row_pins[row]); } +static void unselect_row(uint8_t row) { gpio_atomic_set_pin_input_high(row_pins[row]); } static void unselect_rows(void) { for (uint8_t x = 0; x < MATRIX_ROWS; x++) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } @@ -125,7 +125,7 @@ static void init_pins(void) { # endif unselect_rows(); for (uint8_t x = 0; x < MATRIX_COLS; x++) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } @@ -218,20 +218,20 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) # elif (DIODE_DIRECTION == ROW2COL) -static void select_col(uint8_t col) { setPinOutput_writeLow(col_pins[col]); } +static void select_col(uint8_t col) { gpio_atomic_set_pin_output_low(col_pins[col]); } -static void unselect_col(uint8_t col) { setPinInputHigh_atomic(col_pins[col]); } +static void unselect_col(uint8_t col) { gpio_atomic_set_pin_input_high(col_pins[col]); } static void unselect_cols(void) { for (uint8_t x = 0; x < MATRIX_COLS; x++) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } static void init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } diff --git a/keyboards/keychron/c2_pro/matrix.c b/keyboards/keychron/c2_pro/matrix.c index 7d5b3e4e79..e05ac5e061 100644 --- a/keyboards/keychron/c2_pro/matrix.c +++ b/keyboards/keychron/c2_pro/matrix.c @@ -41,21 +41,21 @@ pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInput_high(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -106,7 +106,7 @@ static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (col < SHIFT_COL_START || col > SHIFT_COL_END) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == SHIFT_COL_START) { @@ -122,9 +122,9 @@ static void unselect_col(uint8_t col) { if (col < SHIFT_COL_START || col > SHIFT_COL_END) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInput_high(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { HC595_output(0x01, 1); @@ -136,9 +136,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (x < SHIFT_COL_START || x > SHIFT_COL_END) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInput_high(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (x == SHIFT_COL_START) HC595_output(UNSELECT_ALL_COL, 0); @@ -181,7 +181,7 @@ void matrix_init_custom(void) { for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInput_high(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } diff --git a/keyboards/keychron/q10/matrix.c b/keyboards/keychron/q10/matrix.c index b772fd7889..cd6e842e15 100644 --- a/keyboards/keychron/q10/matrix.c +++ b/keyboards/keychron/q10/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -65,35 +65,35 @@ static inline uint8_t readMatrixPin(pin_t pin) { static void shiftOutMultiple(uint16_t dataOut) { for (uint8_t i = 0; i < 8; i++) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } dataOut = dataOut >> 1; - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); } - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static void shiftOut_single(uint8_t dataOut) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == (MATRIX_COLS - 8)) { @@ -111,16 +111,16 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (col == (MATRIX_COLS - 1)) { - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } } } @@ -131,9 +131,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (x == (MATRIX_COLS - 1)) { @@ -148,7 +148,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/q12/matrix.c b/keyboards/keychron/q12/matrix.c index 9d5e9c4d39..bfb51703a0 100644 --- a/keyboards/keychron/q12/matrix.c +++ b/keyboards/keychron/q12/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -65,36 +65,36 @@ static inline uint8_t readMatrixPin(pin_t pin) { static void shiftOut(uint8_t dataOut) { for (uint8_t i = 0; i < 8; i++) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } dataOut = dataOut >> 1; - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); } - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static void shiftout_single(uint8_t data) { if (data & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 10) { @@ -112,16 +112,16 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (col == (MATRIX_COLS - 1)) - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } } @@ -131,9 +131,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == 10) @@ -146,7 +146,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/q1v2/matrix.c b/keyboards/keychron/q1v2/matrix.c index 8e01bdb73e..5fa60c1b1d 100644 --- a/keyboards/keychron/q1v2/matrix.c +++ b/keyboards/keychron/q1v2/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -65,37 +65,37 @@ static inline uint8_t readMatrixPin(pin_t pin) { static void shiftOut(uint8_t dataOut) { for (uint8_t i = 0; i < 8; i++) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } dataOut = dataOut >> 1; - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); } - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static void shiftout_single(uint8_t data) { if (data & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 8) { @@ -113,9 +113,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (col == (MATRIX_COLS - 1)) shiftout_single(0x01); @@ -129,9 +129,9 @@ static void unselect_cols(void) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == (MATRIX_COLS - 1)) @@ -144,7 +144,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/q3/matrix.c b/keyboards/keychron/q3/matrix.c index 25b3f6ed4e..5ed8d7bc4f 100644 --- a/keyboards/keychron/q3/matrix.c +++ b/keyboards/keychron/q3/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -65,37 +65,37 @@ static inline uint8_t readMatrixPin(pin_t pin) { static void shiftOut(uint8_t dataOut) { for (uint8_t i = 0; i < 8; i++) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } dataOut = dataOut >> 1; - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); } - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static void shiftout_single(uint8_t data) { if (data & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 8) { @@ -113,9 +113,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (col == (MATRIX_COLS - 1)) @@ -130,9 +130,9 @@ static void unselect_cols(void) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == (MATRIX_COLS - 1)) @@ -145,7 +145,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/q5/matrix.c b/keyboards/keychron/q5/matrix.c index e7f69d9821..e38301f00f 100644 --- a/keyboards/keychron/q5/matrix.c +++ b/keyboards/keychron/q5/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -65,36 +65,36 @@ static inline uint8_t readMatrixPin(pin_t pin) { static void shiftOut(uint8_t dataOut) { for (uint8_t i = 0; i < 8; i++) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } dataOut = dataOut >> 1; - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); } - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static void shiftout_single(uint8_t data) { if (data & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 10) { @@ -112,16 +112,16 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (col == (MATRIX_COLS - 1)) - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } } @@ -131,9 +131,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == (MATRIX_COLS - 1)) @@ -146,7 +146,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/q6/matrix.c b/keyboards/keychron/q6/matrix.c index 95e00405b4..c61a38ad73 100644 --- a/keyboards/keychron/q6/matrix.c +++ b/keyboards/keychron/q6/matrix.c @@ -46,21 +46,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; # define CLR_REG_VAL 0xFF #endif -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -77,36 +77,36 @@ static inline uint8_t readMatrixPin(pin_t pin) { static void shiftOut(uint16_t dataOut) { for (uint8_t i = 0; i < NO_PIN_NUM; i++) { if (dataOut & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } dataOut = dataOut >> 1; - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); } - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static void shiftout_single(uint8_t data) { if (data & 0x1) { - setPinOutput_writeHigh(DATA_PIN); + gpio_atomic_set_pin_output_high(DATA_PIN); } else { - setPinOutput_writeLow(DATA_PIN); + gpio_atomic_set_pin_output_low(DATA_PIN); } - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == NO_PIN_START) { @@ -124,16 +124,16 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (col == (MATRIX_COLS - NO_PIN_OFFSET - 1)) - setPinOutput_writeHigh(CLOCK_PIN); - setPinOutput_writeLow(CLOCK_PIN); - setPinOutput_writeHigh(LATCH_PIN); - setPinOutput_writeLow(LATCH_PIN); + gpio_atomic_set_pin_output_high(CLOCK_PIN); + gpio_atomic_set_pin_output_low(CLOCK_PIN); + gpio_atomic_set_pin_output_high(LATCH_PIN); + gpio_atomic_set_pin_output_low(LATCH_PIN); } } @@ -142,9 +142,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == (MATRIX_COLS - NO_PIN_OFFSET - 1)) @@ -157,7 +157,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/q65/matrix.c b/keyboards/keychron/q65/matrix.c index c9f9888689..4cbdd346ec 100644 --- a/keyboards/keychron/q65/matrix.c +++ b/keyboards/keychron/q65/matrix.c @@ -34,26 +34,26 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void writePinLow_atomic(pin_t pin) { +static inline void gpio_atomic_write_pin_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_write_pin_low(pin); } } -static inline void writePinHigh_atomic(pin_t pin) { +static inline void gpio_atomic_write_pin_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_write_pin_high(pin); } } -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -119,9 +119,9 @@ static bool select_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - writePinLow_atomic(pin); + gpio_atomic_write_pin_low(pin); #else - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); #endif return true; } else { @@ -138,9 +138,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - writePinHigh_atomic(pin); + gpio_atomic_write_pin_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { shiftout_single(0x01); @@ -152,9 +152,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (x == 0) @@ -178,7 +178,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/v1/matrix.c b/keyboards/keychron/v1/matrix.c index 32d9cfdbb0..01875ae44e 100644 --- a/keyboards/keychron/v1/matrix.c +++ b/keyboards/keychron/v1/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND MATRIX_ROWS -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -113,7 +113,7 @@ static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 8) { @@ -129,9 +129,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { shiftOut_single(0x01); @@ -143,9 +143,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (x == 8) @@ -169,7 +169,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/v10/matrix.c b/keyboards/keychron/v10/matrix.c index bb6504fa78..ee7d0a38c6 100644 --- a/keyboards/keychron/v10/matrix.c +++ b/keyboards/keychron/v10/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -105,7 +105,7 @@ static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == PIN_START_74HC595) { @@ -121,9 +121,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { shiftOut_single(0x01); @@ -137,9 +137,9 @@ static void unselect_cols(void) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == PIN_START_74HC595) @@ -162,7 +162,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/v3/matrix.c b/keyboards/keychron/v3/matrix.c index 5ee860afd2..b127465290 100644 --- a/keyboards/keychron/v3/matrix.c +++ b/keyboards/keychron/v3/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -113,7 +113,7 @@ static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 8) { @@ -129,9 +129,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { shiftOut_single(0x01); @@ -143,9 +143,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (x == 8) @@ -169,7 +169,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/v5/matrix.c b/keyboards/keychron/v5/matrix.c index 255201af12..810fdfb8e6 100644 --- a/keyboards/keychron/v5/matrix.c +++ b/keyboards/keychron/v5/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -113,7 +113,7 @@ static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == 10) { @@ -129,9 +129,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { shiftOut_single(0x01); @@ -143,9 +143,9 @@ static void unselect_cols(void) { pin_t pin = col_pins[x]; if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { if (x == 10) @@ -169,7 +169,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/keychron/v6/matrix.c b/keyboards/keychron/v6/matrix.c index bb6504fa78..ee7d0a38c6 100644 --- a/keyboards/keychron/v6/matrix.c +++ b/keyboards/keychron/v6/matrix.c @@ -34,21 +34,21 @@ static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define ROWS_PER_HAND (MATRIX_ROWS) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -105,7 +105,7 @@ static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } else { if (col == PIN_START_74HC595) { @@ -121,9 +121,9 @@ static void unselect_col(uint8_t col) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } else { shiftOut_single(0x01); @@ -137,9 +137,9 @@ static void unselect_cols(void) { if (pin != NO_PIN) { #ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); #else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); #endif } if (x == PIN_START_74HC595) @@ -162,7 +162,7 @@ static void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } diff --git a/keyboards/rate/pistachio_pro/matrix.c b/keyboards/rate/pistachio_pro/matrix.c index f235c65f56..e40d3edd81 100644 --- a/keyboards/rate/pistachio_pro/matrix.c +++ b/keyboards/rate/pistachio_pro/matrix.c @@ -20,53 +20,53 @@ along with this program. If not, see . static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } } static void select_row(uint8_t row) { - setPinOutput_writeLow(row_pins[row]); + gpio_atomic_set_pin_output_low(row_pins[row]); } static void unselect_row(uint8_t row) { - setPinInputHigh_atomic(row_pins[row]); + gpio_atomic_set_pin_input_high(row_pins[row]); } static void unselect_rows(void) { for (uint8_t x = 0; x < MATRIX_ROWS; x++) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } static void select_col(uint8_t col) { - setPinOutput_writeLow(col_pins[col]); + gpio_atomic_set_pin_output_low(col_pins[col]); } static void unselect_col(uint8_t col) { - setPinInputHigh_atomic(col_pins[col]); + gpio_atomic_set_pin_input_high(col_pins[col]); } static void unselect_cols(void) { for (uint8_t x = 0; x < MATRIX_COLS; x++) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } static void init_pins(void) { unselect_rows(); for (uint8_t x = 0; x < MATRIX_COLS; x++) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } unselect_cols(); for (uint8_t x = 0; x < MATRIX_ROWS; x++) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } diff --git a/keyboards/work_louder/micro/matrix.c b/keyboards/work_louder/micro/matrix.c index 3cfbf17dad..3944d676de 100644 --- a/keyboards/work_louder/micro/matrix.c +++ b/keyboards/work_louder/micro/matrix.c @@ -20,21 +20,21 @@ static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #define MATRIX_ROW_SHIFTER ((matrix_row_t)1) -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -51,7 +51,7 @@ static inline uint8_t readMatrixPin(pin_t pin) { static bool select_row(uint8_t row) { pin_t pin = row_pins[row]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } return false; @@ -60,7 +60,7 @@ static bool select_row(uint8_t row) { static void unselect_row(uint8_t row) { pin_t pin = row_pins[row]; if (pin != NO_PIN) { - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); } } @@ -74,11 +74,11 @@ __attribute__((weak)) void matrix_init_custom(void) { unselect_rows(); for (uint8_t x = 0; x < MATRIX_COLS; x++) { if (col_pins[x] != NO_PIN) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } - setPinInputHigh_atomic(F7); - setPinInputHigh_atomic(F0); + gpio_atomic_set_pin_input_high(F7); + gpio_atomic_set_pin_input_high(F0); } void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { diff --git a/quantum/matrix.c b/quantum/matrix.c index d4586efac2..a877fb4e41 100644 --- a/quantum/matrix.c +++ b/quantum/matrix.c @@ -76,21 +76,21 @@ __attribute__((weak)) void matrix_init_pins(void); __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row); __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter); -static inline void setPinOutput_writeLow(pin_t pin) { +static inline void gpio_atomic_set_pin_output_low(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_low(pin); } } -static inline void setPinOutput_writeHigh(pin_t pin) { +static inline void gpio_atomic_set_pin_output_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_output(pin); gpio_write_pin_high(pin); } } -static inline void setPinInputHigh_atomic(pin_t pin) { +static inline void gpio_atomic_set_pin_input_high(pin_t pin) { ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } @@ -140,7 +140,7 @@ __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[] static bool select_row(uint8_t row) { pin_t pin = row_pins[row]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } return false; @@ -150,9 +150,9 @@ static void unselect_row(uint8_t row) { pin_t pin = row_pins[row]; if (pin != NO_PIN) { # ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); # else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); # endif } } @@ -167,7 +167,7 @@ __attribute__((weak)) void matrix_init_pins(void) { unselect_rows(); for (uint8_t x = 0; x < MATRIX_COLS; x++) { if (col_pins[x] != NO_PIN) { - setPinInputHigh_atomic(col_pins[x]); + gpio_atomic_set_pin_input_high(col_pins[x]); } } } @@ -203,7 +203,7 @@ __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[] static bool select_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { - setPinOutput_writeLow(pin); + gpio_atomic_set_pin_output_low(pin); return true; } return false; @@ -213,9 +213,9 @@ static void unselect_col(uint8_t col) { pin_t pin = col_pins[col]; if (pin != NO_PIN) { # ifdef MATRIX_UNSELECT_DRIVE_HIGH - setPinOutput_writeHigh(pin); + gpio_atomic_set_pin_output_high(pin); # else - setPinInputHigh_atomic(pin); + gpio_atomic_set_pin_input_high(pin); # endif } } @@ -230,7 +230,7 @@ __attribute__((weak)) void matrix_init_pins(void) { unselect_cols(); for (uint8_t x = 0; x < ROWS_PER_HAND; x++) { if (row_pins[x] != NO_PIN) { - setPinInputHigh_atomic(row_pins[x]); + gpio_atomic_set_pin_input_high(row_pins[x]); } } } -- cgit v1.2.3 From 8abaa3bc2df4fda13a96d0c5c4ce74b70c974fb7 Mon Sep 17 00:00:00 2001 From: Nick Brassel Date: Tue, 16 Jul 2024 09:22:17 +1000 Subject: Add support for key override introspection. (#24120) --- docs/ChangeLog/PR24120.md | 19 ++++++++++++ docs/features/key_overrides.md | 17 +++++----- quantum/keymap_introspection.c | 43 +++++++++++++++++++++++--- quantum/keymap_introspection.h | 21 +++++++++++++ quantum/process_keycode/process_key_override.c | 10 +++--- quantum/process_keycode/process_key_override.h | 5 +-- 6 files changed, 90 insertions(+), 25 deletions(-) create mode 100644 docs/ChangeLog/PR24120.md (limited to 'quantum') diff --git a/docs/ChangeLog/PR24120.md b/docs/ChangeLog/PR24120.md new file mode 100644 index 0000000000..5c635349ea --- /dev/null +++ b/docs/ChangeLog/PR24120.md @@ -0,0 +1,19 @@ +## Changes requiring user action + +### Key Override Introspection + +Changes were made to key overrides in order to hook them into the keymap introspection system. + +Key override signature changed from: + +```c +const key_override_t **key_overrides = (const key_override_t *[]){ +``` + +to: + +```c +const key_override_t *key_overrides[] = { +``` + +The list of key overrides now does not need to be `NULL`-terminated. diff --git a/docs/features/key_overrides.md b/docs/features/key_overrides.md index 4c568f1679..9b6015175c 100644 --- a/docs/features/key_overrides.md +++ b/docs/features/key_overrides.md @@ -14,7 +14,7 @@ You can use key overrides in a similar way to momentary layer/fn keys to activat To enable this feature, you need to add `KEY_OVERRIDE_ENABLE = yes` to your `rules.mk`. -Then, in your `keymap.c` file, you'll need to define the array `key_overrides`, which defines all key overrides to be used. Each override is a value of type `key_override_t`. The array `key_overrides` is `NULL`-terminated and contains pointers to `key_override_t` values (`const key_override_t **`). +Then, in your `keymap.c` file, you'll need to define the array `key_overrides`, which defines all key overrides to be used. Each override is a value of type `key_override_t`. The array `key_overrides`contains pointers to `key_override_t` values (`const key_override_t **`). ## Creating Key Overrides {#creating-key-overrides} @@ -42,9 +42,8 @@ This shows how the mentioned example of sending `delete` when `shift` + `backspa const key_override_t delete_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL); // This globally defines all key overrides to be used -const key_override_t **key_overrides = (const key_override_t *[]){ - &delete_key_override, - NULL // Null terminate the array of overrides! +const key_override_t *key_overrides[] = { + &delete_key_override }; ``` @@ -91,14 +90,13 @@ const key_override_t brightness_up_override = ko_make_with_layers_negmods_and_op const key_override_t brightness_down_override = ko_make_basic(MOD_MASK_CSA, KC_MPLY, KC_BRID); // This globally defines all key overrides to be used -const key_override_t **key_overrides = (const key_override_t *[]){ +const key_override_t *key_overrides[] = { &next_track_override, &prev_track_override, &vol_up_override, &vol_down_override, &brightness_up_override, - &brightness_down_override, - NULL + &brightness_down_override }; ``` @@ -112,10 +110,9 @@ const key_override_t tilde_esc_override = ko_make_basic(MOD_MASK_SHIFT, KC_ESC, // GUI + esc = ` const key_override_t grave_esc_override = ko_make_basic(MOD_MASK_GUI, KC_ESC, KC_GRV); -const key_override_t **key_overrides = (const key_override_t *[]){ +const key_override_t *key_overrides[] = { &tilde_esc_override, - &grave_esc_override, - NULL + &grave_esc_override }; ``` diff --git a/quantum/keymap_introspection.c b/quantum/keymap_introspection.c index 4e95125335..327df6e277 100644 --- a/quantum/keymap_introspection.c +++ b/quantum/keymap_introspection.c @@ -10,6 +10,7 @@ #endif // INTROSPECTION_KEYMAP_C #include "keymap_introspection.h" +#include "util.h" //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Key mapping @@ -83,7 +84,7 @@ uint16_t keycode_at_dip_switch_map_location_raw(uint8_t switch_idx, bool on) { return KC_TRNS; } -uint16_t keycode_at_dip_switch_map_location(uint8_t switch_idx, bool on) { +__attribute__((weak)) uint16_t keycode_at_dip_switch_map_location(uint8_t switch_idx, bool on) { return keycode_at_dip_switch_map_location_raw(switch_idx, on); } @@ -95,13 +96,16 @@ uint16_t keycode_at_dip_switch_map_location(uint8_t switch_idx, bool on) { #if defined(COMBO_ENABLE) uint16_t combo_count_raw(void) { - return sizeof(key_combos) / sizeof(combo_t); + return ARRAY_SIZE(key_combos); } __attribute__((weak)) uint16_t combo_count(void) { return combo_count_raw(); } combo_t* combo_get_raw(uint16_t combo_idx) { + if (combo_idx >= combo_count_raw()) { + return NULL; + } return &key_combos[combo_idx]; } __attribute__((weak)) combo_t* combo_get(uint16_t combo_idx) { @@ -116,19 +120,48 @@ __attribute__((weak)) combo_t* combo_get(uint16_t combo_idx) { #if defined(TAP_DANCE_ENABLE) uint16_t tap_dance_count_raw(void) { - return sizeof(tap_dance_actions) / sizeof(tap_dance_action_t); + return ARRAY_SIZE(tap_dance_actions); } -uint16_t tap_dance_count(void) { +__attribute__((weak)) uint16_t tap_dance_count(void) { return tap_dance_count_raw(); } tap_dance_action_t* tap_dance_get_raw(uint16_t tap_dance_idx) { + if (tap_dance_idx >= tap_dance_count_raw()) { + return NULL; + } return &tap_dance_actions[tap_dance_idx]; } -tap_dance_action_t* tap_dance_get(uint16_t tap_dance_idx) { +__attribute__((weak)) tap_dance_action_t* tap_dance_get(uint16_t tap_dance_idx) { return tap_dance_get_raw(tap_dance_idx); } #endif // defined(TAP_DANCE_ENABLE) + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Key Overrides + +#if defined(KEY_OVERRIDE_ENABLE) + +uint16_t key_override_count_raw(void) { + return ARRAY_SIZE(key_overrides); +} + +__attribute__((weak)) uint16_t key_override_count(void) { + return key_override_count_raw(); +} + +const key_override_t* key_override_get_raw(uint16_t key_override_idx) { + if (key_override_idx >= key_override_count_raw()) { + return NULL; + } + return key_overrides[key_override_idx]; +} + +__attribute__((weak)) const key_override_t* key_override_get(uint16_t key_override_idx) { + return key_override_get_raw(key_override_idx); +} + +#endif // defined(KEY_OVERRIDE_ENABLE) diff --git a/quantum/keymap_introspection.h b/quantum/keymap_introspection.h index bc4dd93b4c..719825c674 100644 --- a/quantum/keymap_introspection.h +++ b/quantum/keymap_introspection.h @@ -88,3 +88,24 @@ tap_dance_action_t* tap_dance_get_raw(uint16_t tap_dance_idx); tap_dance_action_t* tap_dance_get(uint16_t tap_dance_idx); #endif // defined(TAP_DANCE_ENABLE) + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Key Overrides + +#if defined(KEY_OVERRIDE_ENABLE) + +// Forward declaration of key_override_t so we don't need to deal with header reordering +struct key_override_t; +typedef struct key_override_t key_override_t; + +// Get the number of key overrides defined in the user's keymap, stored in firmware rather than any other persistent storage +uint16_t key_override_count_raw(void); +// Get the number of key overrides defined in the user's keymap, potentially stored dynamically +uint16_t key_override_count(void); + +// Get the key override definitions, stored in firmware rather than any other persistent storage +const key_override_t* key_override_get_raw(uint16_t key_override_idx); +// Get the key override definitions, potentially stored dynamically +const key_override_t* key_override_get(uint16_t key_override_idx); + +#endif // defined(KEY_OVERRIDE_ENABLE) diff --git a/quantum/process_keycode/process_key_override.c b/quantum/process_keycode/process_key_override.c index 264e2562b8..ce30477ee8 100644 --- a/quantum/process_keycode/process_key_override.c +++ b/quantum/process_keycode/process_key_override.c @@ -23,6 +23,7 @@ #include "action_util.h" #include "quantum.h" #include "quantum_keycodes.h" +#include "keymap_introspection.h" #ifndef KEY_OVERRIDE_REPEAT_DELAY # define KEY_OVERRIDE_REPEAT_DELAY 500 @@ -83,9 +84,6 @@ static uint16_t deferred_register = 0; // TODO: in future maybe save in EEPROM? static bool enabled = true; -// Public variables -__attribute__((weak)) const key_override_t **key_overrides = NULL; - // Forward decls static const key_override_t *clear_active_override(const bool allow_reregister); @@ -247,12 +245,12 @@ static bool check_activation_event(const key_override_t *override, const bool ke /** Iterates through the list of key overrides and tries activating each, until it finds one that activates or reaches the end of overrides. Returns true if the key action for `keycode` should be sent */ static bool try_activating_override(const uint16_t keycode, const uint8_t layer, const bool key_down, const bool is_mod, const uint8_t active_mods, bool *activated) { - if (key_overrides == NULL) { + if (key_override_count() == 0) { return true; } - for (uint8_t i = 0;; i++) { - const key_override_t *const override = key_overrides[i]; + for (uint8_t i = 0; i < key_override_count(); i++) { + const key_override_t *const override = key_override_get(i); // End of array if (override == NULL) { diff --git a/quantum/process_keycode/process_key_override.h b/quantum/process_keycode/process_key_override.h index 3e37c7e63a..9ec84dbe6e 100644 --- a/quantum/process_keycode/process_key_override.h +++ b/quantum/process_keycode/process_key_override.h @@ -55,7 +55,7 @@ typedef enum { } ko_option_t; /** Defines a single key override */ -typedef struct { +typedef struct key_override_t { // The non-modifier keycode that triggers the override. This keycode, and the necessary modifiers (trigger_mods) must be pressed to activate this override. Set this to the keycode of the key that should activate the override. Set to KC_NO to require only the necessary modifiers to be pressed and no non-modifier. uint16_t trigger; @@ -87,9 +87,6 @@ typedef struct { bool *enabled; } key_override_t; -/** Define this as a null-terminated array of pointers to key overrides. These key overrides will be used by qmk. */ -extern const key_override_t **key_overrides; - /** Turns key overrides on */ void key_override_on(void); -- cgit v1.2.3 From 59c275afbc2f01dbee750c0a59e20ada2913252b Mon Sep 17 00:00:00 2001 From: フィルターペーパー Date: Wed, 24 Jul 2024 02:34:00 +0800 Subject: Check LED flags for Pixel Fractal effect (#23881) --- quantum/rgb_matrix/animations/pixel_fractal_anim.h | 24 +++++++++++----------- 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'quantum') diff --git a/quantum/rgb_matrix/animations/pixel_fractal_anim.h b/quantum/rgb_matrix/animations/pixel_fractal_anim.h index 4cd1d9b861..90a75ed321 100644 --- a/quantum/rgb_matrix/animations/pixel_fractal_anim.h +++ b/quantum/rgb_matrix/animations/pixel_fractal_anim.h @@ -30,23 +30,23 @@ static bool PIXEL_FRACTAL(effect_params_t* params) { for (uint8_t h = 0; h < MATRIX_ROWS; ++h) { // Light and copy columns outward for (uint8_t l = 0; l < MID_COL - 1; ++l) { - if (led[h][l]) { - rgb_matrix_set_color(g_led_config.matrix_co[h][l], rgb.r, rgb.g, rgb.b); - rgb_matrix_set_color(g_led_config.matrix_co[h][MATRIX_COLS - 1 - l], rgb.r, rgb.g, rgb.b); - } else { - rgb_matrix_set_color(g_led_config.matrix_co[h][l], 0, 0, 0); - rgb_matrix_set_color(g_led_config.matrix_co[h][MATRIX_COLS - 1 - l], 0, 0, 0); + RGB index_rgb = led[h][l] ? (RGB){rgb.r, rgb.g, rgb.b} : (RGB){0, 0, 0}; + if (HAS_ANY_FLAGS(g_led_config.flags[g_led_config.matrix_co[h][l]], params->flags)) { + rgb_matrix_set_color(g_led_config.matrix_co[h][l], index_rgb.r, index_rgb.g, index_rgb.b); + } + if (HAS_ANY_FLAGS(g_led_config.flags[g_led_config.matrix_co[h][MATRIX_COLS - 1 - l]], params->flags)) { + rgb_matrix_set_color(g_led_config.matrix_co[h][MATRIX_COLS - 1 - l], index_rgb.r, index_rgb.g, index_rgb.b); } led[h][l] = led[h][l + 1]; } // Light both middle columns - if (led[h][MID_COL - 1]) { - rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL - 1], rgb.r, rgb.g, rgb.b); - rgb_matrix_set_color(g_led_config.matrix_co[h][MATRIX_COLS - MID_COL], rgb.r, rgb.g, rgb.b); - } else { - rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL - 1], 0, 0, 0); - rgb_matrix_set_color(g_led_config.matrix_co[h][MATRIX_COLS - MID_COL], 0, 0, 0); + RGB index_rgb = led[h][MID_COL - 1] ? (RGB){rgb.r, rgb.g, rgb.b} : (RGB){0, 0, 0}; + if (HAS_ANY_FLAGS(g_led_config.flags[g_led_config.matrix_co[h][MID_COL - 1]], params->flags)) { + rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL - 1], index_rgb.r, index_rgb.g, index_rgb.b); + } + if (HAS_ANY_FLAGS(g_led_config.flags[g_led_config.matrix_co[h][MATRIX_COLS - MID_COL]], params->flags)) { + rgb_matrix_set_color(g_led_config.matrix_co[h][MATRIX_COLS - MID_COL], index_rgb.r, index_rgb.g, index_rgb.b); } // Generate new random fractal column -- cgit v1.2.3 From 91f293d0c7209c9421d4fbc8b952a8501b0b56fb Mon Sep 17 00:00:00 2001 From: フィルターペーパー Date: Wed, 14 Aug 2024 07:54:01 +0800 Subject: Refactor riverflow RGB matrix loop (#24203) Check for LED flags at the start of loop to skip early--- quantum/rgb_matrix/animations/riverflow_anim.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'quantum') diff --git a/quantum/rgb_matrix/animations/riverflow_anim.h b/quantum/rgb_matrix/animations/riverflow_anim.h index 79a38e7f6e..195d15986d 100644 --- a/quantum/rgb_matrix/animations/riverflow_anim.h +++ b/quantum/rgb_matrix/animations/riverflow_anim.h @@ -7,11 +7,11 @@ RGB_MATRIX_EFFECT(RIVERFLOW) bool RIVERFLOW(effect_params_t* params) { RGB_MATRIX_USE_LIMITS(led_min, led_max); for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); HSV hsv = rgb_matrix_config.hsv; uint16_t time = scale16by8(g_rgb_timer + (i * 315), rgb_matrix_config.speed / 8); hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); RGB rgb = rgb_matrix_hsv_to_rgb(hsv); - RGB_MATRIX_TEST_LED_FLAGS(); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } -- cgit v1.2.3 From 822a4580f45f5cdf7c0857e21b8144e933681f7f Mon Sep 17 00:00:00 2001 From: フィルターペーパー Date: Wed, 14 Aug 2024 07:55:00 +0800 Subject: Refactor starlight RGB matrix effects (#24202) * Use unsigned integers * Use lib8tion random8 function * Test for valid LED flags * Use rgb_matrix_hsv_to_rgb function--- quantum/rgb_matrix/animations/starlight_anim.h | 9 +++++---- quantum/rgb_matrix/animations/starlight_dual_hue_anim.h | 11 ++++++----- quantum/rgb_matrix/animations/starlight_dual_sat_anim.h | 11 ++++++----- 3 files changed, 17 insertions(+), 14 deletions(-) (limited to 'quantum') diff --git a/quantum/rgb_matrix/animations/starlight_anim.h b/quantum/rgb_matrix/animations/starlight_anim.h index 33f0b61a91..91626a4663 100644 --- a/quantum/rgb_matrix/animations/starlight_anim.h +++ b/quantum/rgb_matrix/animations/starlight_anim.h @@ -2,25 +2,26 @@ RGB_MATRIX_EFFECT(STARLIGHT) # ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -void set_starlight_color(int i, effect_params_t* params) { +void set_starlight_color(uint8_t i, effect_params_t* params) { uint16_t time = scale16by8(g_rgb_timer, rgb_matrix_config.speed / 8); HSV hsv = rgb_matrix_config.hsv; hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); - RGB rgb = hsv_to_rgb(hsv); + RGB rgb = rgb_matrix_hsv_to_rgb(hsv); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } bool STARLIGHT(effect_params_t* params) { if (!params->init) { if (scale16by8(g_rgb_timer, qadd8(rgb_matrix_config.speed, 5)) % 5 == 0) { - int rand_led = rand() % RGB_MATRIX_LED_COUNT; + uint8_t rand_led = random8_max(RGB_MATRIX_LED_COUNT); set_starlight_color(rand_led, params); } return false; } RGB_MATRIX_USE_LIMITS(led_min, led_max); - for (int i = led_min; i < led_max; i++) { + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); set_starlight_color(i, params); } return rgb_matrix_check_finished_leds(led_max); diff --git a/quantum/rgb_matrix/animations/starlight_dual_hue_anim.h b/quantum/rgb_matrix/animations/starlight_dual_hue_anim.h index df6461b8b7..5ef831476f 100644 --- a/quantum/rgb_matrix/animations/starlight_dual_hue_anim.h +++ b/quantum/rgb_matrix/animations/starlight_dual_hue_anim.h @@ -2,26 +2,27 @@ RGB_MATRIX_EFFECT(STARLIGHT_DUAL_HUE) # ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -void set_starlight_dual_hue_color(int i, effect_params_t* params) { +void set_starlight_dual_hue_color(uint8_t i, effect_params_t* params) { uint16_t time = scale16by8(g_rgb_timer, rgb_matrix_config.speed / 8); HSV hsv = rgb_matrix_config.hsv; hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); - hsv.h = hsv.h + (rand() % (30 + 1 - -30) + -30); - RGB rgb = hsv_to_rgb(hsv); + hsv.h = hsv.h + random8_max((30 + 1 - -30) + -30); + RGB rgb = rgb_matrix_hsv_to_rgb(hsv); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } bool STARLIGHT_DUAL_HUE(effect_params_t* params) { if (!params->init) { if (scale16by8(g_rgb_timer, qadd8(rgb_matrix_config.speed, 5)) % 5 == 0) { - int rand_led = rand() % RGB_MATRIX_LED_COUNT; + uint8_t rand_led = random8_max(RGB_MATRIX_LED_COUNT); set_starlight_dual_hue_color(rand_led, params); } return false; } RGB_MATRIX_USE_LIMITS(led_min, led_max); - for (int i = led_min; i < led_max; i++) { + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); set_starlight_dual_hue_color(i, params); } return rgb_matrix_check_finished_leds(led_max); diff --git a/quantum/rgb_matrix/animations/starlight_dual_sat_anim.h b/quantum/rgb_matrix/animations/starlight_dual_sat_anim.h index f6ecd48aa1..1994aba8a8 100644 --- a/quantum/rgb_matrix/animations/starlight_dual_sat_anim.h +++ b/quantum/rgb_matrix/animations/starlight_dual_sat_anim.h @@ -2,26 +2,27 @@ RGB_MATRIX_EFFECT(STARLIGHT_DUAL_SAT) # ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS -void set_starlight_dual_sat_color(int i, effect_params_t* params) { +void set_starlight_dual_sat_color(uint8_t i, effect_params_t* params) { uint16_t time = scale16by8(g_rgb_timer, rgb_matrix_config.speed / 8); HSV hsv = rgb_matrix_config.hsv; hsv.v = scale8(abs8(sin8(time) - 128) * 2, hsv.v); - hsv.s = hsv.s + (rand() % (30 + 1 - -30) + -30); - RGB rgb = hsv_to_rgb(hsv); + hsv.s = hsv.s + random8_max((30 + 1 - -30) + -30); + RGB rgb = rgb_matrix_hsv_to_rgb(hsv); rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); } bool STARLIGHT_DUAL_SAT(effect_params_t* params) { if (!params->init) { if (scale16by8(g_rgb_timer, qadd8(rgb_matrix_config.speed, 5)) % 5 == 0) { - int rand_led = rand() % RGB_MATRIX_LED_COUNT; + uint8_t rand_led = random8_max(RGB_MATRIX_LED_COUNT); set_starlight_dual_sat_color(rand_led, params); } return false; } RGB_MATRIX_USE_LIMITS(led_min, led_max); - for (int i = led_min; i < led_max; i++) { + for (uint8_t i = led_min; i < led_max; i++) { + RGB_MATRIX_TEST_LED_FLAGS(); set_starlight_dual_sat_color(i, params); } return rgb_matrix_check_finished_leds(led_max); -- cgit v1.2.3 From ab4c13e835060f6fb921a7d206e28f9525d34178 Mon Sep 17 00:00:00 2001 From: Drashna Jaelre Date: Sat, 17 Aug 2024 17:35:10 -0700 Subject: Add dynamic macro keyboard callbacks (#24142) --- keyboards/ergodox_ez/ergodox_ez.c | 12 +- keyboards/ibm/model_m/mschwingen/mschwingen.c | 12 +- keyboards/zsa/moonlander/moonlander.c | 14 +- keyboards/zsa/voyager/voyager.c | 12 +- quantum/dynamic_macro.h | 264 ------------------------ quantum/process_keycode/process_dynamic_macro.c | 52 +++-- quantum/process_keycode/process_dynamic_macro.h | 14 +- 7 files changed, 86 insertions(+), 294 deletions(-) delete mode 100644 quantum/dynamic_macro.h (limited to 'quantum') diff --git a/keyboards/ergodox_ez/ergodox_ez.c b/keyboards/ergodox_ez/ergodox_ez.c index 5fc173917f..e23231ecb8 100644 --- a/keyboards/ergodox_ez/ergodox_ez.c +++ b/keyboards/ergodox_ez/ergodox_ez.c @@ -382,15 +382,23 @@ static bool is_on = false; static bool is_dynamic_recording = false; static uint16_t dynamic_loop_timer; -void dynamic_macro_record_start_user(int8_t direction) { +bool dynamic_macro_record_start_kb(int8_t direction) { + if (!dynamic_macro_record_start_user(direction)) { + return false; + } is_dynamic_recording = true; dynamic_loop_timer = timer_read(); ergodox_right_led_1_on(); + return true; } -void dynamic_macro_record_end_user(int8_t direction) { +bool dynamic_macro_record_end_kb(int8_t direction) { + if (!dynamic_macro_record_end_user(direction)) { + return false; + } is_dynamic_recording = false; layer_state_set_user(layer_state); + return true; } #endif diff --git a/keyboards/ibm/model_m/mschwingen/mschwingen.c b/keyboards/ibm/model_m/mschwingen/mschwingen.c index 11407d1206..7c0f1b2565 100644 --- a/keyboards/ibm/model_m/mschwingen/mschwingen.c +++ b/keyboards/ibm/model_m/mschwingen/mschwingen.c @@ -206,11 +206,19 @@ void update_layer_leds(void) { #endif -void dynamic_macro_record_start_user(int8_t direction) { +bool dynamic_macro_record_start_kb(int8_t direction) { + if (!dynamic_macro_record_start_user(direction)) { + return false; + } isRecording++; blink_cycle_timer = timer_read(); + return true; } -void dynamic_macro_record_end_user(int8_t direction) { +bool dynamic_macro_record_end_kb(int8_t direction) { + if (!dynamic_macro_record_end_user(direction)) { + return false; + } if (isRecording) isRecording--; + return true; } diff --git a/keyboards/zsa/moonlander/moonlander.c b/keyboards/zsa/moonlander/moonlander.c index 02c64f4b96..0584e8cd31 100644 --- a/keyboards/zsa/moonlander/moonlander.c +++ b/keyboards/zsa/moonlander/moonlander.c @@ -26,11 +26,21 @@ bool is_launching = false; #ifdef DYNAMIC_MACRO_ENABLE static bool is_dynamic_recording = false; -void dynamic_macro_record_start_user(int8_t direction) { is_dynamic_recording = true; } +bool dynamic_macro_record_start_kb(int8_t direction) { + if (!dynamic_macro_record_start_user(direction)) { + return false; + } + is_dynamic_recording = true; + return true; +} -void dynamic_macro_record_end_user(int8_t direction) { +bool dynamic_macro_record_end_kb(int8_t direction) { + if (!dynamic_macro_record_end_user(direction)) { + return false; + } is_dynamic_recording = false; ML_LED_3(false); + return false; } #endif diff --git a/keyboards/zsa/voyager/voyager.c b/keyboards/zsa/voyager/voyager.c index 3255f25a97..69d42bba1a 100644 --- a/keyboards/zsa/voyager/voyager.c +++ b/keyboards/zsa/voyager/voyager.c @@ -21,18 +21,26 @@ static uint32_t dynamic_macro_led(uint32_t trigger_time, void *cb_arg) { return 100; } -void dynamic_macro_record_start_user(int8_t direction) { +bool dynamic_macro_record_start_kb(int8_t direction) { + if (!dynamic_macro_record_start_user(direction)) { + return false; + } if (dynamic_macro_token == INVALID_DEFERRED_TOKEN) { STATUS_LED_3(true); dynamic_macro_token = defer_exec(100, dynamic_macro_led, NULL); } + return true; } -void dynamic_macro_record_end_user(int8_t direction) { +bool dynamic_macro_record_end_kb(int8_t direction) { + if (!dynamic_macro_record_end_user(direction)) { + return false; + } if (cancel_deferred_exec(dynamic_macro_token)) { dynamic_macro_token = INVALID_DEFERRED_TOKEN; STATUS_LED_3(false); } + return true; } # endif diff --git a/quantum/dynamic_macro.h b/quantum/dynamic_macro.h deleted file mode 100644 index 64c532e6ce..0000000000 --- a/quantum/dynamic_macro.h +++ /dev/null @@ -1,264 +0,0 @@ -/* Copyright 2016 Jack Humbert - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -/* Author: Wojciech Siewierski < wojciech dot siewierski at onet dot pl > */ -#pragma once - -/* Warn users that this is now deprecated and they should use the core feature instead. */ -#pragma message "Dynamic Macros is now a core feature. See updated documentation to see how to configure it: https://docs.qmk.fm/#/feature_dynamic_macros" - -#include "action_layer.h" - -#ifndef DYNAMIC_MACRO_SIZE -/* May be overridden with a custom value. Be aware that the effective - * macro length is half of this value: each keypress is recorded twice - * because of the down-event and up-event. This is not a bug, it's the - * intended behavior. - * - * Usually it should be fine to set the macro size to at least 256 but - * there have been reports of it being too much in some users' cases, - * so 128 is considered a safe default. - */ -# define DYNAMIC_MACRO_SIZE 128 -#endif - -/* Blink the LEDs to notify the user about some event. */ -void dynamic_macro_led_blink(void) { -#ifdef BACKLIGHT_ENABLE - backlight_toggle(); - wait_ms(100); - backlight_toggle(); -#endif -} - -/* Convenience macros used for retrieving the debug info. All of them - * need a `direction` variable accessible at the call site. - */ -#define DYNAMIC_MACRO_CURRENT_SLOT() (direction > 0 ? 1 : 2) -#define DYNAMIC_MACRO_CURRENT_LENGTH(BEGIN, POINTER) ((int)(direction * ((POINTER) - (BEGIN)))) -#define DYNAMIC_MACRO_CURRENT_CAPACITY(BEGIN, END2) ((int)(direction * ((END2) - (BEGIN)) + 1)) - -/** - * Start recording of the dynamic macro. - * - * @param[out] macro_pointer The new macro buffer iterator. - * @param[in] macro_buffer The macro buffer used to initialize macro_pointer. - */ -void dynamic_macro_record_start(keyrecord_t **macro_pointer, keyrecord_t *macro_buffer) { - dprintln("dynamic macro recording: started"); - - dynamic_macro_led_blink(); - - clear_keyboard(); - layer_clear(); - *macro_pointer = macro_buffer; -} - -/** - * Play the dynamic macro. - * - * @param macro_buffer[in] The beginning of the macro buffer being played. - * @param macro_end[in] The element after the last macro buffer element. - * @param direction[in] Either +1 or -1, which way to iterate the buffer. - */ -void dynamic_macro_play(keyrecord_t *macro_buffer, keyrecord_t *macro_end, int8_t direction) { - dprintf("dynamic macro: slot %d playback\n", DYNAMIC_MACRO_CURRENT_SLOT()); - - uint32_t saved_layer_state = layer_state; - - clear_keyboard(); - layer_clear(); - - while (macro_buffer != macro_end) { - process_record(macro_buffer); - macro_buffer += direction; - } - - clear_keyboard(); - - layer_state = saved_layer_state; -} - -/** - * Record a single key in a dynamic macro. - * - * @param macro_buffer[in] The start of the used macro buffer. - * @param macro_pointer[in,out] The current buffer position. - * @param macro2_end[in] The end of the other macro. - * @param direction[in] Either +1 or -1, which way to iterate the buffer. - * @param record[in] The current keypress. - */ -void dynamic_macro_record_key(keyrecord_t *macro_buffer, keyrecord_t **macro_pointer, keyrecord_t *macro2_end, int8_t direction, keyrecord_t *record) { - /* If we've just started recording, ignore all the key releases. */ - if (!record->event.pressed && *macro_pointer == macro_buffer) { - dprintln("dynamic macro: ignoring a leading key-up event"); - return; - } - - /* The other end of the other macro is the last buffer element it - * is safe to use before overwriting the other macro. - */ - if (*macro_pointer - direction != macro2_end) { - **macro_pointer = *record; - *macro_pointer += direction; - } else { - dynamic_macro_led_blink(); - } - - dprintf("dynamic macro: slot %d length: %d/%d\n", DYNAMIC_MACRO_CURRENT_SLOT(), DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, *macro_pointer), DYNAMIC_MACRO_CURRENT_CAPACITY(macro_buffer, macro2_end)); -} - -/** - * End recording of the dynamic macro. Essentially just update the - * pointer to the end of the macro. - */ -void dynamic_macro_record_end(keyrecord_t *macro_buffer, keyrecord_t *macro_pointer, int8_t direction, keyrecord_t **macro_end) { - dynamic_macro_led_blink(); - - /* Do not save the keys being held when stopping the recording, - * i.e. the keys used to access the layer DM_RSTP is on. - */ - while (macro_pointer != macro_buffer && (macro_pointer - direction)->event.pressed) { - dprintln("dynamic macro: trimming a trailing key-down event"); - macro_pointer -= direction; - } - - dprintf("dynamic macro: slot %d saved, length: %d\n", DYNAMIC_MACRO_CURRENT_SLOT(), DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, macro_pointer)); - - *macro_end = macro_pointer; -} - -/* Handle the key events related to the dynamic macros. Should be - * called from process_record_user() like this: - * - * bool process_record_user(uint16_t keycode, keyrecord_t *record) { - * if (!process_record_dynamic_macro(keycode, record)) { - * return false; - * } - * <...THE REST OF THE FUNCTION...> - * } - */ -bool process_record_dynamic_macro(uint16_t keycode, keyrecord_t *record) { - /* Both macros use the same buffer but read/write on different - * ends of it. - * - * Macro1 is written left-to-right starting from the beginning of - * the buffer. - * - * Macro2 is written right-to-left starting from the end of the - * buffer. - * - * ¯o_buffer macro_end - * v v - * +------------------------------------------------------------+ - * |>>>>>> MACRO1 >>>>>> <<<<<<<<<<<<< MACRO2 <<<<<<<<<<<<<| - * +------------------------------------------------------------+ - * ^ ^ - * r_macro_end r_macro_buffer - * - * During the recording when one macro encounters the end of the - * other macro, the recording is stopped. Apart from this, there - * are no arbitrary limits for the macros' length in relation to - * each other: for example one can either have two medium sized - * macros or one long macro and one short macro. Or even one empty - * and one using the whole buffer. - */ - static keyrecord_t macro_buffer[DYNAMIC_MACRO_SIZE]; - - /* Pointer to the first buffer element after the first macro. - * Initially points to the very beginning of the buffer since the - * macro is empty. */ - static keyrecord_t *macro_end = macro_buffer; - - /* The other end of the macro buffer. Serves as the beginning of - * the second macro. */ - static keyrecord_t *const r_macro_buffer = macro_buffer + DYNAMIC_MACRO_SIZE - 1; - - /* Like macro_end but for the second macro. */ - static keyrecord_t *r_macro_end = r_macro_buffer; - - /* A persistent pointer to the current macro position (iterator) - * used during the recording. */ - static keyrecord_t *macro_pointer = NULL; - - /* 0 - no macro is being recorded right now - * 1,2 - either macro 1 or 2 is being recorded */ - static uint8_t macro_id = 0; - - if (macro_id == 0) { - /* No macro recording in progress. */ - if (!record->event.pressed) { - switch (keycode) { - case QK_DYNAMIC_MACRO_RECORD_START_1: - dynamic_macro_record_start(¯o_pointer, macro_buffer); - macro_id = 1; - return false; - case QK_DYNAMIC_MACRO_RECORD_START_2: - dynamic_macro_record_start(¯o_pointer, r_macro_buffer); - macro_id = 2; - return false; - case QK_DYNAMIC_MACRO_PLAY_1: - dynamic_macro_play(macro_buffer, macro_end, +1); - return false; - case QK_DYNAMIC_MACRO_PLAY_2: - dynamic_macro_play(r_macro_buffer, r_macro_end, -1); - return false; - } - } - } else { - /* A macro is being recorded right now. */ - switch (keycode) { - case QK_DYNAMIC_MACRO_RECORD_STOP: - /* Stop the macro recording. */ - if (record->event.pressed) { /* Ignore the initial release - * just after the recoding - * starts. */ - switch (macro_id) { - case 1: - dynamic_macro_record_end(macro_buffer, macro_pointer, +1, ¯o_end); - break; - case 2: - dynamic_macro_record_end(r_macro_buffer, macro_pointer, -1, &r_macro_end); - break; - } - macro_id = 0; - } - return false; - case QK_DYNAMIC_MACRO_PLAY_1: - case QK_DYNAMIC_MACRO_PLAY_2: - dprintln("dynamic macro: ignoring macro play key while recording"); - return false; - default: - /* Store the key in the macro buffer and process it normally. */ - switch (macro_id) { - case 1: - dynamic_macro_record_key(macro_buffer, ¯o_pointer, r_macro_end, +1, record); - break; - case 2: - dynamic_macro_record_key(r_macro_buffer, ¯o_pointer, macro_end, -1, record); - break; - } - return true; - break; - } - } - - return true; -} - -#undef DYNAMIC_MACRO_CURRENT_SLOT -#undef DYNAMIC_MACRO_CURRENT_LENGTH -#undef DYNAMIC_MACRO_CURRENT_CAPACITY diff --git a/quantum/process_keycode/process_dynamic_macro.c b/quantum/process_keycode/process_dynamic_macro.c index 214cd80a87..f8e8256ac8 100644 --- a/quantum/process_keycode/process_dynamic_macro.c +++ b/quantum/process_keycode/process_dynamic_macro.c @@ -38,20 +38,44 @@ void dynamic_macro_led_blink(void) { /* User hooks for Dynamic Macros */ -__attribute__((weak)) void dynamic_macro_record_start_user(int8_t direction) { +__attribute__((weak)) bool dynamic_macro_record_start_kb(int8_t direction) { + return dynamic_macro_record_start_user(direction); +} + +__attribute__((weak)) bool dynamic_macro_record_start_user(int8_t direction) { dynamic_macro_led_blink(); + return true; +} + +__attribute__((weak)) bool dynamic_macro_play_kb(int8_t direction) { + return dynamic_macro_play_user(direction); } -__attribute__((weak)) void dynamic_macro_play_user(int8_t direction) { +__attribute__((weak)) bool dynamic_macro_play_user(int8_t direction) { dynamic_macro_led_blink(); + return true; +} + +__attribute__((weak)) bool dynamic_macro_record_key_kb(int8_t direction, keyrecord_t *record) { + return dynamic_macro_record_key_user(direction, record); } -__attribute__((weak)) void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record) { +__attribute__((weak)) bool dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record) { dynamic_macro_led_blink(); + return true; +} + +__attribute__((weak)) bool dynamic_macro_record_end_kb(int8_t direction) { + return dynamic_macro_record_end_user(direction); } -__attribute__((weak)) void dynamic_macro_record_end_user(int8_t direction) { +__attribute__((weak)) bool dynamic_macro_record_end_user(int8_t direction) { dynamic_macro_led_blink(); + return true; +} + +__attribute__((weak)) bool dynamic_macro_valid_key_kb(uint16_t keycode, keyrecord_t *record) { + return dynamic_macro_valid_key_user(keycode, record); } __attribute__((weak)) bool dynamic_macro_valid_key_user(uint16_t keycode, keyrecord_t *record) { @@ -74,7 +98,7 @@ __attribute__((weak)) bool dynamic_macro_valid_key_user(uint16_t keycode, keyrec void dynamic_macro_record_start(keyrecord_t **macro_pointer, keyrecord_t *macro_buffer, int8_t direction) { dprintln("dynamic macro recording: started"); - dynamic_macro_record_start_user(direction); + dynamic_macro_record_start_kb(direction); clear_keyboard(); layer_clear(); @@ -108,7 +132,7 @@ void dynamic_macro_play(keyrecord_t *macro_buffer, keyrecord_t *macro_end, int8_ layer_state_set(saved_layer_state); - dynamic_macro_play_user(direction); + dynamic_macro_play_kb(direction); } /** @@ -134,7 +158,7 @@ void dynamic_macro_record_key(keyrecord_t *macro_buffer, keyrecord_t **macro_poi **macro_pointer = *record; *macro_pointer += direction; } - dynamic_macro_record_key_user(direction, record); + dynamic_macro_record_key_kb(direction, record); dprintf("dynamic macro: slot %d length: %d/%d\n", DYNAMIC_MACRO_CURRENT_SLOT(), DYNAMIC_MACRO_CURRENT_LENGTH(macro_buffer, *macro_pointer), DYNAMIC_MACRO_CURRENT_CAPACITY(macro_buffer, macro2_end)); } @@ -144,7 +168,7 @@ void dynamic_macro_record_key(keyrecord_t *macro_buffer, keyrecord_t **macro_poi * pointer to the end of the macro. */ void dynamic_macro_record_end(keyrecord_t *macro_buffer, keyrecord_t *macro_pointer, int8_t direction, keyrecord_t **macro_end) { - dynamic_macro_record_end_user(direction); + dynamic_macro_record_end_kb(direction); /* Do not save the keys being held when stopping the recording, * i.e. the keys used to access the layer DM_RSTP is on. @@ -220,15 +244,7 @@ void dynamic_macro_stop_recording(void) { macro_id = 0; } -/* Handle the key events related to the dynamic macros. Should be - * called from process_record_user() like this: - * - * bool process_record_user(uint16_t keycode, keyrecord_t *record) { - * if (!process_record_dynamic_macro(keycode, record)) { - * return false; - * } - * <...THE REST OF THE FUNCTION...> - * } +/* Handle the key events related to the dynamic macros. */ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) { if (macro_id == 0) { @@ -271,7 +287,7 @@ bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record) { return false; #endif default: - if (dynamic_macro_valid_key_user(keycode, record)) { + if (dynamic_macro_valid_key_kb(keycode, record)) { /* Store the key in the macro buffer and process it normally. */ switch (macro_id) { case 1: diff --git a/quantum/process_keycode/process_dynamic_macro.h b/quantum/process_keycode/process_dynamic_macro.h index 2f10733cae..984fc0cd41 100644 --- a/quantum/process_keycode/process_dynamic_macro.h +++ b/quantum/process_keycode/process_dynamic_macro.h @@ -37,8 +37,14 @@ void dynamic_macro_led_blink(void); bool process_dynamic_macro(uint16_t keycode, keyrecord_t *record); -void dynamic_macro_record_start_user(int8_t direction); -void dynamic_macro_play_user(int8_t direction); -void dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record); -void dynamic_macro_record_end_user(int8_t direction); +bool dynamic_macro_record_start_kb(int8_t direction); +bool dynamic_macro_record_start_user(int8_t direction); +bool dynamic_macro_play_kb(int8_t direction); +bool dynamic_macro_play_user(int8_t direction); +bool dynamic_macro_record_key_kb(int8_t direction, keyrecord_t *record); +bool dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record); +bool dynamic_macro_record_end_kb(int8_t direction); +bool dynamic_macro_record_end_user(int8_t direction); +bool dynamic_macro_valid_key_kb(uint16_t keycode, keyrecord_t *record); +bool dynamic_macro_valid_key_user(uint16_t keycode, keyrecord_t *record); void dynamic_macro_stop_recording(void); -- cgit v1.2.3 From 21b84596e7c372eeeedcf41a32c6c25379cd8f0e Mon Sep 17 00:00:00 2001 From: フィルターペーパー Date: Mon, 19 Aug 2024 10:18:28 +0800 Subject: Enhance overlapping mouse keys control (#23341) Enhance the overlapping mouse key press acceleration (introduced in #21494) with user preprocessor controls.--- docs/features/mouse_keys.md | 13 +++++++++++++ quantum/mousekey.c | 10 +++++----- quantum/mousekey.h | 10 ++++++++++ 3 files changed, 28 insertions(+), 5 deletions(-) (limited to 'quantum') diff --git a/docs/features/mouse_keys.md b/docs/features/mouse_keys.md index 4cc06c992a..d755084f8e 100644 --- a/docs/features/mouse_keys.md +++ b/docs/features/mouse_keys.md @@ -203,6 +203,19 @@ Tips: * Keep `MOUSEKEY_MOVE_DELTA` at 1. This allows precise movements before the gliding effect starts. * Mouse wheel options are the same as the default accelerated mode, and do not use inertia. +### Overlapping mouse key control + +When additional overlapping mouse key is pressed, the mouse cursor will continue in a new direction with the same acceleration. The following settings can be used to reset the acceleration with new overlapping keys for more precise control if desired: + +|Define |Default |Description | +|------------------------------|----------------------|-----------------------------------------------------------------------| +|`MOUSEKEY_OVERLAP_RESET` |undefined |Enables overlapping mouse key control | +|`MOUSEKEY_OVERLAP_MOVE_DELTA` |`MOUSEKEY_MOVE_DELTA` |Step size of reset movement acceleration | +|`MOUSEKEY_OVERLAP_WHEEL_DELTA`|`MOUSEKEY_WHEEL_DELTA`|Step size of reset mouse wheel acceleration | +|`MOUSEKEY_OVERLAP_INTERVAL` |`MOUSEKEY_INTERVAL` |Reset time between cursor movements in milliseconds (Kinetic mode only)| + +?> This feature will not be applied on Inertial mode + ## Use with PS/2 Mouse and Pointing Device Mouse keys button state is shared with [PS/2 mouse](ps2_mouse) and [pointing device](pointing_device) so mouse keys button presses can be used for clicks and drags. diff --git a/quantum/mousekey.c b/quantum/mousekey.c index 8683cfdffa..9649943a0d 100644 --- a/quantum/mousekey.c +++ b/quantum/mousekey.c @@ -391,18 +391,18 @@ void mousekey_on(uint8_t code) { } # endif -# ifndef MOUSEKEY_INERTIA +# if defined(MOUSEKEY_OVERLAP_RESET) && !defined(MOUSEKEY_INERTIA) // If mouse report is not zero, the current mousekey press is overlapping // with another. Restart acceleration for smoother directional transition. if (mouse_report.x || mouse_report.y || mouse_report.h || mouse_report.v) { # ifdef MK_KINETIC_SPEED - mouse_timer = timer_read() - (MOUSEKEY_INTERVAL << 2); + mouse_timer = timer_read() - MOUSEKEY_OVERLAP_INTERVAL; # else - mousekey_repeat = MOUSEKEY_MOVE_DELTA; - mousekey_wheel_repeat = MOUSEKEY_WHEEL_DELTA; + mousekey_repeat = MOUSEKEY_OVERLAP_MOVE_DELTA; + mousekey_wheel_repeat = MOUSEKEY_OVERLAP_WHEEL_DELTA; # endif } -# endif // ifndef MOUSEKEY_INERTIA +# endif // defined(MOUSEKEY_OVERLAP_RESET) && !defined(MOUSEKEY_INERTIA) # ifdef MOUSEKEY_INERTIA diff --git a/quantum/mousekey.h b/quantum/mousekey.h index 73380b743a..e7a790b9a9 100644 --- a/quantum/mousekey.h +++ b/quantum/mousekey.h @@ -174,6 +174,16 @@ along with this program. If not, see . #endif /* #ifndef MK_3_SPEED */ +#ifndef MOUSEKEY_OVERLAP_MOVE_DELTA +# define MOUSEKEY_OVERLAP_MOVE_DELTA MOUSEKEY_MOVE_DELTA +#endif +#ifndef MOUSEKEY_OVERLAP_WHEEL_DELTA +# define MOUSEKEY_OVERLAP_WHEEL_DELTA MOUSEKEY_WHEEL_DELTA +#endif +#ifndef MOUSEKEY_OVERLAP_INTERVAL +# define MOUSEKEY_OVERLAP_INTERVAL MOUSEKEY_INTERVAL +#endif + #ifdef __cplusplus extern "C" { #endif -- cgit v1.2.3